Catégories :

Fonctions de conversion , Fonctions de date et d’heure

TO_TIME , TIME

Convertit une expression d’entrée en heure. Si la saisie est NULL, renvoie NULL.

Voir aussi :

TRY_TO_TIME

Syntaxe

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

Arguments

Obligatoire :

string_expr ou timestamp_expr ou variant_expr ou integer

Expression à convertir en une heure :

  • Pour string_expr, le résultat de la conversion de la chaîne en heure.

  • Pour timestamp_expr, l’heure de la valeur d’entrée.

  • Pour 'integer' (une chaîne contenant un entier), l’entier est traité comme un nombre de secondes, millisecondes, microsecondes ou nanosecondes après le début de l’epoch Unix. Voir les notes sur l’utilisation ci-dessous.

    Pour cet horodatage, la fonction obtient le nombre de secondes après le début de l’epoch Unix. La fonction effectue une opération modulo pour obtenir le reste de la division de ce nombre par le nombre de secondes dans un jour (86400) :

    number_of_seconds % 86400

    La fonction interprète ce reste comme le nombre de secondes après minuit.

    Par exemple, supposons que la valeur est 31536002789.

    1. Sur la base de l’amplitude de cette valeur, la fonction utilise les millisecondes comme unité de temps et détermine que la valeur représente 1971-01-01 00:00:02.789.

    2. La fonction obtient le nombre de secondes après l’epoch Unix pour cette valeur (31536002).

    3. La fonction obtient le reste en divisant ce nombre par le nombre de secondes dans un jour (31536002 % 86400).

    4. La fonction utilise le reste (2) comme nombre de secondes après minuit. La valeur résultante était 00:00:02.

    Note

    L’utilisation d’entiers entre guillemets comme entrées est obsolète.

  • Pour variant_expr :

    • Si la variante contient une chaîne au format TIME (« HH:MI:SS »), une conversion de chaîne est effectuée.

    • Si la variante contient une chaîne au format INTEGER, une conversion de chaîne est effectuée et la valeur est traitée comme le nombre de secondes depuis minuit (modulus 86400 si nécessaire).

    • Si la variante contient la valeur JSON null, la sortie est NULL.

Pour toutes les autres valeurs, une erreur de conversion est générée.

Facultatif :

format

Spécificateur de format d’heure pour string_expr ou AUTO, qui précise que Snowflake doit automatiquement détecter le format à utiliser. Pour plus d’informations, voir Formats de date et heure dans les fonctions de conversion.

Valeur par défaut : valeur actuelle du paramètre de session TIME_INPUT_FORMAT (généralement AUTO)

Renvoie

Le type de données de la valeur renvoyée est TIME.

Notes sur l’utilisation

  • Si le format du paramètre d’entrée est une chaîne contenant un entier, l’unité de mesure de la valeur (secondes, microsecondes, millisecondes ou nanosecondes) est déterminée comme suit :

  • Une fois la chaîne convertie en entier, l’entier est traité comme un nombre de secondes, millisecondes, microsecondes ou nanosecondes après le début de l’epoch Unix (1970-01-01 00:00:00.000000000 UTC).

    • Si l’entier est inférieur à 31536000000 (le nombre de millisecondes dans une année), alors la valeur est traitée comme un nombre de secondes.

    • Si la valeur est supérieure ou égale à 31536000000 et inférieure à 31536000000000, la valeur est alors traitée en millisecondes.

    • Si la valeur est supérieure ou égale à 31536000000000 et inférieure à 31536000000000000, la valeur est alors traitée en microsecondes.

    • Si la valeur est supérieure ou égale à 31536000000000000, alors la valeur est traitée comme des nanosecondes.

    Prudence

    Actuellement, les valeurs négatives sont toujours traitées comme des secondes. Par exemple, -31536000000000000000 est traité comme un nombre de secondes avant l’année 1970, bien que son échelle implique qu’il est destiné à être utilisé comme nanosecondes.

    Ce comportement pourrait changer à l’avenir.

    Note

    Avertissement de dépréciation : les futures versions de Snowflake pourraient interpréter automatiquement les valeurs entières converties en chaînes comme des secondes plutôt que comme des millisecondes, microsecondes ou nanosecondes. Snowflake vous recommande d’appeler TO_DATE, TO_TIME ou TO_TIMESTAMP avec des chaînes qui contiennent des entiers uniquement lorsque ces entiers sont destinés à être interprétés comme des secondes.

  • Si plusieurs lignes sont évaluées (par exemple, si l’entrée est le nom de colonne d’une table qui contient plus d’une ligne), chaque valeur est examinée indépendamment pour déterminer si elle représente des secondes, des millisecondes, des microsecondes ou des nanosecondes.

  • Contrairement à la fonction TO_TIME, la fonction TIME ne prend pas en charge le paramètre facultatif format.

Exemples

Ces exemples illustrent la fonction 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         |
+---------------------+------------------+
Copy
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             |
+-------------------------+----------------------+
Copy

Cet exemple montre comment utiliser la fonction TO_TIME pour traiter des séparateurs de champs autres que les deux points par défaut (cet exemple utilise le caractère de point comme séparateur entre les heures et les minutes et entre les minutes et les secondes) :

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

Cet exemple montre comment la fonction TO_TIME interprète une chaîne de caractères contenant une valeur entière :

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 |
+-------------------------+
Copy
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       |
+--------------+-------------------+-------------------------+----------------+
Copy
Langage: Français