Types de données

BigQuery accepte les types de données simples tels que les nombres entiers, ainsi que les types plus complexes tels que ARRAY et STRUCT. Cette page fournit un aperçu de chaque type de données et des valeurs autorisées. Pour en savoir plus sur les littéraux et les constructeurs de types de données, consultez la page Structure lexicale et syntaxe.

Propriétés de type de données

Lors du stockage et de l'interrogation des données, il est utile de garder à l'esprit les propriétés de type de données suivantes :

Propriété	Description	Applicable à
Nullable	NULL est une valeur valide.	Tous les types de données, mais des conditions s'appliquent aux tableaux.
Orderable	Peut être utilisé dans une clause ORDER BY.	Tous les types de données sauf : ARRAY STRUCT GEOGRAPHY
Groupable	Peut généralement apparaître dans une expression après GROUP BY, DISTINCT et PARTITION BY. Cependant, les expressions PARTITION BY ne peuvent pas inclure les types à virgule flottante.	Tous les types de données sauf : ARRAY STRUCT GEOGRAPHY
Comparable	Les valeurs du même type peuvent être comparées les unes aux autres.	Tous les types de données, avec les exceptions suivantes : Les comparaisons ARRAY ne sont pas acceptées. Les comparaisons d'égalité pour les données STRUCT sont acceptées, champ par champ, selon l'ordre des champs. Les noms de champ sont ignorés. Les comparaisons "inférieur à" et "supérieur à" ne sont pas acceptées. Les comparaisons GEOGRAPHY ne sont pas acceptées. Pour comparer des valeurs GEOGRAPHY, utilisez ST_Equals. Tous les types acceptant les comparaisons peuvent être utilisés dans une condition JOIN. Pour plus de précisions sur les conditions de jointure, consultez la section Types JOIN.

Types de données paramétrées

Syntaxe :

DATA_TYPE(param[, ...])

Les paramètres vous permettent de spécifier des contraintes pour les types de données suivants :

• STRING
• BYTES
• NUMERIC
• BIGNUMERIC

Un type de données déclaré avec des paramètres est appelé "type de données paramétrées". Vous ne pouvez utiliser des types de données paramétrées qu'avec des colonnes et des variables de script. Une colonne avec un type de données paramétrées est une colonne paramétrée, et une variable de script avec un type de données paramétrées est une variable de script paramétré. Les contraintes de type paramétré sont appliquées lors de l'écriture d'une valeur dans une colonne paramétrée ou lors de l'attribution d'une valeur à une variable de script paramétré.

Les paramètres d'un type de données ne sont pas propagés dans une expression, seul le type de données l'est.

Exemples

-- Declare a variable with type parameters.
DECLARE x STRING(10);

-- This is a valid assignment to x.
SET x = "hello";

-- This assignment to x violates the type parameter constraint and results in an OUT_OF_RANGE error.
SET x = "this string is too long"

-- Declare variables with type parameters.
DECLARE x NUMERIC(10) DEFAULT 12345;
DECLARE y NUMERIC(5, 2) DEFAULT 123.45;

-- The variable x is treated as a NUMERIC value when read, so the result of this query
-- is a NUMERIC without type parameters.
SELECT x;

-- Type parameters are not propagated within expressions, so variables x and y are treated
-- as NUMERIC values when read and the result of this query is a NUMERIC without type parameters.
SELECT x + y;

Type Array

Nom	Description
ARRAY	Liste numérotée comportant zéro ou plusieurs éléments de type autre que ARRAY.

Un tableau est une liste numérotée comportant zéro ou plusieurs éléments dont la valeur est d'un type autre que ARRAY. Les éléments d'un tableau doivent partager le même type.

