Cette page présente tous les types de données GoogleSQL pour BigQuery, y compris les informations concernant leurs domaines de valeur. 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 :
Types de données présentant une possibilité de valeur nulle
Pour les types de données présentant une possibilité de valeur nulle, NULL
est une valeur valide. Actuellement, tous les types de données existants présentent une possibilité de valeur nulle, mais des conditions s'appliquent aux tableaux.
Types de données pouvant être triés
Les expressions des types de données pouvant être triés peuvent être utilisées dans une clause ORDER BY
.
S'applique à tous les types de données à l'exception de :
ARRAY
STRUCT
GEOGRAPHY
JSON
Commande NULL
Dans le contexte de la clause ORDER BY
, les valeurs NULL
constituent la valeur minimale possible. C'est-à-dire que les NULL
apparaissent en premier dans les tris ASC
et en dernier dans les tris DESC
.
Les valeurs NULL
peuvent être spécifiées en tant que première ou dernière valeur d'une colonne (indifféremment de l'utilisation de ASC
ou DESC
) grâce aux modificateurs NULLS FIRST
ou NULLS LAST
, respectivement.
Pour en savoir plus sur l'utilisation de ASC
, DESC
, NULLS FIRST
et NULLS LAST
, consultez la clause ORDER BY
.
Trier des nombres à virgule flottante
Les valeurs à virgule flottante sont triées dans l'ordre suivant, de la plus petite à la plus grande :
NULL
NaN
: toutes les valeursNaN
sont considérées comme équivalentes lors du tri.-inf
- Nombres négatifs
- 0 ou -0 - Toutes les valeurs zéro sont considérées comme égales lors du tri.
- Nombres positifs
+inf
Types de données pouvant être groupés
Les types de données pouvant être groupés peuvent 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 sont acceptés, à l'exception des suivants :
GEOGRAPHY
JSON
ARRAY
STRUCT
Les valeurs spéciales à virgule flottante sont regroupées comme suit (en incluant le regroupement de clause GROUP BY
et le regroupement de mot clé DISTINCT
) :
NULL
NaN
: toutes les valeursNaN
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
Types de données comparables
Les valeurs d'un même type de données comparable peuvent être comparées. Tous les types de données sont acceptés, à l'exception des suivants :
GEOGRAPHY
JSON
Remarques :
- 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.
- Pour comparer des valeurs géographiques, 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 classifiables
Les types de données classifiables sont compatibles avec le classement, qui détermine les modalités de tri et de comparaison des chaînes. Les types de données ci-après sont compatibles avec le classement :
- String
- Champs de chaîne dans une structure
- Éléments de chaîne dans un tableau
La taille maximale d'une colonne est de 10 Mio, qu'elle soit de type scalaire ou matriciel.
Tailles des types de données
Le tableau suivant indique la taille en octets logiques de chaque type de données accepté.
Data type | Taille |
---|---|
ARRAY |
Somme de la taille de ses éléments. Par exemple, un tableau défini comme (ARRAY<INT64> ) contenant 4 entrées équivaut à 32 octets logiques (4 entrées x 8 octets logiques). |
BIGNUMERIC |
32 octets logiques |
BOOL |
1 octet logique |
BYTES |
2 octets logiques + nombre d'octets logiques dans la valeur |
DATE |
8 octets logiques |
DATETIME |
8 octets logiques |
FLOAT64 |
8 octets logiques |
GEOGRAPHY |
16 octets logiques + 24 octets logiques x nombre de sommets dans le type géographique. Vous pouvez vérifier ce nombre à l'aide de la fonction ST_NumPoints . |
INT64 |
8 octets logiques |
INTERVAL |
16 octets logiques |
JSON |
Nombre d'octets logiques de l'encodage UTF-8 de la chaîne au format JSON équivalente après normalisation. |
NUMERIC |
16 octets logiques |
STRING |
2 octets + taille de la chaîne encodée en UTF-8 |
STRUCT |
0 octet + taille des champs contenus |
TIME |
8 octets logiques |
TIMESTAMP |
8 octets logiques |
Une valeur NULL
, quel que soit le type de données, équivaut à 0 octet logique.
Les colonnes répétées sont stockées sous la forme de tableaux, et leur taille est calculée en fonction du type de données et du nombre de valeurs de la colonne. Par exemple, la taille d'une colonne d'entiers (INT64
) répétée (ARRAY<INT64>
) et contenant 4 entrées équivaut à 32 octets (4 entrées x 8 octets). La taille totale de toutes les valeurs d'une ligne de table ne peut pas dépasser la taille maximale de ligne.
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 tableau. |
Un tableau est une liste numérotée comportant zéro ou plusieurs éléments dont la valeur est d'un type autre que tableau. 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
.
Pour en savoir plus sur la représentation littérale d'un type de tableau, consultez la section Littéraux de tableau.
Pour en savoir plus sur l'utilisation des tableaux en GoogleSQL, consultez la page Utiliser des tableaux.
Valeurs NULL
et type de tableau
Actuellement, GoogleSQL pour BigQuery dispose des règles suivantes concernant les NULL
et les tableaux :
Un tableau peut être
NULL
.Exemple :
SELECT CAST(NULL AS ARRAY<INT64>) IS NULL AS array_is_null; +---------------+ | array_is_null | +---------------+ | TRUE | +---------------+
GoogleSQL pour BigQuery traduit un tableau
NULL
en un tableau vide dans le résultat de la requête, bien que dans la requête, les tableauxNULL
et vide soient deux valeurs distinctes.Exemple :
WITH Items AS ( SELECT [] AS numbers, "Empty array in query" AS description UNION ALL SELECT CAST(NULL AS ARRAY<INT64>), "NULL array in query") SELECT numbers, description, numbers IS NULL AS numbers_null FROM Items; +---------+----------------------+--------------+ | numbers | description | numbers_null | +---------+----------------------+--------------+ | [] | Empty array in query | false | | [] | NULL array in query | true | +---------+----------------------+--------------+
Lorsque vous écrivez un tableau
NULL
dans une table, il est converti en tableau vide. Si vous écrivezItems
dans une table de la requête précédente, chaque tableau est écrit sous la forme d'un tableau vide :SELECT numbers, description, numbers IS NULL AS numbers_null FROM Items; +---------+----------------------+--------------+ | numbers | description | numbers_null | +---------+----------------------+--------------+ | [] | Empty array in query | false | | [] | NULL array in query | false | +---------+----------------------+--------------+
GoogleSQL pour BigQuery génère une erreur si le résultat de la requête comprend un tableau contenant des éléments
NULL
, bien qu'un tel tableau 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 tableau 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.
Utiliser des littéraux de tableau
Vous pouvez créer un littéral de tableau dans GoogleSQL à l'aide de crochets ([
et ]
). Chaque élément d'un tableau est séparé par une virgule.
SELECT [1, 2, 3] AS numbers;
SELECT ["apple", "pear", "orange"] AS fruit;
SELECT [true, false, true] AS booleans;
Vous pouvez également créer des tableaux à partir d'expressions de types compatibles. Exemple :
SELECT [a, b, c]
FROM
(SELECT 5 AS a,
37 AS b,
406 AS c);
SELECT [a, b, c]
FROM
(SELECT CAST(5 AS INT64) AS a,
CAST(37 AS FLOAT64) AS b,
406 AS c);
Notez que le deuxième exemple contient trois expressions : une qui renvoie INT64
, une qui renvoie FLOAT64
et une qui déclare un littéral. Cette expression fonctionne, car les trois expressions partagent FLOAT64
en tant que supertype.
Pour déclarer un type de données spécifique pour un tableau, utilisez des chevrons (<
et >
). Par exemple :
SELECT ARRAY<FLOAT64>[1, 2, 3] AS floats;
Les tableaux de la plupart des types de données, tels que INT64
ou STRING
, ne nécessitent pas d'être déclarés au préalable.
SELECT [1, 2, 3] AS numbers;
Vous pouvez écrire un tableau vide d'un type spécifique en utilisant ARRAY<type>[]
. Vous pouvez également écrire un tableau vide non typé à l'aide de []
, auquel cas GoogleSQL tente de déduire le type de tableau à partir du contexte environnant. Si GoogleSQL ne peut pas déduire de type, le type par défaut ARRAY<INT64>
est utilisé.
Utiliser des valeurs générées
Vous pouvez également construire un objet ARRAY
avec des valeurs générées.
Générer des tableaux d'entiers
GENERATE_ARRAY
génère un tableau de valeurs à partir d'une valeur de début et de fin, et d'une valeur d'intervalle.
Par exemple, la requête suivante génère un tableau contenant tous les entiers impairs de 11 à 33 inclus :
SELECT GENERATE_ARRAY(11, 33, 2) AS odds;
+--------------------------------------------------+
| odds |
+--------------------------------------------------+
| [11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33] |
+--------------------------------------------------+
Vous pouvez également générer un tableau de valeurs allant dans l'ordre décroissant en indiquant une valeur d'intervalle négative :
SELECT GENERATE_ARRAY(21, 14, -1) AS countdown;
+----------------------------------+
| countdown |
+----------------------------------+
| [21, 20, 19, 18, 17, 16, 15, 14] |
+----------------------------------+
Générer des tableaux de dates
GENERATE_DATE_ARRAY
génère un tableau de DATE
s à partir d'une DATE
de début et de fin, et d'une valeur d'intervalle INTERVAL
.
Vous pouvez générer un ensemble de valeurs de DATE
à l'aide de GENERATE_DATE_ARRAY
. Par exemple, cette requête renvoie la DATE
actuelle et les DATE
s suivantes à des intervalles d'une semaine (WEEK
), jusqu'à une DATE
ultérieure incluse :
SELECT
GENERATE_DATE_ARRAY('2017-11-21', '2017-12-31', INTERVAL 1 WEEK)
AS date_array;
+--------------------------------------------------------------------------+
| date_array |
+--------------------------------------------------------------------------+
| [2017-11-21, 2017-11-28, 2017-12-05, 2017-12-12, 2017-12-19, 2017-12-26] |
+--------------------------------------------------------------------------+
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 :
NULL
FALSE
TRUE
Type Bytes
Nom | Description |
---|---|
BYTES |
Données binaires de longueur variable. |
Les éléments String et Bytes sont des types distincts qui ne peuvent pas être utilisés de manière interchangeable. La plupart des fonctions de Strings 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.
Pour en savoir plus sur la représentation littérale d'un type d'octets, consultez la section Littéraux d'octets.
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
Pour en savoir plus sur la représentation littérale d'un type de date, consultez la section Littéraux de date.
Type Datetime (date/heure)
Nom | Plage |
---|---|
DATETIME |
0001-01-01 00:00:00 à 9999-12-31 23:59:59.999999 |
Une valeur Datetime représente une date et une heure telles qu'affichées sur une montre, 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éparateurT
[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)
Pour en savoir plus sur la représentation littérale d'un type de date/heure, consultez la section Littéraux de date/heure.
Type Geography (géographie)
Nom | Description |
---|---|
GEOGRAPHY |
Ensemble de points, de polylignes et de polygones, représenté sous la forme d'un jeu de points, ou un sous-ensemble de la surface de la Terre. |
Le type géographique est basé sur la spécification SFS (OGC Simple Features) et peut contenir les objets suivants :
Objet géographique | Description |
---|---|
Point |
Un seul emplacement dans l'espace de coordonnées appelé "point". 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. Syntaxe : POINT(x_coordinate y_coordinate)Exemples : POINT(32 210) POINT EMPTY |
LineString |
Représente une polyligne, qui est un objet géométrique à une dimension, avec une séquence de points et d'arêtes géodésiques entre elles. Syntaxe : LINESTRING(point[, ...])Exemples : LINESTRING(1 1, 2 1, 3.1 2.88, 3 -3) LINESTRING EMPTY |
Polygon |
Un polygone, représenté sous la forme d'une surface plane définie par une limite externe et par zéro ou plusieurs limites internes. 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. Syntaxe : POLYGON(interior_ring[, ...]) interior_ring: (point[, ...])Exemples : POLYGON((0 0, 2 2, 2 0, 0 0), (2 2, 3 4, 2 4)) POLYGON EMPTY |
MultiPoint |
Un ensemble de points. Syntaxe : MULTIPOINT(point[, ...])Exemples : MULTIPOINT(0 32, 123 9, 48 67) MULTIPOINT EMPTY |
MultiLineString |
Représente une multipolyligne, qui est une collection de polylignes. Syntaxe : MULTILINESTRING((linestring)[, ...])Exemples : MULTILINESTRING((2 2, 3 4), (5 6, 7 7)) MULTILINESTRING EMPTY |
MultiPolygon |
Représente un multipolygone, qui est une collection de polygones. Syntaxe : MULTIPOLYGON((polygon)[, ...])Exemples : MULTIPOLYGON(((0 -1, 1 0, 0 -1)), ((0 0, 2 2, 3 0), (2 2, 3 4, 2 4, 1 9))) MULTIPOLYGON EMPTY |
GeometryCollection |
Représente une collection de géométries avec des éléments de différentes dimensions ou une zone géographique vide. Syntaxe : GEOMETRYCOLLECTION(geography_object[, ...])Exemples : GEOMETRYCOLLECTION(MULTIPOINT(-1 2, 0 12), LINESTRING(-2 4, 0 6)) GEOMETRYCOLLECTION EMPTY |
Les points, les polylignes et les polygones d'une valeur géographique 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 valeur géographique qui ne contient aucun point, aucune polyligne et aucun polygone, on parle d'une valeur géographique vide. Une valeur géographique vide n'est pas associée à une forme géométrique particulière. Par exemple, la requête suivante produit les mêmes résultats :
SELECT
ST_GEOGFROMTEXT('POINT EMPTY') AS a,
ST_GEOGFROMTEXT('GEOMETRYCOLLECTION EMPTY') AS b
+--------------------------+--------------------------+
| a | b |
+--------------------------+--------------------------+
| GEOMETRYCOLLECTION EMPTY | GEOMETRYCOLLECTION EMPTY |
+--------------------------+--------------------------+
La structure des objets à géométrie composites n'est pas préservée si un type plus simple peut être produit. Par exemple, dans la colonne b
, GEOMETRYCOLLECTION
avec (POINT(1 1)
et POINT(2 2)
est converti dans la géométrie la plus simple possible, MULTIPOINT(1 1, 2 2)
.
SELECT
ST_GEOGFROMTEXT('MULTIPOINT(1 1, 2 2)') AS a,
ST_GEOGFROMTEXT('GEOMETRYCOLLECTION(POINT(1 1), POINT(2 2))') AS b
+----------------------+----------------------+
| a | b |
+----------------------+----------------------+
| MULTIPOINT(1 1, 2 2) | MULTIPOINT(1 1, 2 2) |
+----------------------+----------------------+
Un objet de type géographique représente le résultat ou un argument d'une fonction de géographie.
Type d'intervalle
Nom | Plage |
---|---|
INTERVAL |
De -10000-0 -3660000 -87840000:0:0 à 10000-0 3660000 87840000:0:0 |
Un objet INTERVAL
représente la durée, sans faire référence à un moment précis.
Format canonique
[sign]Y-M [sign]D [sign]H:M:S[.F]
sign
:+
ou-
Y
: annéeM
: moisD
: jourH
: heureM
: minuteS
: seconde[.F]
: jusqu'à six chiffres fractionnaires (précision de l'ordre de la microseconde)
Pour en savoir plus sur la représentation littérale d'un type d'intervalle, consultez la section Littéraux d'intervalle.
Créer un intervalle
Vous pouvez créer un intervalle avec un littéral d'intervalle compatible avec une seule partie de date et heure ou une plage de parties de date et heure.
Créer un intervalle avec une seule partie de date et heure
INTERVAL int64_expression datetime_part
Vous pouvez créer un objet INTERVAL
avec une expression INT64
et une partie de date et heure compatible avec l'intervalle. Exemple :
-- 1 year, 0 months, 0 days, 0 hours, 0 minutes, and 0 seconds (1-0 0 0:0:0)
INTERVAL 1 YEAR
INTERVAL 4 QUARTER
INTERVAL 12 MONTH
-- 0 years, 3 months, 0 days, 0 hours, 0 minutes, and 0 seconds (0-3 0 0:0:0)
INTERVAL 1 QUARTER
INTERVAL 3 MONTH
-- 0 years, 0 months, 42 days, 0 hours, 0 minutes, and 0 seconds (0-0 42 0:0:0)
INTERVAL 6 WEEK
INTERVAL 42 DAY
-- 0 years, 0 months, 0 days, 25 hours, 0 minutes, and 0 seconds (0-0 0 25:0:0)
INTERVAL 25 HOUR
INTERVAL 1500 MINUTE
INTERVAL 90000 SECOND
-- 0 years, 0 months, 0 days, 1 hours, 30 minutes, and 0 seconds (0-0 0 1:30:0)
INTERVAL 90 MINUTE
-- 0 years, 0 months, 0 days, 0 hours, 1 minutes, and 30 seconds (0-0 0 0:1:30)
INTERVAL 90 SECOND
-- 0 years, 0 months, -5 days, 0 hours, 0 minutes, and 0 seconds (0-0 -5 0:0:0)
INTERVAL -5 DAY
Pour obtenir d'autres exemples, consultez la section Littéraux d'intervalle.
Créer un intervalle avec une plage de parties de date et heure
INTERVAL datetime_parts_string starting_datetime_part TO ending_datetime_part
Vous pouvez créer un objet INTERVAL
avec un élément STRING
contenant les éléments de date et heure que vous souhaitez inclure, une partie de date et heure de début et une partie de date et heure de fin. L'objet INTERVAL
obtenu ne comprend que des parties de date et heure dans la plage spécifiée.
Vous pouvez utiliser l'un des formats suivants avec les parties de date et heure compatibles avec des intervalles :
Chaîne de parties de date et heure | Parties de date et heure | Exemple |
---|---|---|
Y-M |
YEAR TO MONTH |
INTERVAL '2-11' YEAR TO MONTH |
Y-M D |
YEAR TO DAY |
INTERVAL '2-11 28' YEAR TO DAY |
Y-M D H |
YEAR TO HOUR |
INTERVAL '2-11 28 16' YEAR TO HOUR |
Y-M D H:M |
YEAR TO MINUTE |
INTERVAL '2-11 28 16:15' YEAR TO MINUTE |
Y-M D H:M:S |
YEAR TO SECOND |
INTERVAL '2-11 28 16:15:14' YEAR TO SECOND |
M D |
MONTH TO DAY |
INTERVAL '11 28' MONTH TO DAY |
M D H |
MONTH TO HOUR |
INTERVAL '11 28 16' MONTH TO HOUR |
M D H:M |
MONTH TO MINUTE |
INTERVAL '11 28 16:15' MONTH TO MINUTE |
M D H:M:S |
MONTH TO SECOND |
INTERVAL '11 28 16:15:14' MONTH TO SECOND |
D H |
DAY TO HOUR |
INTERVAL '28 16' DAY TO HOUR |
D H:M |
DAY TO MINUTE |
INTERVAL '28 16:15' DAY TO MINUTE |
D H:M:S |
DAY TO SECOND |
INTERVAL '28 16:15:14' DAY TO SECOND |
H:M |
HOUR TO MINUTE |
INTERVAL '16:15' HOUR TO MINUTE |
H:M:S |
HOUR TO SECOND |
INTERVAL '16:15:14' HOUR TO SECOND |
M:S |
MINUTE TO SECOND |
INTERVAL '15:14' MINUTE TO SECOND |
Exemple :
-- 0 years, 8 months, 20 days, 17 hours, 0 minutes, and 0 seconds (0-8 20 17:0:0)
INTERVAL '8 20 17' MONTH TO HOUR
-- 0 years, 8 months, -20 days, 17 hours, 0 minutes, and 0 seconds (0-8 -20 17:0:0)
INTERVAL '8 -20 17' MONTH TO HOUR
Pour obtenir d'autres exemples, consultez la section Littéraux d'intervalle.
Parties de date et heure compatibles avec l'intervalle
Vous pouvez utiliser les parties de date et heure suivantes pour créer un intervalle :
YEAR
: nombre d'années,Y
.QUARTER
: nombre de trimestres. Chaque trimestre est converti en3
mois,M
.MONTH
: nombre de mois,M
. Tous les12
mois sont convertis en1
an.WEEK
: nombre de semaines. Chaque semaine est convertie en7
jours,D
.DAY
: nombre de jours,D
.HOUR
: nombre d'heures,H
.MINUTE
: nombre de minutes,M
. Toutes les60
minutes sont converties en1
heure.SECOND
: nombre de secondes,S
. Toutes les60
secondes sont converties en1
minute.
Type JSON
Nom | Description |
---|---|
JSON |
Représente JSON, un format d'échange de données léger. |
Lorsque vous créez une valeur de type JSON, attendez-vous à observer ces comportements de normalisation :
- Les valeurs booléennes, les chaînes et les valeurs NULL sont conservées exactement.
- Les caractères d'espacement ne sont pas conservés.
- Une valeur JSON peut stocker des nombres entiers compris entre -9 223 372 036 854 775 808 (plus petit entier de 64 bits signé) et 18 446 744 073 709 551 615 (plus grand entier de 64 bits non signé) et nombres à virgule flottante dans un domaine de
FLOAT64
- L'ordre des éléments dans un tableau est conservé exactement.
- L'ordre des membres d'un objet n'est ni garanti, ni préservé.
- Si un objet comporte des clés en double, la première clé trouvée est conservée.
- Jusqu'à 500 niveaux peuvent être imbriqués.
- Le format de la représentation de chaîne d'origine d'un nombre JSON peut ne pas être conservé.
Pour en savoir plus sur la représentation littérale d'un type JSON, consultez la section Littéraux JSON.
Types numériques
Les types numériques incluent les types suivants :
INT64
avec l'aliasINT
,SMALLINT
,INTEGER
,BIGINT
,TINYINT
,BYTEINT
NUMERIC
avec l'aliasDECIMAL
BIGNUMERIC
avec l'aliasBIGDECIMAL
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
.
Pour en savoir plus sur la représentation littérale d'un type entier, consultez la section Littéraux entiers.
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
.
Pour en savoir plus sur la représentation littérale d'un type DECIMAL
, consultez la section Littéraux NUMERIC
.
Pour en savoir plus sur la représentation littérale d'un type BIGDECIMAL
, consultez la section Littéraux 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 colonneNUMERIC(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.
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). |
Pour en savoir plus sur la représentation littérale d'un type à virgule flottante, consultez la page Littéraux à virgule flottante.
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 de2
. Lorsque cette valeur est affichée sous forme de chaîne, elle est arrondie à un nombre limité de chiffres. La valeur d'approximation de0.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égationSUM
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 sommeSUM
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 |
Pour plus d'informations sur le tri et le regroupement de ces valeurs afin qu'elles puissent être comparées, consultez la page Trier les valeurs à virgule flottante.
Type String
Nom | Description |
---|---|
STRING |
Données constituées de caractères de longueur variable (Unicode) |
Les valeurs d'entrée de chaîne doivent être encodées au format UTF-8 pour que les valeurs de sortie de chaîne 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 de chaîne 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 de chaîne 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 Strings 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.
Pour en savoir plus sur la représentation littérale d'un type de chaîne, consultez la page Littéraux de chaîne.
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) |
Pour en savoir plus sur la représentation littérale d'un type Struct, consultez la section Littéraux structurés.
Déclarer un type Struct
STRUCT<T>
Les types Struct 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>
|
Objet Struct 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>>
|
Objet Struct 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>>
|
Objet Struct comprenant un tableau nommé inner_array , contenant des entiers de 64 bits. |
Créer 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 | Remarques |
---|---|---|
(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 |
Une valeur Time représente une heure de la journée, telle qu'affichée sur une horloge, 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)
Pour en savoir plus sur la représentation littérale d'un type d'heure, consultez la section Littéraux d'heure.
Type Timestamp
Nom | Plage |
---|---|
TIMESTAMP |
De 0001-01-01 00:00:00 à 9999-12-31 23:59:59.999999 UTC |
Une valeur 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.
Un type Timestamp est généralement représenté en interne comme le nombre de microsecondes écoulées depuis un moment initial fixe dans le temps.
Notez qu'un objet Timestamp lui-même ne comporte pas de fuseau horaire. Il représente le même instant temporel dans le monde entier. Cependant, l'affichage d'un horodatage pour une lisibilité humaine inclut généralement une date, une heure et un fuseau horaire, dans un format dépendant de la mise en œuvre. Par exemple, les valeurs "2020-01-01 00:00:00 UTC", "2019-12-31 19:00:00 America/New_York" et "2020-01-01 05:30:00 Asie/Kolkata" affichées représentent toutes le même instant temporel et représentent donc la même valeur Timestamp.
- Pour représenter une date telle qu'elle peut apparaître sur un calendrier (date civile), utilisez une valeur Date.
- Pour représenter une heure telle qu'elle peut apparaître sur une horloge (heure civile), utilisez une valeur Time.
- Pour représenter une date et une heure telles qu'elles peuvent apparaître sur une montre, utilisez la valeur Datetime.
Format canonique pour les littéraux d'horodatage
Le format canonique d'un littéral Timestamp comporte les parties suivantes :
{
civil_date_time [time_zone] |
civil_date_time[time_zone_offset] |
civil_date_time[utc_time_zone]
}
civil_date_time:
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éparateurT
[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 d'informations, consultez la section Fuseaux horaires.[time_zone_offset]
: chaîne représentant le décalage par rapport au fuseau horaire du temps universel coordonné (UTC). Pour plus d'informations, consultez la section Fuseaux horaires.[utc_time_zone]
: chaîne représentant le temps universel coordonné (UTC), généralement la lettreZ
. Pour plus d'informations, consultez la section Fuseaux horaires.
Pour en savoir plus sur la représentation littérale d'un type d'horodatage, consultez la section Littéraux d'horodatage.
Fuseaux horaires
Un fuseau horaire est utilisé lors de la conversion d'une date ou d'une heure civile (comme cela peut apparaître dans un calendrier ou une horloge) en horodatage (heure absolue), ou inversement. Cela inclut l'opération d'analyse d'une chaîne contenant une date et une heure civile, telle que "2020-01-01 00:00:00" et de la convertir en horodatage. La valeur d'horodatage obtenue ne stocke pas de fuseau horaire spécifique, car elle représente un instantané dans le monde entier.
Les fuseaux horaires sont représentés par des chaînes dans l'un de ces deux formats canoniques :