Opérateurs logiques

Les opérateurs logiques retournent le résultat d’une opération booléenne particulière sur une ou deux expressions d’entrée. Les opérateurs logiques sont également appelés opérateurs booléens.

Les opérateurs logiques ne peuvent être utilisés que comme prédicat (par exemple, dans la clause WHERE). Les expressions d’entrée doivent être des prédicats.

Voir aussi :

BOOLAND , BOOLNOT , BOOLOR , BOOLXOR

Liste des opérateurs logiques

Opérateur

Exemple de syntaxe

Description

AND

a AND b

Correspond aux deux expressions (a et b).

NOT

NOT a

Ne correspond pas à l’expression.

OR

a OR b

Correspond à l’une ou l’autre expression.

L’ordre de préséance de ces opérateurs est indiqué ci-dessous (du plus élevé au plus bas) :

  • NOT

  • AND

  • OR

Exemples

Les exemples suivants utilisent des opérateurs logiques :

Utiliser des opérateurs logiques dans les requêtes sur les données de table

Créer une table et insérer des données :

CREATE OR REPLACE TABLE logical_test1 (id INT, a INT, b VARCHAR);

INSERT INTO logical_test1 (id, a, b) VALUES (1, 8, 'Up');
INSERT INTO logical_test1 (id, a, b) VALUES (2, 25, 'Down');
INSERT INTO logical_test1 (id, a, b) VALUES (3, 15, 'Down');
INSERT INTO logical_test1 (id, a, b) VALUES (4, 47, 'Up');

SELECT * FROM logical_test1;

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  3 | 15 | Down |
|  4 | 47 | Up   |
+----+----+------+

Exécuter des requêtes qui utilisent un seul opérateur logique

Utiliser un seul opérateur logique dans la clause WHERE de diverses requêtes :

SELECT *
  FROM logical_test1
  WHERE a > 20 AND
        b = 'Down';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  2 | 25 | Down |
+----+----+------+

SELECT *
  FROM logical_test1
  WHERE a > 20 OR
        b = 'Down';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  2 | 25 | Down |
|  3 | 15 | Down |
|  4 | 47 | Up   |
+----+----+------+

SELECT *
  FROM logical_test1
  WHERE a > 20 OR
        b = 'Up';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  4 | 47 | Up   |
+----+----+------+

SELECT *
  FROM logical_test1
  WHERE NOT a > 20;

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  3 | 15 | Down |
+----+----+------+

Indiquer la priorité des opérateurs logiques

Les exemples suivants montrent la priorité des opérateurs logiques.

Le premier exemple montre que la priorité de AND est supérieure à la priorité de OR. La requête renvoie les lignes qui répondent à ces conditions :

  • b équivaut à Down.

OR

  • a équivaut à 8 AND b équivaut à Up.

SELECT *
  FROM logical_test1
  WHERE b = 'Down' OR
        a = 8 AND b = 'Up';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  3 | 15 | Down |
+----+----+------+

Vous pouvez utiliser des parenthèses dans la clause WHERE pour modifier la priorité. Par exemple, la requête suivante renvoie les lignes qui répondent à ces conditions :

  • b équivaut à Down OR a équivaut à 8.

AND

  • b équivaut à Up.

SELECT *
  FROM logical_test1
  WHERE (b = 'Down' OR a = 8) AND b = 'Up';

+----+---+----+
| ID | A | B  |
|----+---+----|
|  1 | 8 | Up |
+----+---+----+

L’exemple suivant montre que la priorité de NOT est supérieure à la priorité de AND. Par exemple, la requête suivante renvoie les lignes qui répondent à ces conditions :

  • a n’équivaut NOT à 15.

AND

  • b équivaut à Down.

SELECT *
  FROM logical_test1
  WHERE NOT a = 15 AND b = 'Down';

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  2 | 25 | Down |
+----+----+------+

Vous pouvez utiliser des parenthèses dans la clause WHERE pour modifier la priorité. Par exemple, la requête suivante renvoie les lignes qui ne répondent NOT à ces deux conditions :

  • a équivaut à 15.

AND

  • b équivaut à Down.

SELECT *
  FROM logical_test1
  WHERE NOT (a = 15 AND b = 'Down');

+----+----+------+
| ID |  A | B    |
|----+----+------|
|  1 |  8 | Up   |
|  2 | 25 | Down |
|  4 | 47 | Up   |
+----+----+------+

Utiliser des opérateurs logiques dans les requêtes sur les valeurs booléennes

Créer une table et insérer des données :

CREATE OR REPLACE TABLE logical_test2 (a BOOLEAN, b BOOLEAN);

INSERT INTO logical_test2 VALUES (0, 1);

SELECT * FROM logical_test2;

+-------+------+
| A     | B    |
|-------+------|
| False | True |
+-------+------+

La requête suivante utilise l’opérateur OR pour renvoyer les lignes où a ou b est TRUE :

SELECT a, b FROM logical_test2 WHERE a OR b;

+-------+------+
| A     | B    |
|-------+------|
| False | True |
+-------+------+

La requête suivante utilise l’opérateur AND pour renvoyer les lignes où a et b sont tous deux TRUE :

SELECT a, b FROM logical_test2 WHERE a AND b;

+---+---+
| A | B |
|---+---|
+---+---+

La requête suivante utilise l’opérateur AND et l’opérateur NOT pour renvoyer les lignes où b est TRUE et a est FALSE :

SELECT a, b FROM logical_test2 WHERE b AND NOT a;

+-------+------+
| A     | B    |
|-------+------|
| False | True |
+-------+------+

La requête suivante utilise l’opérateur AND et l’opérateur NOT pour renvoyer les lignes où a est TRUE et b est FALSE :

SELECT a, b FROM logical_test2 WHERE a AND NOT b;

+---+---+
| A | B |
|---+---|
+---+---+

Afficher les « tables de vérité » pour les opérateurs logiques

Les exemples suivants montrent des « tables de vérité » pour les opérateurs logiques sur une colonne booléenne. Pour plus d’informations sur le comportement des valeurs booléennes dans Snowflake, voir Logique ternaire.

Créer une nouvelle table et des données :

CREATE OR REPLACE TABLE logical_test3 (x BOOLEAN);

INSERT INTO logical_test3 (x) VALUES
  (False),
  (True),
  (NULL);

Cela montre la table de vérité pour l’opérateur OR :

SELECT x AS "OR",
       x OR False AS "FALSE",
       x OR True AS "TRUE",
       x OR NULL AS "NULL"
  FROM logical_test3;

+-------+-------+------+------+
| OR    | FALSE | TRUE | NULL |
|-------+-------+------+------|
| False | False | True | NULL |
| True  | True  | True | True |
| NULL  | NULL  | True | NULL |
+-------+-------+------+------+

Cela montre la table de vérité pour l’opérateur AND :

SELECT x AS "AND",
       x AND False AS "FALSE",
       x AND True AS "TRUE",
       x AND NULL AS "NULL"
  FROM logical_test3;

+-------+-------+-------+-------+
| AND   | FALSE | TRUE  | NULL  |
|-------+-------+-------+-------|
| False | False | False | False |
| True  | False | True  | NULL  |
| NULL  | False | NULL  | NULL  |
+-------+-------+-------+-------+