clause WHERE - ClickHouse Documentation

La clause WHERE vous permet de filtrer les données issues de la clause FROM de SELECT. S’il y a une clause WHERE, elle doit être suivie d’une expression de type UInt8. Les lignes pour lesquelles cette expression renvoie 0 sont exclues des transformations ultérieures ou du résultat. L’expression qui suit la clause WHERE est souvent utilisée avec des opérateurs de comparaison et des opérateurs logiques, ou avec l’une des nombreuses fonctions standard. L’expression WHERE est évaluée afin de déterminer s’il est possible d’utiliser des index et l’élagage des partitions, si le moteur de table sous-jacent le prend en charge.

PREWHEREIl existe également une optimisation de filtrage appelée PREWHERE. Prewhere est une optimisation qui permet d’appliquer le filtrage plus efficacement. Elle est activée par défaut, même si la clause PREWHERE n’est pas spécifiée explicitement.

Tester `NULL`

Si vous devez vérifier si une valeur est NULL, utilisez :

IS NULL ou isNull
IS NOT NULL ou isNotNull

Sinon, une expression contenant NULL ne sera jamais vraie.

Filtrer les données avec des opérateurs logiques

Vous pouvez utiliser les fonctions logiques suivantes avec la clause WHERE afin de combiner plusieurs conditions :

and() ou AND
not() ou NOT
or() ou NOT
xor()

Utiliser des colonnes UInt8 comme condition

Dans ClickHouse, les colonnes UInt8 peuvent être utilisées directement comme conditions booléennes : 0 correspond à false et toute valeur non nulle (généralement 1) à true. Un exemple est donné dans la section ci-dessous.

Utilisation des opérateurs de comparaison

Les opérateurs de comparaison suivants peuvent être utilisés :

Opérateur	Fonction	Description	Exemple
`a = b`	`equals(a, b)`	Égal à	`price = 100`
`a == b`	`equals(a, b)`	Égal à (syntaxe alternative)	`price == 100`
`a != b`	`notEquals(a, b)`	Différent de	`category != 'Electronics'`
`a <> b`	`notEquals(a, b)`	Différent de (syntaxe alternative)	`category <> 'Electronics'`
`a < b`	`less(a, b)`	Inférieur à	`price < 200`
`a <= b`	`lessOrEquals(a, b)`	Inférieur ou égal à	`price <= 200`
`a > b`	`greater(a, b)`	Supérieur à	`price > 500`
`a >= b`	`greaterOrEquals(a, b)`	Supérieur ou égal à	`price >= 500`
`a LIKE s`	`like(a, b)`	Correspondance de motif (sensible à la casse)	`name LIKE '%top%'`
`a NOT LIKE s`	`notLike(a, b)`	Absence de correspondance de motif (sensible à la casse)	`name NOT LIKE '%top%'`
`a ILIKE s`	`ilike(a, b)`	Correspondance de motif (insensible à la casse)	`name ILIKE '%LAPTOP%'`
`a BETWEEN b AND c`	`a >= b AND a <= c`	Vérification d’intervalle (bornes incluses)	`price BETWEEN 100 AND 500`
`a NOT BETWEEN b AND c`	`a < b OR a > c`	Vérification hors intervalle	`price NOT BETWEEN 100 AND 500`

Recherche par motif et expressions conditionnelles

Au-delà des opérateurs de comparaison, vous pouvez utiliser la recherche par motif et les expressions conditionnelles dans la clause WHERE.

Fonctionnalité	Syntaxe	Sensible à la casse	Performances	Idéal pour
`LIKE`	`col LIKE '%pattern%'`	Oui	Rapide	Recherche de motifs exacte, sensible à la casse
`ILIKE`	`col ILIKE '%pattern%'`	Non	Plus lent	Recherche insensible à la casse
`if()`	`if(cond, a, b)`	N/A	Rapide	Conditions binaires simples
`multiIf()`	`multiIf(c1, r1, c2, r2, def)`	N/A	Rapide	Conditions multiples
`CASE`	`CASE WHEN ... THEN ... END`	N/A	Rapide	Logique conditionnelle SQL standard

