Types de données du langage SQL standard

BigQuery accepte les types de données simples, tels que des entiers, et des types plus complexes, tels que ARRAY et STRUCT. Cette page présente chaque type de données, ainsi que les 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, avec les exceptions suivantes :
  • Les types de données ARRAY ne peuvent pas être NULL.
  • Les éléments NULL ARRAY ne peuvent pas persister dans une table.
Orderable Peut s'utiliser 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 suivant
GROUP BY, DISTINCT ou PARTITION BY.
Cependant, les expressions PARTITION BY ne peuvent pas inclure
les types à virgule flottante FLOAT et DOUBLE.


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 de jointure.

Types numériques

Les types numériques incluent les types entiers, les types à virgule flottante et le type de données NUMERIC.

Type entier

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

Nom Taille de l'espace de stockage Plage
INT64 8 octets De -9,223,372,036,854,775,808 à 9,223,372,036,854,775,807

Type de données NUMERIC

Le type de données NUMERIC correspond à une valeur numérique exacte comportant 38 chiffres de précision et 9 chiffres décimaux d'échelle. 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 Taille de l'espace de stockage Description Plage
NUMERIC 16 octets Valeurs décimales comportant 38 chiffres décimaux de précision et 9 chiffres décimaux d'échelle. De -99999999999999999999999999999,999999999 à 99999999999999999999999999999,999999999

Type à virgule flottante

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

Nom Taille de l'espace de stockage Description
FLOAT64 8 octets Valeurs décimales à 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.

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 égales 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 la manière suivante : par une clause GROUP BY et par le mot clé DISTINCT :

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

Type Boolean (booléen)

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

Type String (chaîne)

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 les caractères Unicode et non pas les octets. Les comparaisons sont définies sur les caractères Unicode. Les comparaisons "inférieur à" et ORDER BY s'effectuent caractère par caractère et les points de code Unicode inférieurs sont considérés comme des caractères inférieurs.

La plupart des fonctions qui agissent sur des valeurs STRING sont également définies sur BYTES. La version 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 Bytes (octets)

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 qui agissent sur des valeurs STRING sont également définies sur BYTES. La version 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 Date (date)

Nom Description Plage
DATE Représente une date de calendrier logique. 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 Description Plage
DATETIME Correspond à une année, un mois, un jour, une heure, une minute, une seconde et une milliseconde De 0001-01-01 00:00:00 à 9999-12-31 23:59:59.999999.

Un objet DATETIME représente un moment précis. Chaque objet DATETIME contient les éléments suivants :

  • year
  • month
  • day
  • hour
  • minute
  • second
  • subsecond

Contrairement aux horodatages, un objet DATETIME ne fait pas référence à une instance absolue dans le temps. Il s'agit plutôt du temps civil, c'est-à-dire de l'heure affichée par la montre de l'utilisateur et de la date de son calendrier.

Format canonique

YYYY-[M]M-[D]D[( |T)[H]H:[M]M:[S]S[.DDDDDD]]
  • 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 : heures à un ou deux chiffres (valeurs valides de 00 à 23)
  • [M]M : minutes à un ou deux chiffres (valeurs valides de 00 à 59)
  • [S]S : secondes à un ou deux chiffres (valeurs valides de 00 à 59)
  • [.DDDDDD] : jusqu'à six chiffres fractionnaires (c'est-à-dire avec une précision à la microseconde près)

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 consiste en un ensemble de points, de lignes ou de polygones formant 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.

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

Type Time (heure)

Nom Description Plage
TIME Correspond à une heure indépendante d'une date précise De 00:00:00 à 23:59:59.999999.

Un objet de type TIME représente une heure indépendante d'une date précise.

Format canonique

[H]H:[M]M:[S]S[.DDDDDD]
  • [H]H : heures à un ou deux chiffres (valeurs valides de 00 à 23)
  • [M]M : minutes à un ou deux chiffres (valeurs valides de 00 à 59)
  • [S]S : secondes à un ou deux chiffres (valeurs valides de 00 à 59)
  • [.DDDDDD] : jusqu'à six chiffres fractionnaires (c'est-à-dire avec une précision à la microseconde près)

Type Timestamp (horodatage)

Nom Description Plage
TIMESTAMP Représente un moment précis absolu, à la microseconde près. De 0001-01-01 00:00:00 à 9999-12-31 23:59:59.999999 UTC.

Un horodatage représente un moment précis, indépendant de tout fuseau horaire ou de toute convention telle que le passage à l'heure d'été.

Le type TIMESTAMP fournit une précision de l'ordre de la microseconde.

Format canonique

YYYY-[M]M-[D]D[( |T)[H]H:[M]M:[S]S[.DDDDDD]][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 : heures à un ou deux chiffres (valeurs valides de 00 à 23)
  • [M]M : minutes à un ou deux chiffres (valeurs valides de 00 à 59)
  • [S]S : secondes à un ou deux chiffres (valeurs valides de 00 à 59)
  • [.DDDDDD] : jusqu'à six chiffres fractionnaires (c'est-à-dire avec une précision à la microseconde près)
  • [time zone] : chaîne représentant le fuseau horaire. Pour plus de précisions, consultez la section 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 particulier. Un horodatage au format de chaîne peut inclure un fuseau horaire. Lorsqu'un fuseau horaire n'est pas spécifié explicitement, le fuseau horaire par défaut est utilisé (UTC).

Fuseaux horaires

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)

Format de décalage
(+|-)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

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 Wikipedia List of tz database time zones (Liste des fuseaux horaires de la base de données tz).

Format
continent/[region/]city
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, le fuseau horaire America/Los_Angeles signale la même heure que UTC-7:00 à l'heure d'été, mais également la même heure que UTC-8:00 en dehors de l'heure d'été.

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.

Type Array (tableau)

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

Actuellement, BigQuery comporte deux limites concernant les valeurs NULL et ARRAY :

  • BigQuery génère une erreur si le résultat de la requête comprend des ARRAY contenant des éléments NULL, bien que de tels ARRAY puissent être utilisés dans la requête.
  • BigQuery traduit les valeurs ARRAY NULL en ARRAY vides dans le résultat de la requête, bien que les valeurs NULL et ARRAY vides représentent deux valeurs distinctes dans la requête.

Déclarer un type ARRAY

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

Format

ARRAY<T>

Exemples

Déclaration de type Signification
ARRAY<INT64> Tableau simple de nombres entiers de 64 bits.
ARRAY<STRUCT<INT64, INT64>> Tableau de structures contenant chacune deux entiers de 64 bits.
ARRAY<ARRAY<INT64>>
(non compatible)
Cette déclaration de type est non valide, et n'est mentionnée ici que pour le cas où vous chercheriez à savoir 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.

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

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

Format

STRUCT<T>

Exemples

Déclaration de type Signification
STRUCT<INT64> Structure simple avec un seul champ d'entier de 64 bits sans nom
STRUCT<x STRUCT<y INT64, z INT64>> Structure comprenant une structure imbriquée nommée x. La structure x possède 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

Format
(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

Format
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

Format
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 le type de champ field_type exact 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.

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

Envoyer des commentaires concernant…

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