Kategorien:

Konvertierungsfunktionen, Datums- und Uhrzeitfunktionen

TO_TIMESTAMP / TO_TIMESTAMP_*

Konvertiert einen Eingabeausdruck in den entsprechenden Zeitstempel:

  • TO_TIMESTAMP_LTZ (Zeitstempel mit lokaler Zeitzone)

  • TO_TIMESTAMP_NTZ (Zeitstempel ohne Zeitzone)

  • TO_TIMESTAMP_TZ (Zeitstempel mit Zeitzone)

Bemerkung

TO_TIMESTAMP wird anhand des Sitzungsparameters TIMESTAMP_TYPE_MAPPING einer der anderen Zeitstempelfunktionen zugeordnet. Der Standardwert für den Parameter ist TIMESTAMP_NTZ, sodass TO_TIMESTAMP standardmäßig TO_TIMESTAMP_NTZ zugeordnet wird.

Siehe auch:

TRY_TO_TIMESTAMP / TRY_TO_TIMESTAMP_*,

AS_TIMESTAMP_*, IS_TIMESTAMP_*,

TO_DATE , DATE, TO_TIME , TIME

Syntax

timestampFunction ( <numeric_expr> [ , <scale> ] )

timestampFunction ( <date_expr> )

timestampFunction ( <timestamp_expr> )

timestampFunction ( <string_expr> [ , <format> ] )

timestampFunction ( '<integer>' )

timestampFunction ( <variant_expr> )
Copy

Wobei:

timestampFunction ::=
    TO_TIMESTAMP | TO_TIMESTAMP_LTZ | TO_TIMESTAMP_NTZ | TO_TIMESTAMP_TZ
Copy

Argumente

Benötigt:

Eine der folgenden Optionen:

numeric_expr

Eine Anzahl von Sekunden (wenn Skalierung = 0 oder nicht vorhanden) oder Sekundenbruchteilen seit dem Beginn der Unix-Epoche (1970-01-01 00:00:00 UTC). Wenn ein nicht ganzzahliger Dezimalausdruck eingegeben wird, wird die Skalierung des Ergebnisses übernommen.

date_expr

Ein Datum, das in einen Zeitstempel konvertiert werden soll.

timestamp_expr

Ein Zeitstempel, der in einen anderen Zeitstempel konvertiert werden soll (z. B. Konvertieren von TIMESTAMP_LTZ in TIMESTAMP_NTZ).

string_expr

Zeichenfolge, aus der ein Zeitstempel extrahiert werden soll, z. B. '2019-01-31 01:02:03.004'.

'integer'

Ein Ausdruck, der eine Zeichenfolge ergibt, die eine Ganzzahl enthält, z. B. '15000000'. Abhängig von der Größenordnung der Zeichenfolge kann der Wert als Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden interpretiert werden. Weitere Informationen dazu finden Sie in den Nutzungshinweisen.

variant_expr

Ein Ausdruck vom Typ VARIANT. Der VARIANT-Ausdruck muss einen der folgenden Typen enthalten:

  • Zeichenfolge, aus der ein Zeitstempel extrahiert werden soll.

  • Ein Zeitstempel.

  • Eine Ganzzahl, die die Anzahl der Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden repräsentiert.

  • Eine Zeichenfolge, die eine Ganzzahl enthält, die die Anzahl der Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden repräsentiert.

Obwohl TO_TIMESTAMP einen DATE-Wert akzeptiert, akzeptiert es keinen DATE innerhalb eines VARIANT.

Optional:

format

Formatbezeichner (nur bei string_expr). Weitere Informationen dazu finden Sie unter Datums- und Uhrzeitformate in Konvertierungsfunktionen.

Der Standardwert ist der aktuelle Wert des Parameters TIMESTAMP_INPUT_FORMAT (Standard: AUTO).

scale