Les tableaux imbriqués (ARRAY lui-même composé d'éléments ARRAY) ne sont pas autorisés. Les requêtes qui produisent de tels tableaux imbriqués vont afficher une erreur. Il convient, à la place, d'insérer un objet STRUCT entre les tableaux à l'aide de la construction SELECT AS STRUCT.

Éléments NULL et type ARRAY

Actuellement, BigQuery possède les règles suivantes concernant les éléments NULL et les tableaux de type ARRAY :

• Un ARRAY peut être NULL.

  Exemple :

  SELECT CAST(NULL AS ARRAY<INT64>) IS NULL AS array_is_null;
  
  +---------------+
  | array_is_null |
  +---------------+
  | TRUE          |
  +---------------+
  

• BigQuery traduit un tableau NULL en un tableau vide dans le résultat de la requête, bien que dans la requête, les tableaux NULL et vide soient deux valeurs distinctes.

  Exemple :

  WITH Items AS (
    SELECT [] AS numbers UNION ALL
    SELECT CAST(NULL AS ARRAY<INT64>))
  SELECT numbers FROM Items;
  
  +---------+
  | numbers |
  +---------+
  | []      |
  | []      |
  +---------+
  

• BigQuery génère une erreur si le résultat de la requête comprend un ARRAY contenant des éléments NULL, bien qu'un tel ARRAY puisse être utilisé dans la requête.

  Ainsi, cet exemple fonctionne :

  SELECT FORMAT("%T", [1, NULL, 3]) as numbers;
  
  +--------------+
  | numbers      |
  +--------------+
  | [1, NULL, 3] |
  +--------------+
  

  Mais celui-ci génère une erreur :

  -- error
  SELECT [1, NULL, 3] as numbers;
  

Déclarer un type ARRAY

ARRAY<T>

Les types ARRAY sont déclarés à l'aide des chevrons (< et >). Le type des éléments d'un ARRAY peut être arbitrairement complexe, à l'exception du fait qu'un tableau ne peut pas contenir directement un autre tableau.

Exemples

Déclaration de type	Signification
ARRAY<INT64>	Tableau simple de nombres entiers de 64 bits.
ARRAY<BYTES(5)>	Tableau simple d'octets paramétrés.
ARRAY<STRUCT<INT64, INT64>>	Tableau de structures contenant chacune deux entiers de 64 bits.
ARRAY<ARRAY<INT64>> (non compatible)	Cette déclaration de type non valide n'est mentionnée ici que pour le cas où vous chercheriez comment créer un tableau multidimensionnel. Les tableaux ne peuvent pas contenir d'autres tableaux directement. Reportez-vous plutôt à l'exemple suivant.
ARRAY<STRUCT<ARRAY<INT64>>>	Tableau de tableaux de nombres entiers de 64 bits. Sachez qu'il y a un objet STRUCT entre les deux tableaux, car ceux-ci ne peuvent pas contenir d'autres tableaux directement.

Créer un élément ARRAY

Vous pouvez créer un élément ARRAY à l'aide de littéraux ou de fonctions de tableau. Pour en savoir plus, consultez la page Utiliser des tableaux.

Type Boolean

Nom	Description
BOOL	Les valeurs booléennes sont représentées par les mots clés TRUE et FALSE (non sensibles à la casse).

Les valeurs booléennes sont triées dans l'ordre suivant, de la plus petite à la plus grande :

1. NULL
2. FALSE
3. TRUE

Type Bytes

Nom	Description
BYTES	Données binaires de longueur variable.

STRING et BYTES sont des types distincts qui ne peuvent pas être utilisés de manière interchangeable. La plupart des fonctions de STRING sont également définies sur BYTES. La version de BYTES fonctionne sur des octets bruts plutôt que sur des caractères Unicode. Les conversions entre STRING et BYTES forcent l'encodage des octets au format UTF-8.

Type d'octets paramétrés

Type paramètré	Description
BYTES(L)	Séquence d'octets avec un maximum d'octets L autorisés dans la chaîne binaire, où L est une valeur positive de INT64. Si une séquence d'octets comporte plus de L octets, cela génère une erreur OUT_OF_RANGE.

Pour en savoir plus sur les types de données paramétrés et leur utilisation, consultez la section Types de données paramétrés.

Type Date

Nom	Plage
DATE	De 0001-01-01 à 9999-12-31

Le type DATE représente une date de calendrier logique, indépendante du fuseau horaire. Une valeur DATE ne représente pas une période de 24 heures particulière. Elle représente plutôt une période de 24 heures différente selon le fuseau horaire dans lequel elle est interprétée. De plus, elle peut représenter un jour plus court ou plus long lors des passages à l'heure d'été. Pour représenter un moment précis, il convient d'utiliser un horodatage.

Format canonique

'YYYY-[M]M-[D]D'

• YYYY : année à quatre chiffres
• [M]M : mois à un ou deux chiffres
• [D]D : jour à un ou deux chiffres

Type Datetime (date/heure)

Nom	Plage
DATETIME	De 0001-01-01 00:00:00 à 9999-12-31 23:59:59.999999.

Un objet DATETIME représente une date et une heure telles qu'affichées sur un calendrier ou une horloge, indépendamment du fuseau horaire. Il comprend l'année, le mois, le jour, l'heure, la minute, la seconde et la milliseconde. Pour représenter un moment précis, il convient d'utiliser un horodatage.

Format canonique

YYYY-[M]M-[D]D[( |T)[H]H:[M]M:[S]S[.F]]

• YYYY : année à quatre chiffres
• [M]M : mois à un ou deux chiffres
• [D]D : jour à un ou deux chiffres
• ( |T) : espace ou séparateur "T"
• [H]H : heure à un ou deux chiffres (valeurs valides de 00 à 23)
• [M]M : minutes à un ou deux chiffres (valeurs valides comprises entre 00 et 59)
• [S]S : secondes à un ou deux chiffres (valeurs valides comprises entre 00 et 59)
• [.F] : jusqu'à six chiffres fractionnaires (précision de l'ordre de la microseconde)

