Règles de conversion en SQL standard

La "conversion" comprend, sans toutefois s'y limiter, le casting et la coercition.

  • Le casting est une conversion explicite qui utilise la fonction CAST().
  • La coercition est une conversion implicite, que BigQuery effectue automatiquement dans les conditions décrites dans la suite de cette section.
  • Il existe un troisième groupe de fonctions de conversion qui portent un nom de fonction spécifique, par exemple UNIX_DATE().

Le tableau ci-dessous récapitule toutes les options disponibles en matière de fonction CAST et de coercition pour les types de données BigQuery. "Coercition vers" s'applique à toutes les expressions d'un type de données particulier (par exemple, une colonne), mais les littéraux et les paramètres peuvent également faire l'objet d'une coercition. Pour plus de précisions, consultez les sections Coercition de littéraux et Coercition de paramètres.

Type source Casting vers Coercition vers
INT64 BOOL
INT64
NUMERIC
FLOAT64
STRING
FLOAT64
NUMERIC
NUMERIC INT64
NUMERIC
FLOAT64
STRING
FLOAT64
FLOAT64 INT64
NUMERIC
FLOAT64
STRING
 
BOOL BOOL
INT64
STRING
 
STRING BOOL
INT64
NUMERIC
FLOAT64
STRING
BYTES
DATE
DATETIME
TIME
TIMESTAMP
 
BYTES BYTES
STRING
 
DATE DATE
DATETIME
STRING
TIMESTAMP
 
DATETIME DATE
DATETIME
STRING
TIME
TIMESTAMP
 
TIME STRING
TIME
 
TIMESTAMP DATE
DATETIME
STRING
TIME
TIMESTAMP
 
ARRAY ARRAY  
STRUCT STRUCT  

Casting

Syntaxe :

CAST(expr AS typename)

La syntaxe "Cast" est utilisée dans une requête pour indiquer que le type de résultat d'une expression doit être converti dans un autre type.

Exemple :

CAST(x=1 AS STRING)

Cela veut dire que le résultat est "true" si la valeur de x est 1, "false" pour toutes les autres valeurs qui ne sont pas NULL et NULL si x porte la valeur NULL.

Lors des conversions (castings) entre des types compatibles, s'il est impossible d'établir une correspondance entre la valeur d'origine et le domaine cible, des erreurs d'exécution se produisent. Par exemple, si vous tentez de convertir une valeur BYTES en STRING alors que la séquence d'octets n'est pas une valeur UTF-8 valide, une erreur d'exécution se produit.

Lorsqu'une expression x de l'un des types suivants est convertie (via une opération de casting), les règles associées à ce type s'appliquent :

De Vers Règle(s) appliquée(s) lors du casting de x
INT64 FLOAT64 Renvoie une valeur FLOAT64 proche, mais potentiellement non exacte.
INT64 BOOL Renvoie FALSE si x est égal à 0, ou TRUE si ce n'est pas le cas.
NUMERIC Virgule flottante NUMERIC convertira l'expression en nombre à virgule flottante le plus proche avec une possible perte de précision.
FLOAT64 INT64 Renvoie la valeur INT64 la plus proche.
Les cas à mi-chemin tels que 1,5 ou -0,5 sont arrondis à la valeur la plus éloignée de zéro.
FLOAT64 STRING Renvoie une représentation de chaîne approximative.
FLOAT64 NUMERIC Si le nombre à virgule flottante comporte plus de neuf chiffres après la virgule, il sera arrondi à la valeur la plus éloignée à mi-chemin du zéro. Si vous castez une valeur NaN, +inf ou -inf, une erreur est renvoyée. Le casting d'une valeur non comprise dans la plage de NUMERIC renvoie une erreur de dépassement de capacité.
BOOL INT64 Renvoie 1 si x est TRUE, ou 0 si ce n'est pas le cas.
BOOL STRING Renvoie "true" si x est TRUE, ou "false" si ce n'est pas le cas.
STRING FLOAT64 Renvoie x sous la forme d'une valeur FLOAT64, en l'interprétant comme ayant la même forme qu'un littéral FLOAT64 valide.
Accepte également le casting de "inf", "+inf", "-inf" et "nan".
Les conversions ne sont pas sensibles à la casse.
STRING NUMERIC Le littéral numérique contenu dans la valeur STRING ne doit pas dépasser la plage ou la précision maximale du type NUMERIC sous peine de produire une erreur. Si le nombre de chiffres après la virgule est supérieur à neuf, la valeur NUMERIC résultante sera arrondie à la valeur la plus éloignée à mi-chemin du zéro de sorte qu'elle comporte neuf chiffres après la virgule.
STRING BOOL Renvoie TRUE si x est "true" et FALSE si x est "false".
Toutes les autres valeurs de x sont considérées comme non valides. Elles génèrent une erreur au lieu d'être converties en BOOL.
Les STRING ne sont pas sensibles à la casse lorsqu'elles sont converties en BOOL.
STRING BYTES Les STRING sont converties en BYTES par le biais de l'encodage UTF-8. Par exemple, la conversion en BYTES de la STRING "©" donne une séquence de 2 octets dont les valeurs hexadécimales sont C2 et A9.
BYTES STRING Renvoie x interprété en tant que STRING UTF-8.
Par exemple, en cas de conversion du littéral BYTES b'\xc2\xa9' en STRING, ce littéral est interprété en tant que chaîne UTF-8 et se présente sous la forme du caractère Unicode "©".
Une erreur se produit si x n'est pas une valeur UTF-8 valide.
ARRAY ARRAY Le type ARRAY doit être exactement le même.
STRUCT STRUCT Autorisé si les conditions suivantes sont remplies :
  1. Les deux STRUCT ont le même nombre de champs.
  2. Les types de champ STRUCT d'origine peuvent être explicitement convertis en types de champ STRUCT cibles correspondants (tels que définis par l'ordre des champs, et non par leur nom).