Skalierungsbezeichner (nur bei numeric_expr). Wenn angegeben, wird die Skalierung der angegebenen Zahlen definiert. Beispiel:

  • Bei Sekunden: scale = 0.

  • Bei Millisekunden: scale = 3.

  • Bei Mikrosekunden: scale = 6.

  • Bei Nanosekunden: scale = 9.

Standard: 0

Rückgabewerte

Der Datentyp des zurückgegebenen Werts ist einer der TIMESTAMP-Datentypen. Der Datentyp ist standardmäßig TIMESTAMP_NTZ. Sie können dies ändern, indem Sie den Sitzungsparameter TIMESTAMP_TYPE_MAPPING festlegen.

Wenn der Eingabewert NULL ist, ist auch das Ergebnis NULL.

Nutzungshinweise

  • Diese Funktionsfamilie gibt Zeitstempelwerte zurück, wobei Folgendes gilt:

    • Bei string_expr: Ein Zeitstempel, der von einer gegebenen Zeichenfolge repräsentiert wird. Wenn die Zeichenfolge keine Zeitkomponente enthält, wird Mitternacht verwendet.

    • Bei date_expr: Es wird ein Zeitstempel verwendet, der Mitternacht eines bestimmten Tages repräsentiert, entsprechend der spezifischen Zuordnungssemantik von Zeitstempeln (NTZ/LTZ/TZ).

    • Bei timestamp_expr: Ein Zeitstempel, der möglicherweise eine andere Zuordnung aufweist als der Quellzeitstempel.

    • Bei numeric_expr: Ein Zeitstempel, der die vom Benutzer angegebene Anzahl von Sekunden (oder Sekundenbruchteilen) repräsentiert. Zum Erstellen des Ergebnisses wird immer die UTC-Zeit verwendet.

    • variant_expr:

      • Wenn der VARIANT-Ausdruck einen JSON-Nullwert enthält, ist das Ergebnis NULL.

      • Wenn der VARIANT-Ausdruck einen Zeitstempelwert derselben Art wie das Ergebnis hat, bleibt dieser Wert unverändert.

      • Wenn der VARIANT-Ausdruck einen Zeitstempelwert anderer Art enthält, erfolgt die Konvertierung auf dieselbe Weise wie bei timestamp_expr.

      • Wenn der VARIANT-Ausdruck eine Zeichenfolge enthält, wird eine Konvertierung aus einem Zeichenfolgenwert durchgeführt (durch automatisches Formatieren).

      • Wenn der VARIANT-Ausdruck eine Zahl enthält, wird eine Konvertierung aus einem numeric_expr durchgeführt.

        Bemerkung

        Wenn ein INTEGER-Wert direkt in TIMESTAMP_NTZ umgewandelt wird, wird die Ganzzahl als die Anzahl der Sekunden seit Beginn der Linux-Epoche behandelt. Die lokale Zeitzone wird nicht berücksichtigt. Wenn aber der INTEGER-Wert wie im Beispiel unten in einem VARIANT-Wert gespeichert ist, dann erfolgt die Konvertierung indirekt und wird von der lokalen Zeitzone beeinflusst, obwohl das Endergebnis TIMESTAMP_NTZ lautet:

        SELECT TO_TIMESTAMP(31000000);
SELECT TO_TIMESTAMP(PARSE_JSON(31000000));
SELECT PARSE_JSON(31000000)::TIMESTAMP_NTZ;
        Copy

        Der von der ersten Abfrage zurückgegebene Zeitstempel unterscheidet sich von der Zeit, die von der zweiten und dritten Abfrage zurückgegeben wird.

        Um eine Konvertierung unabhängig von der lokalen Zeitzone durchzuführen, fügen Sie im Ausdruck eine explizite Umwandlung in eine Ganzzahl hinzu, wie unten gezeigt:

        SELECT TO_TIMESTAMP(31000000);