Type Geography (géographie)

Nom	Description
GEOGRAPHY	Ensemble de points, de lignes et de polygones, représenté sous la forme d'un jeu de points, ou un sous-ensemble de la surface de la Terre.

Basé sur la spécification SFS (OGC Simple Features), le type GEOGRAPHY est une collection constituée des objets suivants :

• Point géographique : lieu unique dans l'espace de coordonnées. Un point comprend une valeur de coordonnée x et une valeur de coordonnée y, où la coordonnée x est la longitude et la coordonnée y est la latitude du point sur l'ellipsoïde de référence WGS84.
• Zone géographique en polyligne : objet géométrique à une dimension, avec une séquence de points et d'arêtes géodésiques entre lesdits points.
• Zone géographique en polygone : surface plane définie par une limite extérieure ainsi que par zéro limites intérieures ou plus. Chaque limite intérieure définit un trou dans le polygone. Les boucles de délimitation des polygones sont orientées de sorte que si vous traversez les sommets des limites dans l'ordre, l'intérieur du polygone se trouve sur la gauche.

Les points, les polylignes et les polygones d'une valeur GEOGRAPHY forment un agencement simple sur l'ellipsoïde de référence WGS84. Dans un agencement simple, aucun point de la surface WGS84 n'est contenu par plusieurs éléments de la collection. Si des auto-intersections existent, elles sont automatiquement supprimées.

Pour décrire une GEOGRAPHY qui ne contient aucun point, aucune polyligne et aucun polygone, on parle d'une GEOGRAPHY vide.

Un objet de type GEOGRAPHY représente le résultat ou un argument d'une fonction de géographie.

Type d'intervalle

Bêta

Ce produit ou cette fonctionnalité est couvert par les Conditions des offres pré-DG des conditions d'utilisation de Google Cloud Platform. Les fonctionnalités et produits pré-DG sont susceptibles de présenter une compatibilité limitée, et les modifications apportées à ces fonctionnalités ou produits peuvent ne pas être compatibles avec d'autres versions pré-DG. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Nom	Plage
INTERVAL	De -10000-0 -3660000 -87840000:0:0 à 10000-0 3660000 87840000:0:0

Un objet INTERVAL représente la durée. L'intervalle comporte trois parties indépendantes :

