> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentation de la clause `WHERE` dans ClickHouse

# clause WHERE

La clause `WHERE` vous permet de filtrer les données issues de la clause [`FROM`](/fr/reference/statements/select/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](/fr/reference/operators/index#comparison-operators) et des [opérateurs logiques](/fr/reference/operators/index#operators-for-working-with-data-sets), ou avec l'une des nombreuses [fonctions standard](/fr/reference/functions/regular-functions/regular-functions-index).

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.

<Info>
  **PREWHERE**

  Il existe également une optimisation de filtrage appelée [`PREWHERE`](/fr/reference/statements/select/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.
</Info>

<div id="testing-for-null">
  ## Tester `NULL`
</div>

Si vous devez vérifier si une valeur est [`NULL`](/fr/reference/syntax#null), utilisez :

* [`IS NULL`](/fr/reference/operators/index#is_null) ou [`isNull`](/fr/reference/functions/regular-functions/functions-for-nulls#isNull)
* [`IS NOT NULL`](/fr/reference/operators/index#is_not_null)   ou [`isNotNull`](/fr/reference/functions/regular-functions/functions-for-nulls#isNotNull)

Sinon, une expression contenant `NULL` ne sera jamais vraie.

<div id="filtering-data-with-logical-operators">
  ## Filtrer les données avec des opérateurs logiques
</div>

Vous pouvez utiliser les [fonctions logiques](/fr/reference/functions/regular-functions/logical-functions#and) suivantes avec la clause `WHERE` afin de combiner plusieurs conditions :

* [`and()`](/fr/reference/functions/regular-functions/logical-functions#and) ou `AND`
* [`not()`](/fr/reference/functions/regular-functions/logical-functions#not) ou `NOT`
* [`or()`](/fr/reference/functions/regular-functions/logical-functions#or) ou `NOT`
* [`xor()`](/fr/reference/functions/regular-functions/logical-functions#xor)

<div id="using-uint8-columns-as-a-condition">
  ## Utiliser des colonnes UInt8 comme condition
</div>

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](#example-uint8-column-as-condition).

<div id="using-comparison-operators">
  ## Utilisation des opérateurs de comparaison
</div>

Les [opérateurs de comparaison](/fr/reference/operators/index#comparison-operators) 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` |

<div id="pattern-matching-and-conditional-expressions">
  ## Recherche par motif et expressions conditionnelles
</div>

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 »](#examples-pattern-matching-and-conditional-expressions) pour des exemples d’utilisation.

<div id="expressions-with-literals-columns-subqueries">
  ## Expression avec des littéraux, des colonnes ou des sous-requêtes
</div>

L’expression qui suit la clause `WHERE` peut également inclure des [littéraux](/fr/reference/syntax#literals), 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 :

```sql theme={null}
-- 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%'
```

<div id="examples">
  ## Exemples
</div>

<div id="examples-testing-for-null">
  ### Tester `NULL`
</div>

Requêtes avec des valeurs `NULL` :

```sql theme={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;
```

```response theme={null}
┌─x─┬────y─┐
│ 1 │ ᴺᵁᴸᴸ │
└───┴──────┘
┌─x─┬─y─┐
│ 2 │ 3 │
└───┴───┘
```

<div id="example-filtering-with-logical-operators">
  ### Filtrer les données avec des opérateurs logiques
</div>

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

```sql theme={null}
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 :**

```sql theme={null}
SELECT * FROM products
WHERE category = 'Electronics' AND price < 500;
```

```response theme={null}
   ┌─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 :**

```sql theme={null}
SELECT * FROM products
WHERE category = 'Furniture' OR price > 500;
```

```response theme={null}
   ┌─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 :**

```sql theme={null}
SELECT * FROM products
WHERE NOT in_stock;
```

```response theme={null}
   ┌─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) :**

```sql theme={null}
SELECT *
FROM products
WHERE xor(price > 200, category = 'Electronics')
```

```response theme={null}
   ┌─id─┬─name──┬─price─┬─category────┬─in_stock─┐
1. │  2 │ Mouse │  25.5 │ Electronics │ true     │
2. │  3 │ Desk  │   299 │ Furniture   │ false    │
   └────┴───────┴───────┴─────────────┴──────────┘
```

**5. Combiner plusieurs opérateurs :**

```sql theme={null}
SELECT * FROM products
WHERE (category = 'Electronics' OR category = 'Furniture')
  AND in_stock = true
  AND price < 400;
```

```response theme={null}
   ┌─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 :**

```sql theme={null}
SELECT * FROM products
WHERE and(or(category = 'Electronics', price > 100), in_stock);
```

```response theme={null}
   ┌─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.

<div id="example-uint8-column-as-condition">
  ### Utiliser des colonnes UInt8 comme condition
</div>

En reprenant la table de l’[exemple précédent](#example-filtering-with-logical-operators), vous pouvez utiliser directement un nom de colonne comme condition :

```sql theme={null}
SELECT * FROM products
WHERE in_stock
```

```response theme={null}
   ┌─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     │
   └────┴─────────┴────────┴─────────────┴──────────┘
```

<div id="example-using-comparison-operators">
  ### Utilisation des opérateurs de comparaison
</div>

Les exemples ci-dessous utilisent la table et les données de l’[exemple](#example-filtering-with-logical-operators) ci-dessus. Les résultats sont omis pour des raisons de concision.

**1. Égalité explicite avec true (`= 1` or `= true`) :**

```sql theme={null}
SELECT * FROM products
WHERE in_stock = true;
-- or
WHERE in_stock = 1;
```

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

```sql theme={null}
SELECT * FROM products
WHERE in_stock = false;
-- or
WHERE in_stock = 0;
```

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

```sql theme={null}
SELECT * FROM products
WHERE in_stock != false;
-- or
WHERE in_stock != 0;
```

**4. Plus grand que :**

```sql theme={null}
SELECT * FROM products
WHERE in_stock > 0;
```

**5. Inférieur ou égal à :**

```sql theme={null}
SELECT * FROM products
WHERE in_stock <= 0;
```

**6. Combinaison avec d’autres conditions :**

```sql theme={null}
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](/fr/reference/data-types/tuple).

```sql theme={null}
SELECT * FROM products
WHERE in_stock IN (1, true);
```

Vous pouvez également utiliser un [array](/fr/reference/data-types/array) pour cela :

```sql theme={null}
SELECT * FROM products
WHERE in_stock IN [1, true];
```

**8. Mélange de styles de comparaison :**

```sql theme={null}
SELECT * FROM products
WHERE category = 'Electronics' AND in_stock = true;
```

<div id="examples-pattern-matching-and-conditional-expressions">
  ### Recherche par motif et expressions conditionnelles
</div>

Les exemples ci-dessous utilisent la table et les données de l’[exemple](#example-filtering-with-logical-operators) ci-dessus. Les résultats sont omis par souci de brièveté.

<div id="like-examples">
  #### Exemples avec LIKE
</div>

```sql theme={null}
-- 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
```

<div id="ilike-examples">
  #### Exemples d’ILIKE
</div>

```sql theme={null}
-- 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
```

<div id="if-examples">
  #### Exemples de la fonction IF
</div>

```sql theme={null}
-- 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)
```

<div id="multiif-examples">
  #### Exemples de multiIf
</div>

```sql theme={null}
-- 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
```

<div id="case-examples">
  #### Exemples avec CASE
</div>

**CASE simple :**

```sql theme={null}
-- 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 :**

```sql theme={null}
-- 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
```