SELECT TO_TIMESTAMP(PARSE_JSON(31000000)::INT);
SELECT PARSE_JSON(31000000)::INT::TIMESTAMP_NTZ;
        Copy

        Der von allen drei Abfragen zurückgegebene Zeitstempel ist derselbe. Dies gilt unabhängig davon, ob die Umwandlung in TIMESTAMP_NTZ oder der Aufruf der Funktion TO_TIMESTAMP_NTZ erfolgt. Dies gilt auch für den Aufruf von TO_TIMESTAMP, wenn der Parameter TIMESTAMP_TYPE_MAPPING auf TIMESTAMP_NTZ gesetzt ist.

        Ein Beispiel mit Ausgabe finden Sie in den Beispielen am Ende dieses Themas.

    • Wenn eine Konvertierung nicht möglich ist, wird ein Fehler zurückgegeben.

  • Bei Zeitstempeln mit Zeitzonen wirkt sich die Einstellung des Parameters TIMEZONE auf den Rückgabewert aus. Der zurückgegebene Zeitstempel wird in der Zeitzone der Sitzung angegeben.

  • Das Anzeigeformat für Zeitstempel in der Ausgabe wird durch das Zeitstempel-Ausgabeformat bestimmt, das der Funktion entspricht (TIMESTAMP_OUTPUT_FORMAT, TIMESTAMP_LTZ_OUTPUT_FORMAT, TIMESTAMP_NTZ_OUTPUT_FORMAT oder TIMESTAMP_TZ_OUTPUT_FORMAT).

  • Wenn das Format des Eingabeparameters eine Zeichenfolge ist, die eine Ganzzahl enthält:

    • Nachdem die Zeichenfolge in eine Ganzzahl konvertiert wurde, wird die Ganzzahl als Anzahl von Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden nach dem Beginn der Unix-Epoche behandelt (1970-01-01 00:00:00.000000000 UTC).

      • Wenn die Ganzzahl kleiner als 31.536.000.000 (die Anzahl der Millisekunden eines Jahres) ist, wird der Wert als Anzahl der Sekunden behandelt.

      • Wenn der Wert größer oder gleich 31.536.000.000 und kleiner als 31.536.000.000.000 ist, wird der Wert als Millisekunden behandelt.

      • Wenn der Wert größer oder gleich 31.536.000.000.000 und kleiner als 31.536.000.000.000.000 ist, wird der Wert als Mikrosekunde behandelt.

      • Wenn der Wert größer oder gleich 31.536.000.000.000.000 ist, wird der Wert als Nanosekunde behandelt.

    • Wenn mehr als eine Zeile ausgewertet wird (z. B. bei Eingabe der Spaltenname einer Tabelle, die mehr als eine Zeile enthält), bestimmt der erste verarbeitete Wert, ob alle nachfolgenden Werte als Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden behandelt werden.

  • Wenn Sie die Funktion TO_TIMESTAMP_NTZ oder TRY_TO_TIMESTAMP_NTZ verwenden, um einen Zeitstempel mit Zeitzoneninformationen zu konvertieren, gehen die Zeitzoneninformationen verloren. Wenn der Zeitstempel dann wieder in einen Zeitstempel mit Zeitzoneninformationen konvertiert wird (z. B. mit der Funktion TO_TIMESTAMP_TZ), können die Zeitzoneninformationen nicht wiederhergestellt werden.

Beispiele

Dieses Beispiel zeigt, dass TO_TIMESTAMP_TZ einen Zeitstempel erstellt, der eine Zeitzone aus der Sitzung enthält, der Wert aus TO_TIMESTAMP_NTZ jedoch keine Zeitzone aufweist:

ALTER SESSION SET TIMEZONE = 'America/Los_Angeles';
Copy
SELECT TO_TIMESTAMP_TZ('2024-04-05 01:02:03');
Copy
+----------------------------------------+
| TO_TIMESTAMP_TZ('2024-04-05 01:02:03') |
|----------------------------------------|
| 2024-04-05 01:02:03.000 -0700          |
+----------------------------------------+

SELECT TO_TIMESTAMP_NTZ('2024-04-05 01:02:03');
Copy
+-----------------------------------------+
| TO_TIMESTAMP_NTZ('2024-04-05 01:02:03') |
|-----------------------------------------|
| 2024-04-05 01:02:03.000                 |
+-----------------------------------------+