• [sign]Y-M : années et mois
• [sign]D : jours
• [sign]H:M:S.F : heures, minutes, secondes et sous-secondes.

Format canonique

[sign]Y-M [sign]D [sign]H:M:S[.F]

• Y : année
• M : mois
• D : jour
• H : heure
• M : minute
• S : seconde
• [.F] : jusqu'à six chiffres fractionnaires (précision de l'ordre de la microseconde)

Types numériques

Les types numériques incluent les types suivants :

• INT64 avec l'alias INT, SMALLINT, INTEGER, BIGINT, TINYINT, BYTEINT

• NUMERIC avec l'alias DECIMAL

• BIGNUMERIC avec l'alias BIGDECIMAL

• FLOAT64

Type entier

Les entiers sont des valeurs numériques qui ne possèdent pas de composants fractionnaires.

Nom	Plage
INT64 INT SMALLINT INTEGER BIGINT TINYINT BYTEINT	De -9,223,372,036,854,775,808 à 9,223,372,036,854,775,807

INT, SMALLINT, INTEGER, BIGINT, TINYINT et BYTEINT sont des alias pour INT64.

Types décimaux

Les valeurs de type décimal sont des valeurs numériques ayant une précision et une échelle décimales fixes. la précision correspond au nombre de chiffres contenus par le nombre ; L'échelle représente le nombre de chiffres après la virgule.

Ce type peut représenter les fractions décimales avec exactitude et convient aux calculs financiers.

Nom	Précision, évolutivité et plage
NUMERIC DECIMAL	Precision : 38 Échelle : 9 Min : -9.9999999999999999999999999999999999999E+28 Max : 9.9999999999999999999999999999999999999E+28
BIGNUMERIC BIGDECIMAL	Précision : 76,76 (le 77e chiffre est partiel) Échelle : 38 Min : -5,789260461865809771178541920430434395392663499233282028201972879200390656419968E+38 Max : 5,78960461865809771179851920430435392663499233282028201972879200390656419967E+38

DECIMAL est un alias de NUMERIC. BIGDECIMAL est un alias de BIGNUMERIC.

Type décimal paramétré

Type paramètré	Description
NUMERIC(P[,S]) DECIMAL(P[,S])	Un type NUMERIC ou DECIMAL avec une précision maximale de P et une échelle maximale de S, où P et S sont des valeurs de type INT64. S est interprété comme étant 0 si aucune valeur n'est spécifiée. Plage d'échelle maximale : 0 ≤ S ≤ 9 Plage de précision maximale : max(1, S) ≤ P ≤ S + 29
BIGNUMERIC(P[, S]) BIGDECIMAL(P[, S])	Un type BIGNUMERIC ou BIGDECIMAL avec une précision maximale de P et une échelle maximale de S, où P et S sont des valeurs de type INT64. S est interprété comme étant 0 si aucune valeur n'est spécifiée. Plage d'échelle maximale : 0 ≤ S ≤ 38 Plage de précision maximale : max(1, S) ≤ P ≤ S + 38

Si une valeur comporte plus de S chiffres décimaux, elle est arrondie à S chiffres décimaux. Par exemple, l'insertion de la valeur 1.125 dans une colonne NUMERIC(5, 2) arrondit 1.125 à 1.13.

Si une valeur comporte plus de P chiffres, cela génère une erreur OUT_OF_RANGE. Par exemple, l'insertion de 1111 dans une colonne NUMERIC(5, 2) renvoie une erreur OUT_OF_RANGE puisque 1111 est supérieur à 999,99, soit la valeur maximale autorisée dans une colonne NUMERIC(5, 2).

Pour en savoir plus sur les types de données paramétrés et leur utilisation, consultez la section Types de données paramétrés.

Remarque : L'application de restrictions avec précision et évolutivité n'a aucune incidence sur la taille de stockage du type de données sous-jacent.

Type Floating point

Les valeurs à virgule flottante sont des valeurs numériques approximatives qui possèdent des composants fractionnaires.

