Opérateurs

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 est NULL.
• 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 et NaN ne peuvent être renvoyés que si l'un des opérandes est +/-inf ou NaN. 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ée NULL renvoie NULL.

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 : Un signe de pourcentage "%" correspond à un nombre quelconque de caractères ou d'octets. Un trait de soulignement "_" correspond à un caractère ou un octet unique. Vous pouvez échapper les caractères "\", "_" ou "%" à l'aide de deux barres obliques inverses. Par exemple, "\\%". Si vous utilisez des chaînes brutes, une seule barre oblique inverse est nécessaire. Exemple :r"\%"
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 expression NULL du côté gauche et une expression non vide du côté droit est toujours NULL.
• IN avec NULL dans la liste IN ne peut renvoyer que TRUE ou NULL, mais jamais FALSE.
• NULL IN (NULL) renvoie NULL.
• IN UNNEST(<NULL array>) renvoie FALSE (et non NULL).
• NOT IN avec NULL dans la liste IN ne peut renvoyer que FALSE ou NULL, 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>