Les opérateurs sont représentés par des caractères spéciaux ou des mots-clés ; ils n'utilisent pas la syntaxe d'appel de fonction. Un opérateur manipule un certain nombre d'entrées de données (ces entrées de données sont également appelées opérandes), puis renvoie un résultat.
Conventions communes :
- Sauf indication contraire, tous les opérateurs renvoient
NULL
lorsque l'un des opérandes estNULL
. - Tous les opérateurs génèrent une erreur lorsque le résultat du calcul entraîne un débordement.
- Pour toutes les opérations en virgule flottante,
+/-inf
etNaN
ne peuvent être renvoyés que si l'un des opérandes est+/-inf
ouNaN
. Dans les autres cas, une erreur est renvoyée.
Le tableau ci-dessous répertorie tous les opérateurs SQL de Cloud Spanner, classés de la priorité la plus élevée à la plus faible, c'est-à-dire en fonction de l'ordre selon lequel ils seront évalués dans une instruction.
Ordre de priorité | Opérateur | Types de données d'entrée | Nom | Arité de l'opérateur |
---|---|---|---|---|
1 | . | STRUCT |
Opérateur d'accès au champ Membre | Binaire |
[ ] | ARRAY | Position du tableau. Doit être utilisé avec OFFSET ou ORDINAL (consultez la section Fonctions de tableau). | Binaire | |
2 | - | Tous les types numériques | Moins unaire | Unaire |
~ | Entier ou BYTES | Opérateur NOT (PAS) au niveau du bit | Unaire | |
3 | * | Tous les types numériques | Multiplication | Binaire |
/ | Tous les types numériques | Division | Binaire | |
|| | STRING, BYTES ou ARRAY<T> | Opérateur de concaténation | Binaire | |
4 | + | Tous les types numériques | Addition | Binaire |
- | Tous les types numériques | Soustraction | Binaire | |
5 | << | Entier ou BYTES | Décalage à gauche bit à bit | Binaire |
>> | Entier ou BYTES | Décalage à droite bit à bit | Binaire | |
6 | & | Entier ou BYTES | Opérateur AND (ET) au niveau du bit | Binaire |
7 | ^ | Entier ou BYTES | Opérateur XOR (OU exclusif) au niveau du bit | Binaire |
8 | | | Entier ou BYTES | Opérateur OR (OU) au niveau du bit | Binaire |
9 (Opérateurs de comparaison) | = | Tout type comparable. Pour obtenir la liste complète, consultez la page Types de données. | Equal (Égal à) | Binaire |
< | Tout type comparable. Pour obtenir la liste complète, consultez la page Types de données. | Moins de | Binaire | |
> | Tout type comparable. Pour obtenir la liste complète, consultez la page Types de données. | Supérieur à | Binaire | |
<= | Tout type comparable. Pour obtenir la liste complète, consultez la page Types de données. | Inférieur ou égal à | Binaire | |
>= | Tout type comparable. Pour obtenir la liste complète, consultez la page Types de données. | Supérieur ou égal à | Binaire | |
!=, <> | Tout type comparable. Pour obtenir la liste complète, consultez la page Types de données. | Not Equal (Non égal à) | Binaire | |
[NOT] LIKE | STRING et octet | La valeur correspond [ne correspond pas] au modèle spécifié | Binaire | |
[NOT] BETWEEN | Tous types comparables. Pour obtenir la liste complète, consultez la page Types de données. | La valeur est [n'est pas] comprise dans la plage spécifiée | Binaire | |
[NOT] IN | Tous types comparables. Pour obtenir la liste complète, consultez la page Types de données. | La valeur est [n'est pas] comprise dans l'ensemble de valeurs spécifié | Binaire | |
IS [NOT] NULL |
Tous | La valeur est [n'est pas] NULL |
Unaire | |
IS [NOT] TRUE | BOOL | La valeur est [n'est pas] TRUE. | Unaire | |
IS [NOT] FALSE | BOOL | La valeur est [n'est pas] FALSE. | Unaire | |
10 | NOT | BOOL | Logical NOT (Opérateur logique PAS) | Unaire |
11 | AND | BOOL | Logical AND (Opérateur logique ET) | Binaire |
12 | OR | BOOL | Logical OR (Opérateur logique OU) | Binaire |
Les opérateurs ayant le même niveau de priorité sont considérés selon un schéma "associatif gauche". Cela signifie que le regroupement de ces opérateurs commence par la gauche, puis se poursuit vers la droite. Par exemple, l'expression :
x AND y AND z
est interprétée comme :
( ( x AND y ) AND z )
L'expression :
x * y / z
est interprétée comme :
( ( x * y ) / z )
Tous les opérateurs de comparaison ont la même priorité, mais les opérateurs de comparaison ne sont pas associatifs. Par conséquent, des parenthèses sont nécessaires afin de résoudre les ambiguïtés. Exemple :
(x < y) IS FALSE
Opérateurs d'accès aux éléments
Opérateur | Syntaxe | Types de données d'entrée | Type de données de résultat | Description |
---|---|---|---|---|
. | expression.nom_de_champ_1... | STRUCT |
Type T stocké dans nom_de_champ_1 | Opérateur point. Peut être utilisé pour accéder à des champs imbriqués, par exemple : expression.nom_de_champ_1.nom_de_champ_2... |
[ ] | array_expression [position_keyword (int_expression)] | Consultez la section "Fonctions de tableau". | Type T stocké dans un tableau | position_keyword est OFFSET ou ORDINAL. Consultez la section Fonctions de tableau pour consulter les deux fonctions qui utilisent cet opérateur. |
Opérateurs arithmétiques
Tous les opérateurs arithmétiques acceptent les entrées de type numérique T, et les résultats sont de type T sauf indication contraire dans la description ci-dessous :
Nom | Syntaxe |
---|---|
Addition | X + Y |
Soustraction | X - Y |
Multiplication | X * Y |
Division | X / Y |
Moins unaire | - X |
REMARQUE : Les opérations de division par zéro renvoient une erreur. Pour qu'un résultat différent soit renvoyé, utilisez la fonction IEEE_DIVIDE ou la fonction SAFE_DIVIDE.
Types de résultats pour l'addition, la soustraction et la multiplication :
ENTRÉE | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | INT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
Types de résultats pour la division :
ENTRÉE | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
INT64 | FLOAT64 | NUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
Types de résultats pour Moins unaire :
ENTRÉE | INT64 | NUMERIC | FLOAT64 |
---|---|---|---|
RÉSULTAT | INT64 | NUMERIC | FLOAT64 |
Opérateurs bit à bit
Tous les opérateurs fonctionnant au niveau du bit renvoient le même type et la même longueur que le premier opérande.
Nom | Syntaxe | Type de données d'entrée | Description |
---|---|---|---|
Opérateur NOT (PAS) au niveau du bit | ~ X | Entier ou BYTES | Effectue une négation logique sur chaque bit, en formant le complément de la valeur binaire donnée pour chaque bit. |
Opérateur OR (OU) au niveau du bit | X | Y | X : entier ou BYTES
Y : même type que X |
Prend deux combinaisons binaires de longueur égale et effectue l'opération logique "OU inclusif" sur chaque paire de bits correspondants. Cet opérateur génère une erreur si X et Y sont des séquences BYTES de longueurs différentes. |
Opérateur XOR (OU exclusif) au niveau du bit | X ^ Y | X : entier ou BYTES
Y : même type que X |
Prend deux combinaisons binaires de longueur égale et effectue l'opération logique "OU exclusif" sur chaque paire de bits correspondants. Cet opérateur génère une erreur si X et Y sont des séquences BYTES de longueurs différentes. |
Opérateur AND (ET) au niveau du bit | X & Y | X : entier ou BYTES
Y : même type que X |
Prend deux combinaisons binaires de longueur égale et effectue l'opération logique "ET" sur chaque paire de bits correspondants. Cet opérateur génère une erreur si X et Y sont des séquences BYTES de longueurs différentes. |
Décalage à gauche | X << Y | X : entier ou BYTES
Y : INT64 |
Décale le premier opérande X vers la gauche. Cet opérateur renvoie 0 ou une séquence d'octets de b'\x00' si le deuxième opérande Y est supérieur ou égal à la longueur en bits du premier opérande X (par exemple, 64 si X est de type INT64). Cet opérateur génère une erreur si Y est négatif. |
Décalage à droite | X >> Y | X : entier ou BYTES
Y : INT64 |
Décale le premier opérande X vers la droite. Cet opérateur n'effectue pas d'extension de bit de signe avec un type signé (c'est-à-dire qu'il remplit les bits vacants à gauche avec des 0). Cet opérateur renvoie 0 ou une séquence d'octets de b'\x00' si le deuxième opérande Y est supérieur ou égal à la longueur en bits du premier opérande X (par exemple, 64 si X est de type INT64). Cet opérateur génère une erreur si Y est négatif. |
Opérateurs logiques
Cloud Spanner SQL accepte les opérateurs logiques AND
, OR
et NOT
.
Les opérateurs logiques autorisent uniquement des entrées de type BOOL ou NULL
et utilisent une logique à trois valeurs pour produire un résultat. Le résultat peut être TRUE
, FALSE
ou NULL
:
x | y | x AND y | x OR y |
---|---|---|---|
TRUE | TRUE | TRUE | TRUE |
TRUE | FALSE | FALSE | TRUE |
TRUE | NULL | NULL | TRUE |
FALSE | TRUE | FALSE | TRUE |
FALSE | FALSE | FALSE | FALSE |
FALSE | NULL | FALSE | NULL |
NULL | TRUE | NULL | TRUE |
NULL | FALSE | FALSE | NULL |
NULL | NULL | NULL | NULL |
x | NOT x |
---|---|
TRUE | FALSE |
FALSE | TRUE |
NULL | NULL |
Exemples
Les exemples de cette section font référence à une table nommée entry_table
:
+-------+
| entry |
+-------+
| a |
| b |
| c |
| NULL |
+-------+
SELECT 'a' FROM entry_table WHERE entry = 'a'
-- a => 'a' = 'a' => TRUE
-- b => 'b' = 'a' => FALSE
-- NULL => NULL = 'a' => NULL
+-------+
| entry |
+-------+
| a |
+-------+
SELECT entry FROM entry_table WHERE NOT (entry = 'a')
-- a => NOT('a' = 'a') => NOT(TRUE) => FALSE
-- b => NOT('b' = 'a') => NOT(FALSE) => TRUE
-- NULL => NOT(NULL = 'a') => NOT(NULL) => NULL
+-------+
| entry |
+-------+
| b |
| c |
+-------+
SELECT entry FROM entry_table WHERE entry IS NULL
-- a => 'a' IS NULL => FALSE
-- b => 'b' IS NULL => FALSE
-- NULL => NULL IS NULL => TRUE
+-------+
| entry |
+-------+
| NULL |
+-------+
Opérateurs de comparaison
Les comparaisons renvoient toujours une valeur de type BOOL. Les comparaisons nécessitent généralement que les deux opérandes soient du même type. Si les opérandes sont de types différents et que Cloud Spanner SQL peut convertir les valeurs de ces types en un type commun sans perte de précision, Cloud Spanner SQL les convertit généralement dans ce type commun pour la comparaison. En pareil cas, Cloud Spanner SQL va généralement convertir des types littéraux en type "non littéral" si un tel type est présent. Les types de données comparables sont définis dans la section Types de données.
Les types STRUCT n'acceptent que quatre opérateurs de comparaison : égal (=), différent (!= et <>) et "dans" (IN).
Les règles suivantes s'appliquent lors de la comparaison de ces types de données :
- FLOAT64 : toutes les comparaisons avec NaN renvoient FALSE, sauf pour
!=
et<>
qui renvoient TRUE. - BOOL : FALSE est inférieur à TRUE.
- STRING : les chaînes sont comparées point de code par point de code. Par conséquent, pour garantir que des chaînes canoniquement équivalentes seront bien considérées comme égales, il est nécessaire de les normaliser en premier lieu.
NULL
: la convention tient ici. Toute opération avec une entréeNULL
renvoieNULL
.
Nom | Syntaxe | Description |
---|---|---|
Less Than (Inférieur à) | X < Y | Renvoie TRUE (vrai) si X est inférieur à Y. |
Less Than or Equal To (Inférieur ou égal à) | X <= Y | Renvoie TRUE (vrai) si X est inférieur ou égal à Y. |
Greater Than (Supérieur à) | X > Y | Renvoie TRUE (vrai) si X est supérieur à Y. |
Greater Than or Equal To (Supérieur ou égal à) | X >= Y | Renvoie TRUE (vrai) si X est supérieur ou égal à Y. |
Equal (Égal à) | X = Y | Renvoie TRUE (vrai) si X est égal à Y. |
Not Equal (Non égal à) | X != Y X <> Y |
Renvoie TRUE si X n'est pas égal à Y. |
BETWEEN (entre) | X [NOT] BETWEEN Y AND Z | Renvoie TRUE (vrai) si X est [n'est pas] compris dans la plage spécifiée. Le résultat de "X BETWEEN Y AND Z" équivaut à "Y <= X AND X <= Z", mais X n'est évalué qu'une fois dans le premier cas. |
LIKE (comme) | X [NOT] LIKE Y | Vérifie si la STRING dans le premier opérande X correspond à un schéma spécifié par le deuxième opérande Y. Les expressions peuvent contenir les caractères suivants :
|
IN | Multiple (voir ci-dessous) | Renvoie FALSE si l'opérande de droite est vide. Renvoie NULL si l'opérande de gauche est NULL . Renvoie TRUE ou NULL (mais jamais FALSE) si l'opérande de droite contient NULL . Les arguments situés de part et d'autre de l'opérateur "IN" sont des expressions génériques. Il n'est pas absolument nécessaire que l'un des deux opérandes soit un littéral, bien que l'utilisation d'un littéral à droite soit l'approche la plus courante. X n'est évalué qu'une fois. |
Lorsque vous effectuez un test d'égalité pour des valeurs ayant un type de données STRUCT, il est possible qu'un ou plusieurs champs aient la valeur NULL
. Dans ces cas :
- Si toutes les valeurs de champ non nulles sont égales, la comparaison renvoie "NULL".
- Si certaines valeurs de champ non nulles ne sont pas égales, la comparaison renvoie "FALSE".
Le tableau suivant montre comment les types de données STRUCT sont comparés lorsqu'ils contiennent des champs dont la valeur est NULL
.
Struct1 | Struct2 | Struct1 = Struct2 |
---|---|---|
STRUCT(1, NULL) |
STRUCT(1, NULL) |
NULL |
STRUCT(1, NULL) |
STRUCT(2, NULL) |
FALSE |
STRUCT(1,2) |
STRUCT(1, NULL) |
NULL |
Opérateurs IN
L'opérateur IN
accepte les syntaxes suivantes :
x [NOT] IN (y, z, ... ) # Requires at least one element
x [NOT] IN (<subquery>)
x [NOT] IN UNNEST(<array expression>) # analysis error if the expression
# does not return an ARRAY type.
Les arguments situés de part et d'autre de l'opérateur IN
sont des expressions génériques.
Il est courant d'utiliser des littéraux sur l'expression située du côté droit, mais cela n'est pas obligatoire.
La sémantique de :
x IN (y, z, ...)
est définie comme équivalente à :
(x = y) OR (x = z) OR ...
et les formulaires de sous-requête et de tableau sont définis de la même manière.
x NOT IN ...
équivaut à :
NOT(x IN ...)
Le formulaire UNNEST traite une analyse de tableau comme UNNEST
dans la clause FROM :
x [NOT] IN UNNEST(<array expression>)
Ce formulaire est souvent utilisé avec les paramètres de tableau (ARRAY). Exemple :
x IN UNNEST(@array_parameter)
Remarque : Un ARRAY NULL
est traité de la même manière qu'un ARRAY vide.
Consultez la rubrique sur les tableaux pour plus d'informations sur l'utilisation de cette syntaxe.
Lorsque l'opérateur IN
est utilisé, la sémantique suivante s'applique :
IN
avec une expression vide du côté droit est toujours FALSE.IN
avec une expressionNULL
du côté gauche et une expression non vide du côté droit est toujoursNULL
.IN
avecNULL
dans la listeIN
ne peut renvoyer que TRUE ouNULL
, mais jamais FALSE.NULL IN (NULL)
renvoieNULL
.IN UNNEST(<NULL array>)
renvoie FALSE (et nonNULL
).NOT IN
avecNULL
dans la listeIN
ne peut renvoyer que FALSE ouNULL
, mais jamais TRUE.
IN
peut être utilisé avec des clés composées de plusieurs parties à l'aide de la syntaxe du constructeur de structure.
Par exemple :
(Key1, Key2) IN ( (12,34), (56,78) )
(Key1, Key2) IN ( SELECT (table.a, table.b) FROM table )
Consultez la section Type de structure de la rubrique "Types de données" pour plus d'informations sur cette syntaxe.
Opérateurs IS
Les opérateurs IS renvoient TRUE ou FALSE pour la condition testée. Ils ne renvoient jamais NULL
, même pour les entrées NULL
, contrairement aux fonctions IS_INF et IS_NAN définies dans la section Fonctions mathématiques. Si NOT est présent, la valeur BOOL de sortie est inversée.
Syntaxe de la fonction | Type de données d'entrée | Type de données de résultat | Description |
---|---|---|---|
X IS [NOT] NULL |
N'importe quel type de valeur | BOOL | Renvoie TRUE si l'évaluation de l'opérande X donne NULL , renvoie FALSE dans le cas contraire. |
X IS [NOT] TRUE |
BOOL | BOOL | Renvoie TRUE si l'évaluation de l'opérande BOOL donne TRUE, renvoie FALSE dans le cas contraire. |
X IS [NOT] FALSE |
BOOL | BOOL | Renvoie TRUE si l'évaluation de l'opérande BOOL donne FALSE, renvoie FALSE dans le cas contraire. |
Opérateur de concaténation
L'opérateur de concaténation combine plusieurs valeurs en une seule.
Syntaxe de la fonction | Type de données d'entrée | Type de données de résultat |
---|---|---|
STRING || STRING [ || ... ] |
STRING | STRING |
BYTES || BYTES [ || ... ] |
BYTES | STRING |
ARRAY<T> || ARRAY<T> [ || ... ] |
ARRAY<T> | ARRAY<T> |