Nom	Description
FLOAT64	Valeurs numériques à double précision (approximatives).

Sémantique à virgule flottante

Lorsque vous travaillez avec des nombres à virgule flottante, vous devez tenir compte des valeurs spéciales non numériques telles que : NaN et +/-inf.

Les opérateurs arithmétiques assurent un comportement conforme à la norme IEEE-754 pour toutes les valeurs d'entrée finies produisant des sorties finies et pour toutes les opérations pour lesquelles au moins une entrée est non finie.

Les appels de fonction et les opérateurs renvoient une erreur de dépassement de capacité si l'entrée est finie mais que la sortie est non finie. Si l'entrée contient des valeurs non finies, la sortie peut être non finie. En général, les fonctions n'introduisent pas de valeurs NaN ou +/-inf. Cependant, des fonctions spécifiques telles que IEEE_DIVIDE peuvent afficher des valeurs non finies pour une entrée finie. Tous ces cas sont décrits dans la section consacrée aux fonctions mathématiques.

Les valeurs à virgule flottante sont des approximations.

• Le format binaire utilisé pour représenter les valeurs à virgule flottante ne peut représenter qu'un sous-ensemble de nombres compris entre le nombre le plus positif et le nombre le plus négatif dans la plage de valeurs. Cela permet de gérer efficacement une plage beaucoup plus étendue que ce qui serait possible autrement. Pour les nombres qui ne peuvent pas être facilement représentés, une approximation est générée à l'aide d'une valeur de fermeture. Par exemple, 0.1 ne peut pas être représenté sous la forme d'un entier mis à l'échelle avec une puissance de 2. Lorsque cette valeur est affichée sous forme de chaîne, elle est arrondie à un nombre limité de chiffres. La valeur d'approximation de 0.1 peut apparaître sous la forme "0.1", ce qui ne permet pas de voir que la valeur n'est pas précise. Dans d'autres cas, l'approximation peut être visible.
• La somme des valeurs à virgule flottante peut produire des résultats surprenants en raison de la précision limitée. Par exemple, (1e30 + 1e-20) - 1e30 = 0, alors que (1e30 - 1e30) + 1e-20 = 1e-20. En effet, la valeur à virgule flottante n'a pas suffisamment de précision pour représenter (1e30 + 1e-20), et le résultat est arrondi à 1e30. Cet exemple montre également que le résultat de la fonction d'agrégation SUM des valeurs à virgule flottante dépend de l'ordre dans lequel les valeurs sont accumulées. En général, cet ordre n'est pas déterministe. Par conséquent, le résultat n'est pas déterministe. Ainsi, la somme SUM des valeurs à virgule flottante qui en résulte peut ne pas être déterministe et deux exécutions de la même requête sur les mêmes tables peuvent produire des résultats différents.
• Si les points ci-dessus vous préoccupent, utilisez plutôt un type décimal.

Exemples de fonctions mathématiques

Terme gauche	Opérateur	Terme droit	Affiche
Valeur quelconque	+	NaN	NaN
1,0	+	+inf	+inf
1,0	+	-inf	-inf
-inf	+	+inf	NaN
Valeur FLOAT64 maximale	+	Valeur FLOAT64 maximale	Erreur de dépassement de capacité
Valeur FLOAT64 minimale	/	2.0	0,0
1,0	/	0.0	Erreur "Diviser par zéro"

Les opérateurs de comparaison assurent un comportement conforme à la norme IEEE-754 pour les entrées à virgule flottante.

Exemples d'opérateurs de comparaison

Terme gauche	Opérateur	Terme droit	Affiche
NaN	=	Valeur quelconque	FALSE
NaN	<	Valeur quelconque	FALSE
Valeur quelconque	<	NaN	FALSE
-0,0	=	0,0	TRUE
-0,0	<	0,0	FALSE

Les valeurs à virgule flottante sont triées dans l'ordre suivant, de la plus petite à la plus grande :

