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> )

Wobei:

timestampFunction ::=
    TO_TIMESTAMP | TO_TIMESTAMP_LTZ | TO_TIMESTAMP_NTZ | TO_TIMESTAMP_TZ

Argumente

Benötigt:

Eine der folgenden Optionen:

numerischer_Ausdruck

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.

Datumsausdruck

Ein Datum, das in einen Zeitstempel konvertiert werden soll.

Zeitstempelausdruck

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

Zeichenfolgenausdruck

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

Ganzzahl

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 Details dazu finden Sie in den Nutzungshinweisen unten.

Variant-Ausdruck

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

  • Zeichenfolge, aus der ein Zeitstempel extrahiert werden soll.

  • Ein Zeitstempel.

  • Ganzzahl von Sekunden oder Millisekunden

  • Eine Zeichenfolge mit einer Ganzzahl von Sekunden oder Millisekunden.

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

Optional:

Format

Formatbezeichner (nur bei Zeichenfolgenausdruck). Weitere Informationen dazu finden Sie unter Konvertierungsfunktionen im Abschnitt Datums- und Uhrzeitformate.

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

Skalierung

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

  • Für Sekunden: Skalierung = 0.

  • Für Millisekunden: Skalierung = 3.

  • Für Nanosekunden: Skalierung = 9.

Nutzungshinweise

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

    • Bei Eingabe von NULL ist das Ergebnis NULL.

    • Bei einem Zeichenfolgenausdruck: Zeitstempel wird durch eine angegebene Zeichenfolge dargestellt. Wenn die Zeichenfolge keine Zeitkomponente enthält, wird Mitternacht verwendet.

    • Bei einem Datumsausdruck: Zeitstempel, der Mitternacht eines bestimmten Tages darstellt, wird entsprechend der jeweiligen Semantik der Zeitstempelkonfiguration (NTZ/LTZ/TZ) verwendet.

    • Bei einem Zeitstempelausdruck: ein Zeitstempel, der möglicherweise eine andere Konfiguration aufweist als der Quellzeitstempel.

    • Bei einem numerischen_Ausdruck: ein Zeitstempel, der die vom Benutzer angegebene Anzahl von Sekunden (oder Sekundenbruchteilen) darstellt. Beachten Sie, dass zur Erstellung des Ergebnisses immer die Zeit UTC verwendet wird.

    • Bei einem Variant-Ausdruck:

      • Wenn der Variant-Ausdruck einen JSON-null-Wert enthält, lautet das Ergebnis NULL.

      • Wenn der Variant-Ausdruck einen Zeitstempelwert derselben Art wie das Ergebnis hat, bleibt dieser Wert erhalten.

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

      • 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 die Konvertierung wie bei numerischer_Ausdruck durchgeführt.

        Bemerkung

        When an INTEGER value is cast directly to TIMESTAMP_NTZ, the integer is treated as the number of seconds since the beginning of the Linux epoch, and the local time zone is not taken into account. (For details, see TO_TIMESTAMP / TO_TIMESTAMP_*.) However, if the INTEGER value is stored inside a VARIANT value, for example as shown below, then the conversion is indirect, and is affected by the local time zone, even though the final result is TIMESTAMP_NTZ:

        select to_timestamp(parse_json(31000000));
        select parse_json(31000000)::timestamp_ntz;
        

        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(parse_json(31000000)::int);
        select parse_json(31000000)::int::timestamp_ntz;
        

        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.

  • 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 (Eingabe ist z. B. der Spaltenname einer Tabelle, die mehr als zwei Zeilen enthält), bestimmt der erste verarbeitete Wert, ob alle nachfolgenden Werte als Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden behandelt werden.

      Wenn der erste Wert größer oder gleich 31.536.000.000 ist, werden alle Werte als Millisekunden behandelt, auch wenn einige verbleibende Werte kleiner als 31.536.000.000 sind. Eine ähnliche Logik gilt für Mikrosekunden und Nanosekunden.

    Vorsicht

    Derzeit werden negative Werte immer als Sekunden behandelt. Beispielsweise wird -31.536.000.000.000.000.000 als eine Anzahl von Sekunden vor dem Jahr 1970 behandelt, obwohl seine Skala impliziert, dass es als Nanosekunden verwendet werden soll.

    Dieses Verhalten kann sich in Zukunft möglicherweise ändern.

    Vorsicht

    Warnung vor Veralten: In zukünftigen Snowflake-Versionen werden Ganzzahlen in Zeichenfolgen möglicherweise automatisch als Sekunden und nicht als Millisekunden, Mikrosekunden oder Nanosekunden interpretiert. Snowflake empfiehlt, dass Sie bei Zeichenfolgen, die nur Ganzzahlen enthalten, welche als Sekunden interpretiert werden sollen, TO_DATE oder TO_TIMESTAMP aufrufen.