Voir « Recherche par motif et expressions conditionnelles » pour des exemples d’utilisation.

Expression avec des littéraux, des colonnes ou des sous-requêtes

L’expression qui suit la clause WHERE peut également inclure des littéraux, des colonnes ou des sous-requêtes, c’est-à-dire des instructions SELECT imbriquées qui renvoient des valeurs utilisées dans des conditions.

Type	Définition	Évaluation	Performance	Exemple
Littéral	Valeur constante fixe	À l’écriture de la requête	La plus rapide	`WHERE price > 100`
Colonne	Référence aux données de la table	Pour chaque ligne	Rapide	`WHERE price > cost`
Sous-requête	`SELECT` imbriqué	À l’exécution de la requête	Variable	`WHERE id IN (SELECT ...)`

Vous pouvez combiner des littéraux, des colonnes et des sous-requêtes dans des conditions complexes :

-- Literal + Column
WHERE price > 100 AND category = 'Electronics'

-- Column + Subquery
WHERE price > (SELECT AVG(price) FROM products) AND in_stock = true

-- Literal + Column + Subquery
WHERE category = 'Electronics' 
  AND price < 500
  AND id IN (SELECT product_id FROM bestsellers)

-- All three with logical operators
WHERE (price > 100 OR category IN (SELECT category FROM featured))
  AND in_stock = true
  AND name LIKE '%Special%'

Exemples

Tester `NULL`

Requêtes avec des valeurs NULL :

CREATE TABLE t_null(x Int8, y Nullable(Int8)) ENGINE=MergeTree() ORDER BY x;
INSERT INTO t_null VALUES (1, NULL), (2, 3);

SELECT * FROM t_null WHERE y IS NULL;
SELECT * FROM t_null WHERE y != 0;

┌─x─┬────y─┐
│ 1 │ ᴺᵁᴸᴸ │
└───┴──────┘
┌─x─┬─y─┐
│ 2 │ 3 │
└───┴───┘

Filtrer les données avec des opérateurs logiques

Considérons la table et les données suivantes :

CREATE TABLE products (
    id UInt32,
    name String,
    price Float32,
    category String,
    in_stock Bool
) ENGINE = MergeTree()
ORDER BY id;

INSERT INTO products VALUES
(1, 'Laptop', 999.99, 'Electronics', true),
(2, 'Mouse', 25.50, 'Electronics', true),
(3, 'Desk', 299.00, 'Furniture', false),
(4, 'Chair', 150.00, 'Furniture', true),
(5, 'Monitor', 350.00, 'Electronics', true),
(6, 'Lamp', 45.00, 'Furniture', false);

1. AND - les deux conditions doivent être vraies :

SELECT * FROM products
WHERE category = 'Electronics' AND price < 500;

   ┌─id─┬─name────┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse   │  25.5 │ Electronics │ true     │
2. │  5 │ Monitor │   350 │ Electronics │ true     │
   └────┴─────────┴───────┴─────────────┴──────────┘

2. OR - au moins une condition doit être vraie :

SELECT * FROM products
WHERE category = 'Furniture' OR price > 500;

   ┌─id─┬─name───┬──price─┬─category────┬─in_stock─┐
1. │  1 │ Laptop │ 999.99 │ Electronics │ true     │
2. │  3 │ Desk   │    299 │ Furniture   │ false    │
3. │  4 │ Chair  │    150 │ Furniture   │ true     │
4. │  6 │ Lamp   │     45 │ Furniture   │ false    │
   └────┴────────┴────────┴─────────────┴──────────┘

3. NOT - Négation d’une condition :

SELECT * FROM products
WHERE NOT in_stock;

   ┌─id─┬─name─┬─price─┬─category──┬─in_stock─┐