1. NULL
2. NaN : toutes les valeurs NaN sont considérées comme équivalentes lors du tri.
3. -inf
4. Nombres négatifs
5. 0 ou -0 - Toutes les valeurs zéro sont considérées comme égales lors du tri.
6. Nombres positifs
7. +inf

Les valeurs spéciales à virgule flottante sont regroupées de cette façon, par une clause GROUP BY et par le mot clé DISTINCT :

• NULL
• NaN : toutes les valeurs NaN sont considérées comme équivalentes lors du tri.
• -inf
• 0 ou -0 - Toutes les valeurs zéro sont considérées comme égales lors du regroupement.
• +inf

Type String

Nom	Description
STRING	Données constituées de caractères de longueur variable (Unicode)

Les valeurs d'entrée STRING doivent être encodées au format UTF-8 pour que les valeurs de sortie STRING soient encodées avec ce format. Les encodages alternatifs tels que CESU-8 et UTF-8 modifié ne sont pas traités comme des encodages UTF-8 valides.

Toutes les fonctions et tous les opérateurs qui agissent sur les valeurs STRING opèrent sur des caractères Unicode plutôt que sur des octets. Par exemple, des fonctions telles que SUBSTR et LENGTH appliquées à une entrée STRING comptent le nombre de caractères, et non d'octets.

Chaque caractère Unicode est associé à une valeur numérique appelée point de code. Les points de code inférieurs sont associés aux caractères inférieurs. Lorsque des caractères sont comparés, les points de code déterminent ceux qui sont inférieurs ou supérieurs aux autres caractères.

La plupart des fonctions de STRING sont également définies sur BYTES. La version de BYTES fonctionne sur des octets bruts plutôt que sur des caractères Unicode. STRING et BYTES sont des types distincts qui ne peuvent pas être utilisés de manière interchangeable. Il n'y a pas de conversion implicite dans les deux sens. La conversion forcée explicite entre STRING et BYTES s'effectue par le biais d'un encodage/décodage UTF-8. La conversion forcée de valeurs BYTES en valeurs STRING affiche une erreur si les octets ne sont pas des encodages UTF-8 valides.

Type de chaîne paramétrée

Type paramètré	Description
STRING(L)	Chaîne avec un maximum de L caractères Unicode autorisés dans la chaîne, où L est une valeur INT64 positive. Si une chaîne avec plus de L caractères Unicode est assignée, une erreur OUT_OF_RANGE est générée.

Pour en savoir plus sur les types de données paramétrés et leur utilisation, consultez la section Types de données paramétrés.

Type Struct

Nom	Description
STRUCT	Conteneur de champs numérotés ayant chacun un type (obligatoire) et un nom de champ (facultatif)

Déclarer un type de structure

STRUCT<T>

Les types de structure sont déclarés à l'aide des chevrons (< et >). Le type des éléments d'un objet STRUCT peut être arbitrairement complexe.

Exemples

Déclaration de type	Signification
STRUCT<INT64>	Structure simple avec un seul champ d'entier de 64 bits sans nom
STRUCT<x STRING(10)>	Objet STRUCT simple avec un seul champ de chaîne paramétrée nommé x
STRUCT<x STRUCT<y INT64, z INT64>>	Structure comprenant une structure imbriquée nommée x. L'objet STRUCT x contient deux champs : y et z, qui sont tous deux des entiers de 64 bits.
STRUCT<inner_array ARRAY<INT64>>	Structure comprenant un tableau nommé inner_array, contenant des entiers de 64 bits.

Construire une structure

Syntaxe de tuple

(expr1, expr2 [, ... ])

Le type de sortie est un type STRUCT anonyme comportant des champs anonymes dont les types correspondent à ceux des expressions d'entrée. Vous devez spécifier au moins deux expressions, sinon cette syntaxe ne peut pas être distinguée d'une expression entre parenthèses.

Exemples

Syntaxe	Type de sortie	Notes
(x, x+y)	STRUCT<?,?>	Si vous utilisez des noms de colonne (chaînes sans guillemets), le type de données du champ STRUCT est dérivé de celui de la colonne. Étant donné que x et y sont des colonnes, les types de données des champs STRUCT sont dérivés du type des colonnes et du type de sortie de l'opérateur d'addition.

