> ## 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 sur les opérateurs # Opérateurs ClickHouse transforme les opérateurs en fonctions correspondantes lors de l’analyse syntaxique des requêtes, en fonction de leur priorité, de leur précédence et de leur associativité.
## Opérateurs d’accès
`a[N]` – Accès à un élément d’un tableau. Fonction `arrayElement(a, N)`. `a.N` – Accès à un élément d’un tuple. Fonction `tupleElement(a, N)`.
## Opérateur de négation numérique
`-a` – La fonction `negate (a)`. Pour la négation d’un Tuple : [tupleNegate](/fr/reference/functions/regular-functions/tuple-functions#tupleNegate).
## Opérateurs de multiplication et de division
`a * b` – La fonction `multiply (a, b)`. Pour multiplier un Tuple par un nombre : [tupleMultiplyByNumber](/fr/reference/functions/regular-functions/tuple-functions#tupleMultiplyByNumber) ; pour le produit scalaire : [dotProduct](/fr/reference/functions/regular-functions/array-functions#arrayDotProduct). `a / b` – La fonction `divide(a, b)`. Pour diviser un Tuple par un nombre : [tupleDivideByNumber](/fr/reference/functions/regular-functions/tuple-functions#tupleDivideByNumber). `a % b` – La fonction `modulo(a, b)`.
## Opérateurs d’addition et de soustraction
`a + b` – La fonction `plus(a, b)`. Pour l’addition de tuples : [tuplePlus](/fr/reference/functions/regular-functions/tuple-functions#tuplePlus). `a - b` – La fonction `minus(a, b)`. Pour la soustraction de tuples : [tupleMinus](/fr/reference/functions/regular-functions/tuple-functions#tupleMinus).
## Opérateurs de comparaison
### fonction equals
`a = b` – La fonction `equals(a, b)`. `a == b` – La fonction `equals(a, b)`.
### fonction notEquals
`a != b` – la fonction `notEquals(a, b)`. `a <> b` – la fonction `notEquals(a, b)`.
### fonction lessOrEquals
`a <= b` – La fonction `lessOrEquals(a, b)`.
### fonction greaterOrEquals
`a >= b` – La fonction `greaterOrEquals(a, b)`.
### fonction less
`a < b` – La fonction `less(a, b)`.
### fonction greater
`a > b` – La fonction `greater(a, b)`.
### fonction like
`a LIKE b` – La fonction `like(a, b)`.
### fonction notLike
`a NOT LIKE b` – La fonction `notLike(a, b)`.
### fonction ilike
`a ILIKE b` – La fonction `ilike(a, b)`.
### Fonction BETWEEN
`a BETWEEN b AND c` – Identique à `a >= b AND a <= c`. `a NOT BETWEEN b AND c` – Identique à `a < b OR a > c`.
### opérateur `IS NOT DISTINCT FROM` (`<=>`)
À partir de la version 25.10, vous pouvez utiliser `<=>` comme n’importe quel autre opérateur. Avant la version 25.10, il ne pouvait être utilisé que dans des expressions JOIN, par exemple : ```sql theme={null} CREATE TABLE a (x String) ENGINE = Memory; INSERT INTO a VALUES ('ClickHouse'); SELECT * FROM a AS a1 JOIN a AS a2 ON a1.x <=> a2.x; ┌─x──────────┬─a2.x───────┐ │ ClickHouse │ ClickHouse │ └────────────┴────────────┘ ``` L’opérateur `<=>` est l’opérateur d’égalité compatible avec `NULL`, équivalent à `IS NOT DISTINCT FROM`. Il fonctionne comme l’opérateur d’égalité classique (`=`), mais considère les valeurs `NULL` comme comparables. Deux valeurs `NULL` sont considérées comme égales, et une valeur `NULL` comparée à n’importe quelle valeur non `NULL` renvoie 0 (`false`) plutôt que `NULL`. ```sql theme={null} SELECT 'ClickHouse' <=> NULL, NULL <=> NULL ``` ```response theme={null} ┌─isNotDistinc⋯use', NULL)─┬─isNotDistinc⋯NULL, NULL)─┐ │ 0 │ 1 │ └──────────────────────────┴──────────────────────────┘ ```
## Opérateurs pour travailler avec les chaînes de caractères
### OVERLAY
* `OVERLAY(string PLACING replacement FROM offset)` - La fonction `overlay(string, replacement, offset)`. * `OVERLAY(string PLACING replacement FROM offset FOR length)` - La fonction `overlay(string, replacement, offset, length)`. * `OVERLAYUTF8(string PLACING replacement FROM offset)` - La fonction `overlayUTF8(string, replacement, offset)`. * `OVERLAYUTF8(string PLACING replacement FROM offset FOR length)` - La fonction `overlayUTF8(string, replacement, offset, length)`.
## Opérateurs pour manipuler des ensembles de données
Voir les [opérateurs IN](/fr/reference/statements/in) et l’opérateur [EXISTS](/fr/reference/operators/exists).
### fonction IN
`a IN ...` – La fonction `in(a, b)`.
### fonction notIn
`a NOT IN ...` – La fonction `notIn(a, b)`.
### fonction globalIn
`a GLOBAL IN ...` – La fonction `globalIn(a, b)`.
### fonction globalNotIn
`a GLOBAL NOT IN ...` – La fonction `globalNotIn(a, b)`.
### fonction in avec sous-requête
`a = ANY (subquery)` – La fonction `in(a, subquery)`.
### notIn sous-requête function
`a != ANY (subquery)` – Équivaut à `a NOT IN (SELECT singleValueOrNull(*) FROM subquery)`.
### Fonction in sous-requête
`a = ALL (subquery)` – Identique à `a IN (SELECT singleValueOrNull(*) FROM subquery)`.
### fonction de sous-requête notIn
`a != ALL (subquery)` – La fonction `notIn(a, subquery)`. **Exemples** Requête avec ALL : ```sql title="Query" theme={null} SELECT number AS a FROM numbers(10) WHERE a > ALL (SELECT number FROM numbers(3, 3)); ``` ```text title="Response" theme={null} ┌─a─┐ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └───┘ ``` Requête avec ANY : ```sql title="Query" theme={null} SELECT number AS a FROM numbers(10) WHERE a > ANY (SELECT number FROM numbers(3, 3)); ``` ```text title="Response" theme={null} ┌─a─┐ │ 4 │ │ 5 │ │ 6 │ │ 7 │ │ 8 │ │ 9 │ └───┘ ```
### `SOME` / `ALL` sur les tableaux
En plus de la forme avec sous-requête décrite ci-dessus, le côté droit de `SOME` / `ALL` peut être une expression de tableau (un littéral de tableau, une colonne de type tableau ou toute expression renvoyant un tableau). Il s'agit de la syntaxe de quantificateur de tableau de style PostgreSQL. Elle est reconnue lors de l'analyse syntaxique et réécrite en fonctions de tableau, donc aucune réécriture manuelle n'est nécessaire : | Syntaxe | Réécrit en | | --------------------------------------------------------- | ---------------------------------- | | `expr = SOME(arr)` | `has(arr, expr)` | | `expr <> ALL(arr)` | `NOT has(arr, expr)` | | `expr OP SOME(arr)` (tout autre opérateur de comparaison) | `arrayExists(x -> expr OP x, arr)` | | `expr OP ALL(arr)` (tout autre opérateur de comparaison) | `arrayAll(x -> expr OP x, arr)` | `SOME` est le quantificateur existentiel (le synonyme SQL de `ANY`). `=` et `<>` sont traités à part et réécrits en `has` / `NOT has`, car ils disposent d'une implémentation optimisée ; la forme générale s'appuie sur les fonctions d'ordre supérieur `arrayExists` / `arrayAll`. La forme tableau n'est reconnue que pour les opérateurs de comparaison `=`, `==`, `!=`, `<>`, `<=>`, `<`, `<=`, `>`, et `>=`. Les autres opérateurs qui acceptent un tableau à droite — par exemple `LIKE`, `ILIKE`, `NOT LIKE`, `REGEXP` et `IN` — ne sont **pas** réécrits en quantificateur de tableau et conservent leur sens habituel. Par exemple, `'abc' LIKE SOME(['a%', 'b%'])` n'est pas une syntaxe de quantificateur de tableau ; utilisez directement `arrayExists` / `arrayAll` dans ces cas. **`ANY` n'est pas pris en charge pour la forme tableau** Seuls `SOME` et `ALL` acceptent un tableau à droite. `ANY` est exclu, car `any` est aussi une fonction d'agrégation ; une expression de la forme `expr = any(x)` conserve donc son sens d'appel de fonction. Utilisez `SOME` pour le quantificateur de tableau. ```sql title="Query" theme={null} SELECT 3 = SOME([1, 2, 3, 4]) AS in_array, 5 < SOME([1, 2, 6]) AS less_than_some, 5 > ALL([1, 2, 3]) AS greater_than_all; ``` ```text title="Response" theme={null} ┌─in_array─┬─less_than_some─┬─greater_than_all─┐ │ 1 │ 1 │ 1 │ └──────────┴────────────────┴──────────────────┘ ``` **La gestion de `NULL` diffère de celle de la forme avec sous-requête** Comme la forme avec tableau est réécrite par le parseur (où les paramètres de requête tels que `transform_null_in` ne sont pas disponibles, et où une colonne de tableau propre à chaque ligne ne peut pas utiliser le chemin `IN` de l'analyseur avec gestion sûre de `NULL`), elle s'appuie sur la sémantique bivalente de `has` (pour `=` / `<>`) et de `arrayExists` / `arrayAll` (qui convertissent en `0` un résultat de comparaison `NULL` inconnu). Cela peut différer de la forme avec sous-requête, dont la gestion de `NULL` est ramenée à `IN` / `NOT IN` et dépend de `transform_null_in` : ```sql theme={null} SELECT NULL = SOME([NULL]); -- has([NULL], NULL) -> 1 SELECT NULL <> ALL([NULL]); -- NOT has([NULL], NULL) -> 0 SELECT NULL < SOME([1]); -- arrayExists(x -> NULL < x, [1]) -> 0 SELECT NULL > ALL([1]); -- arrayAll(x -> NULL > x, [1]) -> 0 ```
## Opérateurs pour manipuler les dates et heures
### EXTRACT
```sql theme={null} EXTRACT(part FROM date); ``` Extrait des composantes d’une date donnée. Par exemple, vous pouvez récupérer le mois d’une date donnée, ou les secondes d’une heure. Le paramètre `part` spécifie quelle composante de la date récupérer. Les valeurs suivantes sont disponibles : * `NANOSECOND` — La nanoseconde. Valeurs possibles : 0–999999999. * `MICROSECOND` — La microseconde. Valeurs possibles : 0–999999. * `MILLISECOND` — La milliseconde. Valeurs possibles : 0–999. * `SECOND` — La seconde. Valeurs possibles : 0–59. * `MINUTE` — La minute. Valeurs possibles : 0–59. * `HOUR` — L’heure. Valeurs possibles : 0–23. * `DAY` — Le jour du mois. Valeurs possibles : 1–31. * `WEEK` — Le numéro de semaine ISO 8601. Valeurs possibles : 1–53. * `MONTH` — Le numéro du mois. Valeurs possibles : 1–12. * `QUARTER` — Le trimestre. Valeurs possibles : 1–4. * `YEAR` — L’année. * `EPOCH` — Le timestamp Unix (secondes écoulées depuis 1970-01-01 00:00:00 UTC). Remarque : pour `DateTime64`, la partie sous-seconde est tronquée. * `DOW` — Le jour de la semaine (compatible PostgreSQL). 0 = dimanche, 6 = samedi. * `DOY` — Le jour de l’année. Valeurs possibles : 1–366. * `ISODOW` — Le jour ISO de la semaine. 1 = lundi, 7 = dimanche. * `ISOYEAR` — L’année de numérotation des semaines ISO 8601. * `CENTURY` — Le siècle. Par exemple, l’année 2024 appartient au XXIe siècle. * `DECADE` — La décennie (année divisée par 10). Par exemple, l’année 2024 a pour décennie 202. * `MILLENNIUM` — Le millénaire. Par exemple, l’année 2024 appartient au IIIe millénaire. * `TIMEZONE_HOUR` — La partie heure signée du décalage UTC du fuseau horaire de l’opérande. Par exemple, `+5:30` renvoie `5`, `-3:30` renvoie `-3`. * `TIMEZONE_MINUTE` — La partie minute signée du décalage UTC du fuseau horaire de l’opérande. Par exemple, `+5:30` renvoie `30`, `-3:30` renvoie `-30`. Le paramètre `part` n’est pas sensible à la casse. Le paramètre `date` spécifie la valeur à traiter. Les types [Date](/fr/reference/data-types/date), [Date32](/fr/reference/data-types/date32), [DateTime](/fr/reference/data-types/datetime), [DateTime64](/fr/reference/data-types/datetime64) et [Interval](/fr/reference/data-types/special-data-types/interval) sont pris en charge. Lorsque `date` est un `Interval`, la `part` demandée doit correspondre à l’unité stockée par l’intervalle (par exemple, `EXTRACT(DAY FROM INTERVAL 5 DAY)` est autorisé ; `EXTRACT(HOUR FROM INTERVAL 5 DAY)` est rejeté, car les intervalles ClickHouse ne stockent qu’un seul type d’unité). Le résultat pour un opérande `Interval` est `Int64`. Exemples : ```sql theme={null} SELECT EXTRACT(DAY FROM toDate('2017-06-15')); SELECT EXTRACT(MONTH FROM toDate('2017-06-15')); SELECT EXTRACT(YEAR FROM toDate('2017-06-15')); SELECT EXTRACT(EPOCH FROM toDateTime('2024-01-15 12:30:45', 'UTC')); SELECT EXTRACT(DOW FROM toDate('2024-01-15')); SELECT EXTRACT(CENTURY FROM toDate('2024-01-01')); SELECT EXTRACT(TIMEZONE_HOUR FROM toDateTime('2024-01-15 12:00:00', 'Asia/Kolkata')); -- 5 SELECT EXTRACT(TIMEZONE_MINUTE FROM toDateTime('2024-01-15 12:00:00', 'Asia/Kolkata')); -- 30 SELECT EXTRACT(DAY FROM INTERVAL 40 DAY); -- 40 SELECT EXTRACT(MONTH FROM INTERVAL 7 MONTH); -- 7 ``` Dans l’exemple suivant, nous créons une table et y insérons une valeur de type `DateTime`. ```sql theme={null} CREATE TABLE test.Orders ( OrderId UInt64, OrderName String, OrderDate DateTime ) ENGINE = MergeTree ORDER BY (); ``` ```sql theme={null} INSERT INTO test.Orders VALUES (1, 'Jarlsberg Cheese', toDateTime('2008-10-11 13:23:44')); ``` ```sql theme={null} SELECT toYear(OrderDate) AS OrderYear, toMonth(OrderDate) AS OrderMonth, toDayOfMonth(OrderDate) AS OrderDay, toHour(OrderDate) AS OrderHour, toMinute(OrderDate) AS OrderMinute, toSecond(OrderDate) AS OrderSecond FROM test.Orders; ``` ```text theme={null} ┌─OrderYear─┬─OrderMonth─┬─OrderDay─┬─OrderHour─┬─OrderMinute─┬─OrderSecond─┐ │ 2008 │ 10 │ 11 │ 13 │ 23 │ 44 │ └───────────┴────────────┴──────────┴───────────┴─────────────┴─────────────┘ ``` Vous trouverez d’autres exemples dans [les tests](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00619_extract.sql).
### INTERVAL
Crée une valeur de type [Interval](/fr/reference/data-types/special-data-types/interval), à utiliser dans des opérations arithmétiques avec des valeurs de type [Date](/fr/reference/data-types/date) et [DateTime](/fr/reference/data-types/datetime). Types d’intervalles : * `SECOND` * `MINUTE` * `HOUR` * `DAY` * `WEEK` * `MONTH` * `QUARTER` * `YEAR` Vous pouvez également utiliser une chaîne littérale pour définir la valeur `INTERVAL`. Par exemple, `INTERVAL 1 HOUR` est identique à `INTERVAL '1 hour'` ou `INTERVAL '1' hour`. Il n’est pas possible de combiner des intervalles de types différents. Vous ne pouvez pas utiliser d’expressions telles que `INTERVAL 4 DAY 1 HOUR`. Spécifiez les intervalles dans des unités inférieures ou égales à la plus petite unité de l’intervalle, par exemple `INTERVAL 25 HOUR`. Vous pouvez utiliser des opérations successives, comme dans l’exemple ci-dessous. Exemples : ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ │ 2020-11-03 22:09:50 │ 2020-11-08 01:09:50 │ └─────────────────────┴────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL '4 day' + INTERVAL '3 hour'; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ │ 2020-11-03 22:12:10 │ 2020-11-08 01:12:10 │ └─────────────────────┴────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT now() AS current_date_time, current_date_time + INTERVAL '4' day + INTERVAL '3' hour; ``` ```text theme={null} ┌───current_date_time─┬─plus(plus(now(), toIntervalDay('4')), toIntervalHour('3'))─┐ │ 2020-11-03 22:33:19 │ 2020-11-08 01:33:19 │ └─────────────────────┴────────────────────────────────────────────────────────────┘ ``` La syntaxe `INTERVAL` ou la fonction `addDays` sont toujours à privilégier. Une simple addition ou soustraction (syntaxe du type `now() + ...`) ne tient pas compte des paramètres de temps. Par exemple, de l’heure d’été. Exemples : ```sql theme={null} SELECT toDateTime('2014-10-26 00:00:00', 'Asia/Istanbul') AS time, time + 60 * 60 * 24 AS time_plus_24_hours, time + toIntervalDay(1) AS time_plus_1_day; ``` ```text theme={null} ┌────────────────time─┬──time_plus_24_hours─┬─────time_plus_1_day─┐ │ 2014-10-26 00:00:00 │ 2014-10-26 23:00:00 │ 2014-10-27 00:00:00 │ └─────────────────────┴─────────────────────┴─────────────────────┘ ``` **Voir aussi** * [Interval](/fr/reference/data-types/special-data-types/interval) type de données * [toInterval](/fr/reference/functions/regular-functions/type-conversion-functions#toIntervalYear) fonctions de conversion de type
### Addition de date et d’heure
Une valeur [Date](/fr/reference/data-types/date) ou [Date32](/fr/reference/data-types/date32) peut être ajoutée à une valeur [Time](/fr/reference/data-types/time) ou [Time64](/fr/reference/data-types/time64) à l’aide de l’opérateur `+`. Le résultat est un [DateTime](/fr/reference/data-types/datetime) ou un [DateTime64](/fr/reference/data-types/datetime64) représentant cette date à l’heure indiquée. L’opération est commutative. Le type de résultat dépend des types des opérandes : | Opérande de gauche | Opérande de droite | Type de résultat | | ------------------ | ------------------ | ---------------- | | `Date` | `Time` | `DateTime` | | `Date` | `Time64(s)` | `DateTime64(s)` | | `Date32` | `Time` | `DateTime64(0)` | | `Date32` | `Time64(s)` | `DateTime64(s)` | Le résultat utilise le [fuseau horaire de session](/fr/reference/settings/session-settings#session_timezone) (ou le fuseau horaire par défaut du serveur si aucun fuseau horaire de session n’est défini). Le paramètre [`date_time_overflow_behavior`](/fr/reference/settings/formats#date_time_overflow_behavior) contrôle ce qui se passe lorsque le résultat sort de la plage représentable. Exemples : ```sql theme={null} SET use_legacy_to_time = 0; SELECT toDate('2024-07-15') + toTime('14:30:25') AS dt, toTypeName(dt); ``` ```text theme={null} ┌──────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 14:30:25 │ DateTime │ └─────────────────────┴────────────────┘ ``` ```sql theme={null} SELECT toDate('2024-07-15') + toTime64('14:30:25.123456', 6) AS dt, toTypeName(dt); ``` ```text theme={null} ┌─────────────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 14:30:25.123456 │ DateTime64(6) │ └────────────────────────────┴────────────────┘ ``` ```sql theme={null} SELECT toTime64('23:59:59.999', 3) + toDate32('2024-07-15') AS dt, toTypeName(dt); ``` ```text theme={null} ┌──────────────────────dt─┬─toTypeName(dt)─┐ │ 2024-07-15 23:59:59.999 │ DateTime64(3) │ └─────────────────────────┴────────────────┘ ```
## Opérateur logique AND
Syntaxe `SELECT a AND b` — effectue la conjonction logique de `a` et `b` à l’aide de la fonction [and](/fr/reference/functions/regular-functions/logical-functions#and).
## Opérateur logique OR
Syntaxe `SELECT a OR b` — calcule la disjonction logique de `a` et `b` à l’aide de la fonction [or](/fr/reference/functions/regular-functions/logical-functions#or).
## Opérateur de négation logique
Syntaxe `SELECT NOT a` — renvoie la négation logique de `a` à l’aide de la fonction [not](/fr/reference/functions/regular-functions/logical-functions#not).
## Opérateur conditionnel
`a ? b : c` – La fonction `if(a, b, c)`. Remarque : L’opérateur conditionnel évalue les valeurs de b et de c, vérifie ensuite si la condition a est vraie, puis renvoie la valeur correspondante. Si `b` ou `C` est une fonction [arrayJoin()](/fr/reference/functions/regular-functions/array-join), chaque ligne sera dupliquée quelle que soit la condition « a ».
## Expression conditionnelle
```sql theme={null} CASE [x] WHEN a THEN b [WHEN ... THEN ...] [ELSE c] END ``` Si `x` est spécifié, la fonction `transform(x, [a, ...], [b, ...], c)` est utilisée. Sinon, `multiIf(a, b, ..., c)`. S'il n'y a pas de clause `ELSE c` dans l'expression, la valeur par défaut est `NULL`. La fonction `transform` ne fonctionne pas avec `NULL`.
## Opérateur de concaténation
`s1 || s2` – La fonction `concat(s1, s2)`.
## Opérateur de création de lambda
`x -> expr` – La fonction `lambda(x, expr)`. Les opérateurs suivants n’ont pas de priorité, car il s’agit de parenthèses :
## Opérateur de création de tableau
`[x1, ...]` – La fonction `array(x1, ...)`.
## Opérateur de création de Tuple
`(x1, x2, ...)` – La fonction `tuple(x2, x2, ...)`.
## Associativité
Tous les opérateurs binaires sont associatifs à gauche. Par exemple, `1 + 2 + 3` est transformé en `plus(plus(1, 2), 3)`. Il arrive parfois que cela ne fonctionne pas comme prévu. Par exemple, `SELECT 4 > 2 > 3` renverra 0. Pour des raisons d’efficacité, les fonctions `and` et `or` acceptent un nombre quelconque d’arguments. Les suites correspondantes d’opérateurs `AND` et `OR` sont transformées en un unique appel à ces fonctions.
## Vérifier `NULL`
ClickHouse prend en charge les opérateurs `IS NULL` et `IS NOT NULL`.
### IS NULL
* Pour les valeurs de type [Nullable](/fr/reference/data-types/nullable), l’opérateur `IS NULL` renvoie : * `1` si la valeur est `NULL`. * `0` sinon. * Pour les autres valeurs, l’opérateur `IS NULL` renvoie toujours `0`. Cela peut être optimisé en activant le paramètre [optimize\_functions\_to\_subcolumns](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns). Avec `optimize_functions_to_subcolumns = 1`, la fonction lit uniquement la sous-colonne [null](/fr/reference/data-types/nullable#finding-null), au lieu de lire et de traiter l’ensemble des données de la colonne. La requête `SELECT n IS NULL FROM table` est transformée en `SELECT n.null FROM TABLE`. ```sql theme={null} SELECT x+100 FROM t_null WHERE y IS NULL ``` ```text theme={null} ┌─plus(x, 100)─┐ │ 101 │ └──────────────┘ ```
### IS NOT NULL
* Pour les valeurs du type [Nullable](/fr/reference/data-types/nullable), l’opérateur `IS NOT NULL` renvoie : * `0` si la valeur est `NULL`. * `1` dans le cas contraire. * Pour toutes les autres valeurs, l’opérateur `IS NOT NULL` renvoie toujours `1`. ```sql theme={null} SELECT * FROM t_null WHERE y IS NOT NULL ``` ```text theme={null} ┌─x─┬─y─┐ │ 2 │ 3 │ └───┴───┘ ``` Peut être optimisé en activant le paramètre [optimize\_functions\_to\_subcolumns](/fr/reference/settings/session-settings#optimize_functions_to_subcolumns). Avec `optimize_functions_to_subcolumns = 1`, la fonction lit uniquement la sous-colonne [null](/fr/reference/data-types/nullable#finding-null), au lieu de lire et de traiter l’ensemble des données de la colonne. La requête `SELECT n IS NOT NULL FROM table` se transforme en `SELECT NOT n.null FROM TABLE`.
## Vérification des valeurs booléennes
ClickHouse prend en charge les opérateurs `IS TRUE`, `IS FALSE`, `IS UNKNOWN`, `IS NOT TRUE`, `IS NOT FALSE` et `IS NOT UNKNOWN`. Ils s’utilisent avec les expressions [Bool](/fr/reference/data-types/boolean) et `Nullable(Bool)`. * `expr IS TRUE` renvoie `1` uniquement si `expr` vaut `true`. * `expr IS FALSE` renvoie `1` uniquement si `expr` vaut `false`. * `expr IS UNKNOWN` renvoie `1` uniquement si `expr` vaut `NULL`. * `expr IS NOT TRUE` renvoie `1` si `expr` vaut `false` ou `NULL`. * `expr IS NOT FALSE` renvoie `1` si `expr` vaut `true` ou `NULL`. * `expr IS NOT UNKNOWN` renvoie `1` si `expr` n’est pas `NULL`. Pour les expressions booléennes, `IS UNKNOWN` est équivalent à `IS NULL` et `IS NOT UNKNOWN` est équivalent à `IS NOT NULL`. ```sql theme={null} CREATE TABLE t_bool (x Nullable(Bool)) ENGINE = Memory; INSERT INTO t_bool VALUES (true), (false), (NULL); SELECT x, x IS TRUE, x IS FALSE, x IS UNKNOWN, x IS NOT TRUE, x IS NOT FALSE, x IS NOT UNKNOWN FROM t_bool; ```