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 unten.

Bemerkung

Die Verwendung von Ganzzahlen in Anführungszeichen als Eingabewerte ist veraltet.

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.

  • 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 string_expr). 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).

scale

Skalierungsbezeichner (nur bei numeric_expr). 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.

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.

Nutzungshinweise

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

    • Bei Eingabe von NULL ist das Ergebnis NULL.

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

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

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

    • Bei numeric_expr: 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.

    • variant_expr:

      • 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 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 die Konvertierung wie bei numeric_expr ausgefü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. (Weitere Informationen dazu finden Sie unter TO_TIMESTAMP / TO_TIMESTAMP_*.) 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(parse_json(31000000));
select parse_json(31000000)::timestamp_ntz;
        Copy

        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;
        Copy

        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.

      Bemerkung

      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, TO_TIME oder TO_TIMESTAMP aufrufen.

    • 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.

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                 |
+-----------------------------------------+
Copy

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                                   |
+-----------------------------------------------------------------+
Copy

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';
+----------------------------------+
| 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               |
+---------------------------------------+
Copy

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';
+----------------------------------+
| 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                               |
+-------------------------------------------------------+
Copy

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:

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

CREATE TABLE demo1 (
    description VARCHAR,
    value VARCHAR -- yes, 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
    ;
+--------------+-------------------+-------------------------+----------------+
| 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     |
+--------------+-------------------+-------------------------+----------------+
Copy

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           |
+-------------------------+------------------------------+-----------------------------------+
Copy
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              |
+-------------------------+---------------------------------+--------------------------------------+
Copy
Sprache: Deutsch