Cette syntaxe peut également être utilisée avec les expressions de comparaison de structures basées sur des clés composées de plusieurs parties, par exemple dans une clause WHERE :

WHERE (Key1,Key2) IN ( (12,34), (56,78) )

Syntaxe de structure sans type

STRUCT( expr1 [AS field_name] [, ... ])

Les noms de champs en double sont autorisés. Les champs sans nom sont considérés comme des champs anonymes et ne peuvent donc pas être référencés par nom. Les valeurs de type STRUCT peuvent être NULL ou avoir des valeurs de champ NULL.

Exemples

Syntaxe	Type de sortie
STRUCT(1,2,3)	STRUCT<int64,int64,int64>
STRUCT()	STRUCT<>
STRUCT('abc')	STRUCT<string>
STRUCT(1, t.str_col)	STRUCT<int64, str_col string>
STRUCT(1 AS a, 'abc' AS b)	STRUCT<a int64, b string>
STRUCT(str_col AS abc)	STRUCT<abc string>

Syntaxe de structure avec type

STRUCT<[field_name] field_type, ...>( expr1 [, ... ])

La syntaxe avec type permet de construire des structures avec un type de données STRUCT explicite. Le type de sortie est exactement le champ field_type qui est spécifié. Le type de l'expression d'entrée est field_type si les deux types ne sont pas identiques, et une erreur est générée si les types ne sont pas compatibles. AS alias n'est pas autorisé sur les expressions d'entrée. Le nombre d'expressions doit correspondre au nombre de champs du type, et le type des expressions doit être convertible de manière forcée ou en littéral en fonction des types de champ.

Exemples

Syntaxe	Type de sortie
STRUCT<int64>(5)	STRUCT<int64>
STRUCT<date>("2011-05-05")	STRUCT<date>
STRUCT<x int64, y string>(1, t.str_col)	STRUCT<x int64, y string>
STRUCT<int64>(int_col)	STRUCT<int64>
STRUCT<x int64>(5 AS x)	Erreur - La syntaxe avec type n'autorise pas AS.

Comparaisons limitées de structures

Les structures peuvent être directement comparées en utilisant des opérateurs d'égalité :

• Égal à (=)
• Différent de (!= ou <>)
• [NOT] IN

Sachez cependant que ces comparaisons directes d'égalité comparent les champs de structure par paire, dans l'ordre ordinal, en ignorant les noms de champ. Si, à la place, vous souhaitez comparer des champs d'une structure portant le même nom, vous pouvez comparer les champs individuels directement.

Type Time (heure)

Nom	Plage
TIME	00:00:00 à 23:59:59.999999

Un objet TIME représente une heure telle qu'affichée sur une montre, indépendamment d'une date et d'un fuseau horaire spécifiques. Pour représenter un moment précis, il convient d'utiliser un horodatage.

Format canonique

[H]H:[M]M:[S]S[.DDDDDD|.F]

• [H]H : heure à un ou deux chiffres (valeurs valides de 00 à 23)
• [M]M : minutes à un ou deux chiffres (valeurs valides comprises entre 00 et 59)
• [S]S : secondes à un ou deux chiffres (valeurs valides comprises entre 00 et 59)
• [.F] : jusqu'à six chiffres fractionnaires (précision de l'ordre de la microseconde)

Type Timestamp

Nom	Plage
TIMESTAMP	De 0001-01-01 00:00:00 à 9999-12-31 23:59:59.999999 UTC

Un objet TIMESTAMP représente un moment précis, indépendant de tout fuseau horaire ou convention, telle que l'heure d'été, avec une précision de l'ordre de la microseconde.

• Pour représenter une date telle qu'elle peut apparaître sur un calendrier, utilisez un objet DATE.
• Pour représenter une heure telle qu'elle peut apparaître sur une horloge, utilisez un objet TIME.
• Pour représenter une date et une heure telles qu'elles peuvent apparaître sur un calendrier et une horloge, utilisez un objet DATETIME.

