> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-parallel-read-in-order-multi-part.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éséance et de leur associativité.

Opérateurs d’accès

`a[N]` – Accès à un élément d’un tableau. Fonction `arrayElement(a, N)`. `N` peut également être un tableau d’entiers, auquel cas les éléments situés à toutes ces positions sont renvoyés sous forme de tableau, comme avec `arrayMap(i -> a[i], N)`. Les positions peuvent être nullables. Une position `NULL` produit `NULL` lorsque le type d’élément peut être encapsulé dans `Nullable` ; pour les types d’éléments qui ne peuvent pas être contenus dans `Nullable` (comme `Array`, `Map`), elle produit la valeur par défaut du type d’élément, comme pour un index `NULL` scalaire. `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 match

`a REGEXP b` – Fonction `match(a, b)`. `a ~ b` – Fonction `match(a, b)` (correspondance d’expression régulière de type PostgreSQL).

Fonction notMatch

`a !~ b` – Fonction `notMatch(a, b)` (vérifie que `a` ne correspond pas à l’expression régulière `b`).

Fonction matchCaseInsensitive

`a ~* b` – Fonction `matchCaseInsensitive(a, b)` (correspondance d’expression régulière insensible à la casse).

Fonction notMatchCaseInsensitive

`a !~* b` – La fonction `notMatchCaseInsensitive(a, b)` (vérifie que `a` ne correspond pas à l’expression régulière `b`, sans distinction entre majuscules et minuscules).

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 pris en charge) | `arrayExists(x -> expr OP x, arr)` | | `expr OP ALL(arr)` (tout autre opérateur pris en charge) | `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 est reconnue pour les opérateurs de comparaison `=`, `==`, `!=`, `<>`, `<=>`, `<`, `<=`, `>`, `>=`, les prédicats de comparaison à mot-clé `IS DISTINCT FROM` et `IS NOT DISTINCT FROM`, ainsi que les prédicats de recherche de chaînes `LIKE`, `ILIKE`, `NOT LIKE`, `NOT ILIKE` et `REGEXP`. Les prédicats de comparaison à mot-clé et les prédicats de recherche de chaînes ne sont reconnus que pour la forme tableau, pas pour la forme avec sous-requête (qui est ramenée à `IN`/`NOT IN`). Les opérateurs qui n'ont pas de signification de quantificateur de tableau — par exemple `IN` lui-même — ne sont **pas** réécrits et conservent leur sens habituel. Les prédicats de recherche de chaînes fonctionnent parce que `MatchImpl` (l'implémentation sous-jacente à `LIKE` / `ILIKE` / `REGEXP`) prend en charge un haystack constant avec une needle non constante. Par exemple, `'abc' LIKE SOME(['a%', 'b%'])` est réécrit en `arrayExists(x -> 'abc' LIKE x, ['a%', 'b%'])`, et `'abc' NOT LIKE ALL(['x%', 'y%'])` en `arrayAll(x -> 'abc' NOT LIKE x, ['x%', 'y%'])`. Cela permet de faire correspondre une chaîne à plusieurs patterns ; pour une correspondance en un seul passage combiné, vous pouvez toujours utiliser une fonction de recherche multi-pattern telle que `multiMatchAny` (expressions régulières) ou `multiSearchAny` (substrings). **`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, 'abc' LIKE SOME(['a%', 'z%']) AS like_some; ``` ```text title="Response" theme={null} ┌─in_array─┬─less_than_some─┬─greater_than_all─┬─like_some─┐ │ 1 │ 1 │ 1 │ 1 │ └──────────┴────────────────┴──────────────────┴───────────┘ ``` **La gestion de `NULL` diffère de celle de la forme avec sous-requête** Comme la forme 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/other#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#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) │ └─────────────────────────┴────────────────┘ ```

AT TIME ZONE et AT LOCAL