Beispiele

Dies 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';
+----------------------------------+
| status                           |
|----------------------------------|
| Statement executed successfully. |
+----------------------------------+
SELECT TO_TIMESTAMP_TZ('2013-04-05 01:02:03');
+----------------------------------------+
| TO_TIMESTAMP_TZ('2013-04-05 01:02:03') |
|----------------------------------------|
| 2013-04-05 01:02:03.000 -0700          |
+----------------------------------------+

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

Dies zeigt, wie verschiedene Formate die Analyse eines mehrdeutigen Datums beeinflussen können:

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

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

Dies 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 EPOCH):

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

Dieses Beispiel ähnelt dem vorherigen, liefert den Wert jedoch in Millisekunden, indem ein scale-Wert von 3 angegeben wird:

ALTER SESSION SET TIMESTAMP_OUTPUT_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF9 TZH:TZM TZD';
+----------------------------------+
| status                           |
|----------------------------------|
| Statement executed successfully. |
+----------------------------------+
SELECT TO_TIMESTAMP_NTZ(40 * 365.25 * 86400 * 1000 + 456, 3);
+-------------------------------------------------------+
| TO_TIMESTAMP_NTZ(40 * 365.25 * 86400 * 1000 + 456, 3) |
|-------------------------------------------------------|
| 2010-01-01 00:00:00.456                               |
+-------------------------------------------------------+

Dieses Beispiel zeigt, wie der erste konvertierte Wert steuern kann, ob die nachfolgenden Werte als Sekunden oder Millisekunden interpretiert werden:

Erstellen und laden Sie die Tabelle:

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

Vergleichen Sie die Ausgabe der folgenden beiden Abfragen. Der einzige Unterschied zwischen den beiden ist die Reihenfolge der Zeilen:

SELECT 
       description, 
       value, 
       TO_TIMESTAMP(value), 
       TO_DATE(value)
    FROM demo1
    ORDER BY value ASC
    ;
+--------------+-------------+-------------------------+----------------+
| DESCRIPTION  | VALUE       | TO_TIMESTAMP(VALUE)     | TO_DATE(VALUE) |
|--------------+-------------+-------------------------+----------------|
| Seconds      | 31535999999 | 2969-05-02 23:59:59.000 | 2969-05-02     |
| Milliseconds | 31536000000 | 2969-05-03 00:00:00.000 | 2969-05-03     |
+--------------+-------------+-------------------------+----------------+
SELECT 
       description, 
       value, 
       TO_TIMESTAMP(value), 
       TO_DATE(value)
    FROM demo1
    ORDER BY value DESC
    ;
+--------------+-------------+-------------------------+----------------+
| DESCRIPTION  | VALUE       | TO_TIMESTAMP(VALUE)     | TO_DATE(VALUE) |
|--------------+-------------+-------------------------+----------------|
| Milliseconds | 31536000000 | 1971-01-01 00:00:00.000 | 1971-01-01     |
| Seconds      | 31535999999 | 1970-12-31 23:59:59.999 | 1970-12-31     |
+--------------+-------------+-------------------------+----------------+

Das folgende 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;
+-------------------------+------------------------------+-----------------------------------+
| 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           |
+-------------------------+------------------------------+-----------------------------------+
SELECT TO_TIMESTAMP_NTZ(0), TO_TIMESTAMP_NTZ(PARSE_JSON(0)), TO_TIMESTAMP_NTZ(PARSE_JSON(0)::INT);
+-------------------------+---------------------------------+--------------------------------------+
| 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              |
+-------------------------+---------------------------------+--------------------------------------+