Kategorien:

Konvertierungsfunktionen, Datums- und Uhrzeitfunktionen

TO_TIME , TIME

Konvertiert einen Eingabeausdruck in eine Zeit. Wenn die Eingabe NULL lautet, wird NULL zurückgegeben.

Siehe auch:

TRY_TO_TIME

Syntax

TO_TIME( <string_expr> [, <format> ] )
TO_TIME( <timestamp_expr> )
TO_TIME( '<integer>' )
TO_TIME( <variant_expr> )

TIME( <string_expr> )
TIME( <timestamp_expr> )
TIME( '<integer>' )
TIME( <variant_expr> )

Argumente

Erforderlich:

string_expr oder timestamp_expr oder variant_expr oder integer

Ausdruck, der in eine Uhrzeit umgewandelt werden soll:

  • string_expr ist das Ergebnis der Umwandlung der Zeichenfolge in eine Uhrzeit.

  • timestamp_expr ist die Uhrzeitkomponente des Eingabewerts.

  • 'integer' ist eine Zeichenfolge, die eine Ganzzahl (Integer) enthält, wobei die Ganzzahl als Anzahl von Sekunden, Millisekunden, Mikrosekunden oder Nanosekunden nach Beginn der Unix-Epoche behandelt wird. Weitere Informationen dazu finden Sie in den Nutzungshinweisen unten.

    Für diesen Zeitstempel erhält die Funktion die Anzahl der Sekunden nach dem Beginn der Unix-Epoche. Die Funktion führt eine Modulo-Operation aus, um den Rest aus der Division dieser Zahl durch die Anzahl der Sekunden eines Tages (86400) zu erhalten:

    number_of_seconds % 86400

    Die Funktion interpretiert diesen Rest als die Anzahl der Sekunden nach Mitternacht.

    Angenommen, der Wert ist 31536002789.

    1. Ausgehend von der Größe dieses Wertes verwendet die Funktion Millisekunden als Zeiteinheit und bestimmt, dass der Wert für 1971-01-01 00:00:02.789 steht.

    2. Die Funktion ermittelt für diesen Wert die Anzahl der Sekunden nach der Unix-Epoche (31536002).

    3. Die Funktion erhält den Rest aus der Division dieser Zahl durch die Anzahl der Sekunden eines Tages (31536002 % 86400).

    4. Die Funktion verwendet den Rest (2) als die Anzahl der Sekunden nach Mitternacht. Der resultierende Wert ist 00:00:02.

    Bemerkung

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

  • variant_expr:

    • Wenn der Variant-Wert eine Zeichenfolge im TIME-Format (‚HH:MI:SS‘) enthält, wird eine Zeichenfolgenkonvertierung durchgeführt.

    • Wenn der Variant-Wert eine Zeichenfolge im INTEGER-Format enthält, wird eine Zeichenfolgenkonvertierung durchgeführt und der Wert als Anzahl der Sekunden seit Mitternacht behandelt (Modulus von 86.400, falls erforderlich).

    • Wenn der Variant-Wert einen JSON-null-Wert enthält, ist die Ausgabe NULL.

Bei allen anderen Werten wird ein Konvertierungsfehler generiert.

Optional:

format

Uhrzeitformatbezeichner für string_expr oder AUTO, was angibt, dass Snowflake das zu verwendende Format automatisch ermitteln soll. Weitere Informationen dazu finden Sie unter Datums- und Uhrzeitformate in Konvertierungsfunktionen.

Standardwert: aktueller Wert des Sitzungsparameters TIME_INPUT_FORMAT (normalerweise AUTO)

Rückgabewerte

Der Datentyp des zurückgegebenen Werts ist TIME.

Nutzungshinweise

  • Wenn das Format des Eingabeparameters eine Zeichenfolge ist, die eine Ganzzahl (Integer) enthält, wird die Maßeinheit für den Wert (Sekunden, Mikrosekunden, Millisekunden oder Nanosekunden) wie folgt bestimmt:

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

    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.

    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.

  • Im Gegensatz zur Funktion TO_TIME unterstützt die Funktion TIME den optionalen Parameter format nicht.

Beispiele

Diese Beispiele veranschaulichen die Funktion TO_TIME.

SELECT TO_TIME('13:30:00'), TIME('13:30:00');
+---------------------+------------------+
| TO_TIME('13:30:00') | TIME('13:30:00') |
|---------------------+------------------|
| 13:30:00            | 13:30:00         |
+---------------------+------------------+
SELECT TO_TIME('13:30:00.000'), TIME('13:30:00.000');
+-------------------------+----------------------+
| TO_TIME('13:30:00.000') | TIME('13:30:00.000') |
|-------------------------+----------------------|
| 13:30:00                | 13:30:00             |
+-------------------------+----------------------+

In diesem Beispiel wird gezeigt, wie mit der Funktion TO_TIME andere Feldtrennzeichen als die Standard-Doppelpunkte verarbeitet werden (in diesem Beispiel wird das Punktzeichen als Trennzeichen zwischen Stunden und Minuten sowie zwischen Minuten und Sekunden verwendet):

SELECT TO_TIME('11.15.00', 'HH24.MI.SS');
+-----------------------------------+
| TO_TIME('11.15.00', 'HH24.MI.SS') |
|-----------------------------------|
| 11:15:00                          |
+-----------------------------------+

Dieses Beispiel zeigt, wie die Funktion TO_TIME eine Zeichenfolge interpretiert, die einen Integer-Wert enthält:

CREATE TABLE demo1_time (
    description VARCHAR,
    value VARCHAR -- yes, string rather than bigint
    );
+----------------------------------------+
| status                                 |
|----------------------------------------|
| Table DEMO1_TIME successfully created. |
+----------------------------------------+
INSERT INTO demo1_time (description, value) VALUES
   ('Seconds',      '31536001'),
   ('Milliseconds', '31536002400'),
   ('Microseconds', '31536003600000'),
   ('Nanoseconds',  '31536004900000000')
   ;
+-------------------------+
| number of rows inserted |
|-------------------------|
|                       4 |
+-------------------------+
SELECT
       description,
       value,
       TO_TIMESTAMP(value),
       TO_TIME(value)
    FROM demo1_time
    ORDER BY value
    ;
+--------------+-------------------+-------------------------+----------------+
| DESCRIPTION  | VALUE             | TO_TIMESTAMP(VALUE)     | TO_TIME(VALUE) |
|--------------+-------------------+-------------------------+----------------|
| Seconds      | 31536001          | 1971-01-01 00:00:01.000 | 00:00:01       |
| Milliseconds | 31536002400       | 1971-01-01 00:00:02.400 | 00:00:02       |
| Microseconds | 31536003600000    | 1971-01-01 00:00:03.600 | 00:00:03       |
| Nanoseconds  | 31536004900000000 | 1971-01-01 00:00:04.900 | 00:00:04       |
+--------------+-------------------+-------------------------+----------------+
Zurück zum Anfang