1. │  3 │ Desk │   299 │ Furniture │ false    │
2. │  6 │ Lamp │    45 │ Furniture │ false    │
   └────┴──────┴───────┴───────────┴──────────┘

4. XOR - Une et une seule condition doit être vraie (pas les deux) :

SELECT *
FROM products
WHERE xor(price > 200, category = 'Electronics')

   ┌─id─┬─name──┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse │  25.5 │ Electronics │ true     │
2. │  3 │ Desk  │   299 │ Furniture   │ false    │
   └────┴───────┴───────┴─────────────┴──────────┘

5. Combiner plusieurs opérateurs :

SELECT * FROM products
WHERE (category = 'Electronics' OR category = 'Furniture')
  AND in_stock = true
  AND price < 400;

   ┌─id─┬─name────┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse   │  25.5 │ Electronics │ true     │
2. │  4 │ Chair   │   150 │ Furniture   │ true     │
3. │  5 │ Monitor │   350 │ Electronics │ true     │
   └────┴─────────┴───────┴─────────────┴──────────┘

6. Utilisation de la syntaxe des fonctions :

SELECT * FROM products
WHERE and(or(category = 'Electronics', price > 100), in_stock);

   ┌─id─┬─name────┬──price─┬─category────┬─in_stock─┐
1. │  1 │ Laptop  │ 999.99 │ Electronics │ true     │
2. │  2 │ Mouse   │   25.5 │ Electronics │ true     │
3. │  4 │ Chair   │    150 │ Furniture   │ true     │
4. │  5 │ Monitor │    350 │ Electronics │ true     │
   └────┴─────────┴────────┴─────────────┴──────────┘

La syntaxe SQL par mots-clés (AND, OR, NOT, XOR) est généralement plus lisible, mais la syntaxe des fonctions peut être utile dans des expressions complexes ou pour construire des requêtes dynamiques.

Utiliser des colonnes UInt8 comme condition

En reprenant la table de l’exemple précédent, vous pouvez utiliser directement un nom de colonne comme condition :

SELECT * FROM products
WHERE in_stock

   ┌─id─┬─name────┬──price─┬─category────┬─in_stock─┐
1. │  1 │ Laptop  │ 999.99 │ Electronics │ true     │
2. │  2 │ Mouse   │   25.5 │ Electronics │ true     │
3. │  4 │ Chair   │    150 │ Furniture   │ true     │
4. │  5 │ Monitor │    350 │ Electronics │ true     │
   └────┴─────────┴────────┴─────────────┴──────────┘

Utilisation des opérateurs de comparaison

Les exemples ci-dessous utilisent la table et les données de l’exemple ci-dessus. Les résultats sont omis pour des raisons de concision. 1. Égalité explicite avec true (= 1 or = true) :

SELECT * FROM products
WHERE in_stock = true;
-- or
WHERE in_stock = 1;

2. Égalité explicite avec false (= 0 ou = false) :

SELECT * FROM products
WHERE in_stock = false;
-- or
WHERE in_stock = 0;

3. Inégalité (!= 0 ou != false) :

SELECT * FROM products
WHERE in_stock != false;
-- or
WHERE in_stock != 0;

4. Plus grand que :

SELECT * FROM products
WHERE in_stock > 0;

5. Inférieur ou égal à :

SELECT * FROM products
WHERE in_stock <= 0;

6. Combinaison avec d’autres conditions :

SELECT * FROM products
WHERE in_stock AND price < 400;

7. Utilisation de l’opérateur IN : Dans l’exemple ci-dessous, (1, true) est un Tuple.

SELECT * FROM products
WHERE in_stock IN (1, true);

Vous pouvez également utiliser un array pour cela :

SELECT * FROM products
WHERE in_stock IN [1, true];

8. Mélange de styles de comparaison :