Format canonique

YYYY-[M]M-[D]D[( |T)[H]H:[M]M:[S]S[.F]][time zone]

• YYYY : année à quatre chiffres
• [M]M : mois à un ou deux chiffres
• [D]D : jour à un ou deux chiffres
• ( |T) : espace ou séparateur "T"
• [H]H : heure à un ou deux chiffres (valeurs valides de 00 à 23)
• [M]M : minutes à un ou deux chiffres (valeurs valides comprises entre 00 et 59)
• [S]S : secondes à un ou deux chiffres (valeurs valides comprises entre 00 et 59)
• [.F] : jusqu'à six chiffres fractionnaires (précision de l'ordre de la microseconde)
• [time zone] : chaîne représentant le fuseau horaire. Lorsqu'un fuseau horaire n'est pas spécifié explicitement, le fuseau horaire par défaut est utilisé (UTC). Pour plus de précisions, consultez la section Fuseaux horaires.

Fuseaux horaires

Les fuseaux horaires sont utilisés lors de l'analyse ou du formatage des horodatages à des fins d'affichage. La valeur d'horodatage elle-même ne stocke pas de fuseau horaire spécifique et ne change pas lorsque vous appliquez un décalage de fuseau horaire.

Les fuseaux horaires sont représentés par des chaînes dans l'un de ces deux formats canoniques :

• Décalage par rapport au temps universel coordonné (UTC), ou bien la lettre Z pour l'UTC
• Nom du fuseau horaire issu de la base de données tz

Décalage par rapport au temps universel coordonné (UTC)

(+|-)H[H][:M[M]]
Z

Exemples

-08:00
-8:15
+3:00
+07:30
-7
Z

Lorsque vous utilisez ce format, aucune espace n'est autorisée entre le fuseau horaire et le reste de l'horodatage.

2014-09-27 12:30:00.45-8:00
2014-09-27T12:30:00.45Z

Nom de fuseau horaire

continent/[region/]city

Les noms de fuseau horaire proviennent de la base de données tz. Pour obtenir des informations de référence moins complètes mais plus simples, consultez l'article Wikipédia List of tz database time zones (Liste des fuseaux horaires de la base de données tz).

Exemples

America/Los_Angeles
America/Argentina/Buenos_Aires

Lorsque vous utilisez un nom de fuseau horaire, une espace est requise entre le nom et le reste de l'horodatage :

2014-09-27 12:30:00.45 America/Los_Angeles

Sachez que les noms de fuseau horaire ne sont pas tous interchangeables, même s'ils signalent la même heure au cours d'une partie de l'année. Par exemple, America/Los_Angeles signale la même heure que le fuseau horaire UTC-7:00 pendant l'heure d'été. En revanche, hors de cette période, il signale la même heure que le fuseau horaire UTC-8:00.

Si aucun fuseau horaire n'est spécifié, la valeur de fuseau horaire par défaut est utilisée.

Secondes intercalaires

Un horodatage est simplement un décalage depuis le 1970-01-01 00:00:00 UTC, supposant qu'il y ait exactement 60 secondes par minute. Les secondes intercalaires ne sont pas représentées dans un horodatage stocké.

Si votre entrée contient des valeurs qui utilisent ":60" dans le champ des secondes pour représenter une seconde intercalaire, cette seconde intercalaire n'est pas conservée lors de la conversion en valeur d'horodatage. Cette valeur est plutôt interprétée comme un horodatage comprenant ":00" dans le champ des secondes de la minute suivante.

Les secondes intercalaires n'affectent pas les calculs d'horodatage. Ces calculs utilisent les horodatages de type Unix, qui ne reflètent pas les secondes intercalaires. Les secondes intercalaires ne sont observables que par le biais de fonctions qui mesurent le temps réel. Dans ces fonctions, il est possible qu'une seconde d'horodatage soit ignorée ou répétée s'il existe une seconde intercalaire.