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.
Liste des opérateurs logiques¶
Opérateur |
Exemple de syntaxe |
Description |
---|---|---|
|
|
Correspond aux deux expressions ( |
|
|
Ne correspond pas à l’expression. |
|
|
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
Utiliser des opérateurs logiques dans les requêtes sur les valeurs booléennes
Afficher les « tables de vérité » pour les 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
ANDb
é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
ORa
é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 |
+-------+-------+-------+-------+