Casting sécurisé

Lors de l'utilisation de CAST, une requête peut échouer si BigQuery est incapable d'effectuer le casting. Par exemple, la requête suivante génère une erreur :

SELECT CAST("apple" AS INT64) AS not_a_number;

Si vous souhaitez protéger vos requêtes contre ce type d'erreur, vous pouvez utiliser SAFE_CAST. La fonction SAFE_CAST est identique à CAST, sauf qu'elle renvoie NULL au lieu de générer une erreur.

SELECT SAFE_CAST("apple" AS INT64) AS not_a_number;

+--------------+
| not_a_number |
+--------------+
| NULL         |
+--------------+

Si vous castez des octets en chaînes, vous pouvez également utiliser la fonction SAFE_CONVERT_BYTES_TO_STRING. Tous les caractères UTF-8 non valides sont remplacés par le caractère de remplacement Unicode U+FFFD. Pour en savoir plus, consultez la section SAFE_CONVERT_BYTES_TO_STRING.

Caster des chaînes hexadécimales en nombres entiers

Si vous travaillez avec des chaînes hexadécimales (0x123), vous pouvez les caster en nombres entiers :

SELECT '0x123' as hex_value, CAST('0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| 0x123     | 291        |
+-----------+------------+

SELECT '-0x123' as hex_value, CAST('-0x123' as INT64) as hex_to_int;

+-----------+------------+
| hex_value | hex_to_int |
+-----------+------------+
| -0x123    | -291       |
+-----------+------------+

Caster des types de date

BigQuery permet le casting des types de date en chaînes (ou inversement) comme suit :

CAST(date_expression AS STRING)
CAST(string_expression AS DATE)

Le casting d'un type de date en chaîne ne dépend pas du fuseau horaire et son résultat se présente sous la forme YYYY-MM-DD. Le casting d'une chaîne en date ne dépend pas du fuseau horaire et la chaîne doit être conforme au format de littéral de date accepté. Si l'expression de chaîne n'est pas valide ou représente une date en dehors de la plage de valeurs minimale-maximale acceptée, une erreur est générée.

Caster des types d'horodatage

BigQuery permet le casting des types d'horodatage en chaînes (ou inversement) comme suit :

CAST(timestamp_expression AS STRING)
CAST(string_expression AS TIMESTAMP)

Lors du casting de types d'horodatage en chaînes, l'horodatage est interprété à l'aide du fuseau horaire par défaut, à savoir UTC. Le nombre de décimales (valeurs inférieures à la seconde) générées dépend du nombre de zéros dans la partie inférieure à la seconde : la fonction CAST tronquera zéro, trois ou six chiffres.

Lors de la conversion d'une chaîne en horodatage, string_expression doit être conforme aux formats de littéraux d'horodatage acceptés. Dans le cas contraire, une erreur d'exécution se produit. L'expression string_expression peut contenir une valeur time_zone (consultez la section Fuseaux horaires). Si un fuseau horaire est spécifié dans string_expression, il est utilisé pour la conversion. Dans le cas contraire, le fuseau horaire par défaut (UTC) est utilisé. Si la chaîne comporte moins de six chiffres, elle est implicitement élargie.

Une erreur est générée si l'expression string_expression n'est pas valide, si elle comporte plus de six décimales (c.-à-d. si la précision est supérieure à la microseconde) ou si elle représente une valeur temporelle en dehors de la plage d'horodatage acceptée.

Caster des types de date en horodatages (ou inversement)

BigQuery permet le casting des types de date en horodatages (ou inversement) comme suit :

CAST(date_expression AS TIMESTAMP)
CAST(timestamp_expression AS DATE)

Le casting d'une date en horodatage interprète date_expression comme heure de début de la journée (minuit) dans le fuseau horaire par défaut (UTC). Le casting d'un horodatage en date tronque effectivement l'horodatage du fuseau horaire par défaut.

Coercition

Si nécessaire, BigQuery convertit (par coercition) le type de résultat d'une expression en un autre type pour faire correspondre les signatures de fonction. Par exemple, si la fonction "func()" est définie pour accepter un seul argument de type INT64 et qu'une expression (dont le type de résultat est FLOAT64) est utilisée en tant qu'argument, le résultat de l'expression sera "converti" dans le type INT64 avant que la valeur de "func()" soit calculée.

Coercition de littéraux

BigQuery permet les coercitions de littéraux suivantes :

Type de données d'entrée Type de données de résultat Notes
Littéral de type STRING DATE
TIMESTAMP

La coercition de littéraux est nécessaire lorsque le type réel des littéraux est différent du type attendu par la fonction en question. Par exemple, si la fonction func() utilise un argument DATE, l'expression func("2014-09-27") est valide, car le littéral de type STRING "2014-09-27" est converti par coercition en DATE.

La conversion de littéraux est évaluée au moment de l'analyse et génère une erreur si le littéral d'entrée ne peut pas être converti dans le type cible.

Remarque : Les littéraux de chaîne ne sont pas convertis par coercition en types numériques.

Coercition de paramètres

BigQuery permet les coercitions de paramètres suivantes :

Type de données d'entrée Type de données de résultat
Paramètre de type STRING

Si la valeur du paramètre ne peut pas être convertie par coercition dans le type cible, une erreur est générée.

Fonctions de conversion supplémentaires

BigQuery offre les fonctions de conversion supplémentaires suivantes :

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.