SELECT * FROM products
WHERE category = 'Electronics' AND in_stock = true;

Recherche par motif et expressions conditionnelles

Les exemples ci-dessous utilisent la table et les données de l’exemple ci-dessus. Les résultats sont omis par souci de brièveté.

Exemples avec LIKE

-- Find products with 'o' in the name
SELECT * FROM products WHERE name LIKE '%o%';
-- Result: Laptop, Monitor

-- Find products starting with 'L'
SELECT * FROM products WHERE name LIKE 'L%';
-- Result: Laptop, Lamp

-- Find products with exactly 4 characters
SELECT * FROM products WHERE name LIKE '____';
-- Result: Desk, Lamp

Exemples d’ILIKE

-- Case-insensitive search for 'LAPTOP'
SELECT * FROM products WHERE name ILIKE '%laptop%';
-- Result: Laptop

-- Case-insensitive prefix match
SELECT * FROM products WHERE name ILIKE 'l%';
-- Result: Laptop, Lamp

Exemples de la fonction IF

-- Different price thresholds by category
SELECT * FROM products
WHERE if(category = 'Electronics', price < 500, price < 200);
-- Result: Mouse, Chair, Monitor
-- (Electronics under $500 OR Furniture under $200)

-- Filter based on stock status
SELECT * FROM products
WHERE if(in_stock, price > 100, true);
-- Result: Laptop, Chair, Monitor, Desk, Lamp
-- (In stock items over $100 OR all out-of-stock items)

Exemples de multiIf

-- Multiple category-based conditions
SELECT * FROM products
WHERE multiIf(
    category = 'Electronics', price < 600,
    category = 'Furniture', in_stock = true,
    false
);
-- Result: Mouse, Monitor, Chair
-- (Electronics < $600 OR in-stock Furniture)

-- Tiered filtering
SELECT * FROM products
WHERE multiIf(
    price > 500, category = 'Electronics',
    price > 100, in_stock = true,
    true
);
-- Result: Laptop, Chair, Monitor, Lamp

Exemples avec CASE

CASE simple :

-- Different rules per category
SELECT * FROM products
WHERE CASE category
    WHEN 'Electronics' THEN price < 400
    WHEN 'Furniture' THEN in_stock = true
    ELSE false
END;
-- Result: Mouse, Monitor, Chair

CASE avec conditions :

-- Price-based tiered logic
SELECT * FROM products
WHERE CASE
    WHEN price > 500 THEN in_stock = true
    WHEN price > 100 THEN category = 'Electronics'
    ELSE true
END;
-- Result: Laptop, Monitor, Mouse, Lamp

​Tester NULL

​Filtrer les données avec des opérateurs logiques

​Utiliser des colonnes UInt8 comme condition

​Utilisation des opérateurs de comparaison

​Recherche par motif et expressions conditionnelles

​Expression avec des littéraux, des colonnes ou des sous-requêtes

​Exemples

​Tester NULL

​Filtrer les données avec des opérateurs logiques

​Utiliser des colonnes UInt8 comme condition

​Utilisation des opérateurs de comparaison

​Recherche par motif et expressions conditionnelles

​Exemples avec LIKE

​Exemples d’ILIKE

​Exemples de la fonction IF

​Exemples de multiIf

​Exemples avec CASE

Tester `NULL`

Filtrer les données avec des opérateurs logiques

Utiliser des colonnes UInt8 comme condition

Utilisation des opérateurs de comparaison

Recherche par motif et expressions conditionnelles

Expression avec des littéraux, des colonnes ou des sous-requêtes

Exemples

Tester `NULL`

Filtrer les données avec des opérateurs logiques

Utiliser des colonnes UInt8 comme condition

Utilisation des opérateurs de comparaison

Recherche par motif et expressions conditionnelles

Exemples avec LIKE

Exemples d’ILIKE

Exemples de la fonction IF

Exemples de multiIf

Exemples avec CASE