Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

WHERE

View as MarkdownEdit this pageReport an issueSet up docs MCP

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.

Tester NULL

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

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 :

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
Navigation