Das folgende Beispiel zeigt, wie verschiedene Formate die Analyse eines mehrdeutigen Datums beeinflussen können: Angenommen, TIMESTAMP_TZ_OUTPUT_FORMAT ist nicht eingestellt, sodass TIMESTAMP_OUTPUT_FORMAT verwendet wird und auf den Standardwert (YYYY-MM-DD HH24:MI:SS.FF3 TZHTZM) eingestellt ist.

Dieses Beispiel zeigt die Ergebnisse, wenn das Eingabeformat mm/dd/yyyy hh24:mi:ss (Monat/Tag/Jahr) ist:

SELECT TO_TIMESTAMP_TZ('04/05/2024 01:02:03', 'mm/dd/yyyy hh24:mi:ss');
Copy
+-----------------------------------------------------------------+
| TO_TIMESTAMP_TZ('04/05/2024 01:02:03', 'MM/DD/YYYY HH24:MI:SS') |
|-----------------------------------------------------------------|
| 2024-04-05 01:02:03.000 -0700                                   |
+-----------------------------------------------------------------+

Dieses Beispiel zeigt die Ergebnisse, wenn das Eingabeformat dd/mm/yyyy hh24:mi:ss (Tag/Monat/Jahr) ist:

SELECT TO_TIMESTAMP_TZ('04/05/2024 01:02:03', 'dd/mm/yyyy hh24:mi:ss');
Copy
+-----------------------------------------------------------------+
| TO_TIMESTAMP_TZ('04/05/2024 01:02:03', 'DD/MM/YYYY HH24:MI:SS') |
|-----------------------------------------------------------------|
| 2024-05-04 01:02:03.000 -0700                                   |
+-----------------------------------------------------------------+

Dieses Beispiel zeigt, wie Sie eine numerische Eingabe verwenden können, die ungefähr 40 Jahre darstellt, beginnend mit dem 1. Januar 1970 um Mitternacht (dem Beginn der Unix-Epoche). Die Dezimalstellenzahl wird nicht angegeben, daher wird die Standard-Dezimalstellenzahl 0 (Sekunden) verwendet.

ALTER SESSION SET TIMESTAMP_OUTPUT_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF9 TZH:TZM';
Copy
SELECT TO_TIMESTAMP_NTZ(40 * 365.25 * 86400);
Copy
+---------------------------------------+
| TO_TIMESTAMP_NTZ(40 * 365.25 * 86400) |
|---------------------------------------|
| 2010-01-01 00:00:00.000               |
+---------------------------------------+

Dieses Beispiel ähnelt dem vorangegangenen Beispiel, gibt aber den Wert als Millisekunden an, indem es eine Dezimalstellenzahl von 3 angibt:

SELECT TO_TIMESTAMP_NTZ(40 * 365.25 * 86400 * 1000 + 456, 3);
Copy
+-------------------------------------------------------+
| TO_TIMESTAMP_NTZ(40 * 365.25 * 86400 * 1000 + 456, 3) |
|-------------------------------------------------------|
| 2010-01-01 00:00:00.456                               |
+-------------------------------------------------------+

Dieses Beispiel zeigt, wie sich die Ergebnisse ändern, wenn für denselben numerischen Wert verschiedene Dezimalstellenzahlen angegeben werden:

SELECT TO_TIMESTAMP(1000000000, 0) AS "Scale in seconds",
       TO_TIMESTAMP(1000000000, 3) AS "Scale in milliseconds",
       TO_TIMESTAMP(1000000000, 6) AS "Scale in microseconds",
       TO_TIMESTAMP(1000000000, 9) AS "Scale in nanoseconds";
Copy
+-------------------------+-------------------------+-------------------------+-------------------------+
| Scale in seconds        | Scale in milliseconds   | Scale in microseconds   | Scale in nanoseconds    |
|-------------------------+-------------------------+-------------------------+-------------------------|
| 2001-09-09 01:46:40.000 | 1970-01-12 13:46:40.000 | 1970-01-01 00:16:40.000 | 1970-01-01 00:00:01.000 |
+-------------------------+-------------------------+-------------------------+-------------------------+

