Catégories :

Fonctions de conversion , Fonctions de date et d’heure

TO_DATE , DATE

Convertit une expression d’entrée en date :

  • Pour une expression de chaîne, le résultat de la conversion de la chaîne en date.

  • Pour une expression d’horodatage, la date de l’horodatage.

  • Pour une expression variante :

    • Si la variante contient une chaîne, une conversion de chaîne est effectuée.

    • Si la variante contient une date, la valeur de date est conservée telle quelle.

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

  • Pour une entrée NULL, la sortie est NULL.

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

Voir aussi :

TRY_TO_DATE

Syntaxe

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

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

Arguments

Obligatoire :

Une des options :

expr_horodatage

Expression TIMESTAMP. La partie DATE du TIMESTAMP est extraite.

expr_chaîne

Chaîne à partir de laquelle extraire une date, par exemple « 2019-01-31 ».

entier

Expression qui correspond à une chaîne contenant un entier, par exemple « 15000000 ». Selon l’ampleur de la chaîne, elle peut être interprétée comme des secondes, des millisecondes, des microsecondes ou des nanosecondes. Pour plus de détails, voir les notes sur l’utilisation ci-dessous.

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

expr_variante

Expression de type VARIANT. VARIANT doit contenir une DATE ou une chaîne qui contient un INTEGER. (TO_DATE renvoie une erreur en cas de passage d’un VARIANT contenant un horodatage.)

VARIANT doit contenir l’un des éléments suivants :

  • Une chaîne à partir de laquelle extraire une date.

  • Une date.

  • Une chaîne contenant un nombre entier de secondes ou de millisecondes.

Bien que TO_DATE accepte une valeur TIMESTAMP, il n’accepte pas de TIMESTAMP dans un VARIANT.

Facultatif :

format

Spécificateur de format de date pour expr_chaine 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.

La valeur par défaut est la valeur actuelle du paramètre de session DATE_INPUT_FORMAT (généralement AUTO).

Renvoie

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

Notes sur l’utilisation

  • Si le format du paramètre d’entrée est une chaîne contenant un entier :

    • 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), alors la première valeur traitée détermine si toutes les valeurs suivantes sont traitées en secondes, millisecondes, microsecondes ou nanosecondes.

      Si la valeur est supérieure ou égale à 31536000000 et inférieure à 31536000000000, toutes les valeurs sont alors traitées en millisecondes.

      Pour traiter les lignes en parallèle, un ensemble de lignes peut être divisé en groupes soit par l’utilisateur (par exemple avec une clause PARTITION BY), soit par Snowflake. La première ligne de chaque groupe détermine si la valeur est interprétée en secondes, millisecondes, microsecondes ou nanosecondes pour l’ensemble du groupe. Cela peut donner des résultats différents lorsque l’ordre des valeurs change. Pour éviter ce problème, spécifiez le format d’entrée pour la valeur, soit comme argument de la fonction, soit dans un paramètre de session.

Exemples

Ces exemples montrent comment utiliser la fonction TO_DATE().

SELECT TO_DATE('2013-05-17'), DATE('2013-05-17');
+-----------------------+--------------------+
| TO_DATE('2013-05-17') | DATE('2013-05-17') |
|-----------------------+--------------------|
| 2013-05-17            | 2013-05-17         |
+-----------------------+--------------------+
SELECT TO_DATE('2012.07.23', 'YYYY.MM.DD'), DATE('2012.07.23', 'YYYY.MM.DD');
+-------------------------------------+----------------------------------+
| TO_DATE('2012.07.23', 'YYYY.MM.DD') | DATE('2012.07.23', 'YYYY.MM.DD') |
|-------------------------------------+----------------------------------|
| 2012-07-23                          | 2012-07-23                       |
+-------------------------------------+----------------------------------+
SELECT TO_DATE('1999-01-02', 'AUTO'), DATE('1999-01-02', 'AUTO');
+-------------------------------+----------------------------+
| TO_DATE('1999-01-02', 'AUTO') | DATE('1999-01-02', 'AUTO') |
|-------------------------------+----------------------------|
| 1999-01-02                    | 1999-01-02                 |
+-------------------------------+----------------------------+
SELECT TO_DATE('02/14/2014', 'MM/DD/YYYY'), DATE('02/14/2014', 'MM/DD/YYYY');
+-------------------------------------+----------------------------------+
| TO_DATE('02/14/2014', 'MM/DD/YYYY') | DATE('02/14/2014', 'MM/DD/YYYY') |
|-------------------------------------+----------------------------------|
| 2014-02-14                          | 2014-02-14                       |
+-------------------------------------+----------------------------------+

Lorsque l’entrée est une chaîne qui contient un nombre entier, la magnitude de ce nombre entier détermine si elle est interprétée comme des secondes, des millisecondes, etc. L’interprétation de la première valeur est appliquée aux valeurs suivantes. Par exemple, si la première valeur est interprétée comme des millisecondes, les valeurs suivantes sont également interprétées comme des millisecondes, même si ces valeurs suivantes ont une ampleur très différente. L’exemple suivant le montre :

Créez et chargez la table :

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

INSERT INTO demo1 (description, value) VALUES
   ('Seconds',      '31535999999'),
   ('Milliseconds', '31536000000')
   ;

Comparez la sortie des deux requêtes suivantes. La seule différence entre les deux est l’ordre des lignes, mais les horodatages et les dates dans les deux dernières colonnes sont très différents.

Dans la première requête, la valeur saisie dans la première ligne est traitée comme un nombre de secondes. Par conséquent, les valeurs saisies dans les lignes suivantes sont également traitées comme le nombre de secondes :

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

Dans la deuxième requête, la valeur d’entrée de la première ligne est traitée comme un nombre de millisecondes. Par conséquent, les valeurs d’entrée dans les lignes suivantes sont également traitées comme le nombre de millisecondes :

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