Les opérateurs postfixes `AT TIME ZONE` et `AT LOCAL` convertissent une valeur `DateTime` ou `DateTime64` vers un autre fuseau horaire. Ils constituent un sucre syntaxique de la fonction existante [`toTimeZone`](/fr/reference/functions/regular-functions/date-time-functions#toTimezone) : | Syntaxe | Équivalent | | - | - | | `expr AT TIME ZONE zone` | `toTimeZone(expr, zone)` | | `expr AT LOCAL` | `toTimeZone(expr, timeZone())` | `zone` peut être n’importe quelle expression de chaîne constante qui s’évalue en un nom de fuseau horaire valide (par ex. `'America/Denver'`, `'UTC'` ou `concat('America', '/', 'Denver')`). Comme `AT TIME ZONE` est réécrit en `toTimeZone`, les mêmes règles s’appliquent aux arguments de fuseau horaire : les expressions non constantes, comme une référence de colonne, nécessitent [`allow_nonconst_timezone_arguments = 1`](/fr/reference/settings/session-settings/allow#allow_nonconst_timezone_arguments). `AT LOCAL` utilise le [fuseau horaire de session](/fr/reference/settings/session-settings/other#session_timezone) actuel (ou le fuseau horaire par défaut du serveur si aucun fuseau horaire de session n’est défini). Sur les tables `Distributed`, `session_timezone` doit être défini explicitement ; lorsqu’il est vide, `timeZone()` est local au shard et ne peut pas être utilisé comme argument constant de `toTimeZone`, ce qui provoque une exception `ILLEGAL_COLUMN`. Contrairement à PostgreSQL, où `timestamp without time zone AT TIME ZONE zone` réinterprète la valeur telle qu’affichée comme appartenant au fuseau donné avant la conversion, ClickHouse conserve toujours le même instant absolu et modifie uniquement l’étiquette de fuseau horaire utilisée pour l’affichage. Les deux formes sont équivalentes à `toTimeZone` et ne modifient pas le timestamp sous-jacent. `AT TIME ZONE` a une préséance d’opérateur de 13 (au-dessus de `*`/`/`/`%` à 12, et au-dessus de `+`/`-` à 11), comme dans PostgreSQL. Cela signifie que `a * ts AT TIME ZONE 'tz'` s’associe comme `a * (ts AT TIME ZONE 'tz')`, et que `ts + interval AT TIME ZONE 'tz'` s’associe comme `ts + (interval AT TIME ZONE 'tz')`. Pour appliquer la conversion de fuseau horaire après l’opération arithmétique, utilisez des parenthèses explicites : ```sql theme={null} -- Explicit parens required to add first, then convert timezone SELECT (TIMESTAMP '2001-02-16 20:38:40' + INTERVAL 1 HOUR) AT TIME ZONE 'America/Denver'; -- Equivalent to: SELECT toTimeZone(TIMESTAMP '2001-02-16 20:38:40' + INTERVAL 1 HOUR, 'America/Denver'); ``` Exemples : ```sql theme={null} SET session_timezone = 'UTC'; SELECT TIMESTAMP '2001-02-16 20:38:40' AT TIME ZONE 'America/Denver'; ``` ```text theme={null} ┌─toTimeZone(toDateTime('2001-02-16 20:38:40'), 'America/Denver')─┐ │ 2001-02-16 13:38:40 │ └──────────────────────────────────────────────────────────────────┘ ``` ```sql theme={null} SELECT TIMESTAMP '2001-02-16 20:38:40' AT LOCAL; ``` ```text theme={null} ┌─toTimeZone(toDateTime('2001-02-16 20:38:40'), timeZone())─┐ │ 2001-02-16 20:38:40 │ └────────────────────────────────────────────────────────────┘ ``` **Voir aussi** * [`toTimeZone`](/fr/reference/functions/regular-functions/date-time-functions#toTimezone) * [`timeZone`](/fr/reference/functions/regular-functions/date-time-functions#timezone)

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#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 != 0 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#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; ```