Das folgende Beispiel zeigt, wie die Funktion die zu verwendenden Einheiten (Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden) auf der Grundlage der Größe des Wertes bestimmt, wenn die Eingabe eine Zeichenfolge ist, die eine Ganzzahl enthält:

Erstellen und laden der Tabelle mit Zeichenfolgen, die Integer-Werte in verschiedenen Bereichen enthalten:

CREATE OR REPLACE TABLE demo1 (
  description VARCHAR,
  value VARCHAR -- string rather than bigint
);

INSERT INTO demo1 (description, value) VALUES
  ('Seconds',      '31536000'),
  ('Milliseconds', '31536000000'),
  ('Microseconds', '31536000000000'),
  ('Nanoseconds',  '31536000000000000');
Copy

Übergeben der Zeichenfolge an die Funktion:

SELECT description,
       value,
       TO_TIMESTAMP(value),
       TO_DATE(value)
  FROM demo1
  ORDER BY value;
Copy
+--------------+-------------------+-------------------------+----------------+
| DESCRIPTION  | VALUE             | TO_TIMESTAMP(VALUE)     | TO_DATE(VALUE) |
|--------------+-------------------+-------------------------+----------------|
| Seconds      | 31536000          | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Milliseconds | 31536000000       | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Microseconds | 31536000000000    | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Nanoseconds  | 31536000000000000 | 1971-01-01 00:00:00.000 | 1971-01-01     |
+--------------+-------------------+-------------------------+----------------+

Im folgenden Beispiel werden Werte in TIMESTAMP_NTZ umgewandelt. Das Beispiel zeigt den Unterschied im Verhalten zwischen der Verwendung einer Ganzzahl und eines Variant-Werts, der eine Ganzzahl enthält:

SELECT 0::TIMESTAMP_NTZ, PARSE_JSON(0)::TIMESTAMP_NTZ, PARSE_JSON(0)::INT::TIMESTAMP_NTZ;
Copy
+-------------------------+------------------------------+-----------------------------------+
| 0::TIMESTAMP_NTZ        | PARSE_JSON(0)::TIMESTAMP_NTZ | PARSE_JSON(0)::INT::TIMESTAMP_NTZ |
|-------------------------+------------------------------+-----------------------------------|
| 1970-01-01 00:00:00.000 | 1969-12-31 16:00:00.000      | 1970-01-01 00:00:00.000           |
+-------------------------+------------------------------+-----------------------------------+

Die zurückgegebenen Zeitstempel stimmen für eine Ganzzahl und für einen in eine Ganzzahl umgewandelten Variant-Wert in der ersten und dritten Spalte überein, aber der zurückgegebene Zeitstempel ist für den Variant-Wert, der nicht in eine Ganzzahl umgewandelt wurde, in der zweiten Spalte unterschiedlich. Weitere Informationen dazu finden Sie unter Nutzungshinweise.

Das gleiche Verhalten gilt beim Aufrufen der Funktion TO_TIMESTAMP_NTZ:

SELECT TO_TIMESTAMP_NTZ(0), TO_TIMESTAMP_NTZ(PARSE_JSON(0)), TO_TIMESTAMP_NTZ(PARSE_JSON(0)::INT);
Copy
+-------------------------+---------------------------------+--------------------------------------+
| TO_TIMESTAMP_NTZ(0)     | TO_TIMESTAMP_NTZ(PARSE_JSON(0)) | TO_TIMESTAMP_NTZ(PARSE_JSON(0)::INT) |
|-------------------------+---------------------------------+--------------------------------------|
| 1970-01-01 00:00:00.000 | 1969-12-31 16:00:00.000         | 1970-01-01 00:00:00.000              |
+-------------------------+---------------------------------+--------------------------------------+
Sprache: Deutsch