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. Par 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ésultat pour l'addition et la multiplication :

 INT64FLOAT64
INT64INT64FLOAT64
FLOAT64FLOAT64FLOAT64

Types de résultat pour la soustraction :

 INT64FLOAT64
INT64INT64FLOAT64
FLOAT64FLOAT64FLOAT64

Types de résultats pour la division :

 INT64FLOAT64
INT64FLOAT64FLOAT64
FLOAT64FLOAT64FLOAT64

Types de résultat pour Moins unaire :

Type de données d'entrée Type de données de résultat
INT64 INT64
FLOAT64 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

Tous les opérateurs logiques n'autorisent que l'entrée BOOL.

Nom Syntaxe Description
Logical NOT (Opérateur logique PAS) NOT X Renvoie FALSE si l'entrée est TRUE. Renvoie TRUE si l'entrée est FALSE. Renvoie NULL dans les autres cas.
Logical AND (Opérateur logique ET) X AND Y Renvoie FALSE si au moins une entrée est FALSE. Renvoie TRUE si X et Y sont TRUE. Renvoie NULL dans les autres cas.
Logical OR (Opérateur logique OU) X OR Y Renvoie FALSE si X et Y sont tous deux FALSE. Renvoie TRUE si au moins une entrée est TRUE. Renvoie NULL dans les autres cas.

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