ClickHouse/docs/fr/query_language/operators.md

---
machine_translated: true
---

# Opérateur {#operators}

Tous les opérateurs sont transformés en leurs fonctions correspondantes à l'étape d'analyse des requêtes en fonction de leur priorité et de leur associativité.
Les groupes d'opérateurs sont listés par ordre de priorité (plus il est élevé dans la liste, plus tôt l'opérateur est connecté à ses arguments).

## Des Opérateurs D'Accès {#access-operators}

`a[N]` – Access to an element of an array. The `arrayElement(a, N)` fonction.

`a.N` – Access to a tuple element. The `tupleElement(a, N)` fonction.

## Opérateur De Négation Numérique {#numeric-negation-operator}

`-a` – The `negate (a)` fonction.

## Opérateurs de Multiplication et de Division {#multiplication-and-division-operators}

`a * b` – The `multiply (a, b)` fonction.

`a / b` – The `divide(a, b)` fonction.

`a % b` – The `modulo(a, b)` fonction.

## Opérateurs d'Addition et de soustraction {#addition-and-subtraction-operators}

`a + b` – The `plus(a, b)` fonction.

`a - b` – The `minus(a, b)` fonction.

## Opérateurs De Comparaison {#comparison-operators}

`a = b` – The `equals(a, b)` fonction.

`a == b` – The `equals(a, b)` fonction.

`a != b` – The `notEquals(a, b)` fonction.

`a <> b` – The `notEquals(a, b)` fonction.

`a <= b` – The `lessOrEquals(a, b)` fonction.

`a >= b` – The `greaterOrEquals(a, b)` fonction.

`a < b` – The `less(a, b)` fonction.

`a > b` – The `greater(a, b)` fonction.

`a LIKE s` – The `like(a, b)` fonction.

`a NOT LIKE s` – The `notLike(a, b)` fonction.

`a BETWEEN b AND c` – The same as `a >= b AND a <= c`.

`a NOT BETWEEN b AND c` – The same as `a < b OR a > c`.

## Opérateurs pour travailler avec des ensembles de données {#operators-for-working-with-data-sets}

*Voir [Dans les opérateurs](select.md#select-in-operators).*

`a IN ...` – The `in(a, b)` fonction.

`a NOT IN ...` – The `notIn(a, b)` fonction.

`a GLOBAL IN ...` – The `globalIn(a, b)` fonction.

`a GLOBAL NOT IN ...` – The `globalNotIn(a, b)` fonction.

## Opérateurs pour travailler avec des Dates et des heures {#operators-datetime}

### EXTRACT {#operator-extract}

``` sql
EXTRACT(part FROM date);
```

Extrait une partie d'une date donnée. Par exemple, vous pouvez récupérer un mois à partir d'une date donnée, ou d'une seconde à partir d'un moment.

Le `part` paramètre spécifie la partie de la date à récupérer. Les valeurs suivantes sont disponibles:

-   `DAY` — The day of the month. Possible values: 1–31.
-   `MONTH` — The number of a month. Possible values: 1–12.
-   `YEAR` — The year.
-   `SECOND` — The second. Possible values: 0–59.
-   `MINUTE` — The minute. Possible values: 0–59.
-   `HOUR` — The hour. Possible values: 0–23.

Le `part` le paramètre est insensible à la casse.

Le `date` paramètre spécifie la date ou l'heure à traiter. Soit [Date](../data_types/date.md) ou [DateTime](../data_types/datetime.md) le type est pris en charge.

Exemple:

``` sql
SELECT EXTRACT(DAY FROM toDate('2017-06-15'));
SELECT EXTRACT(MONTH FROM toDate('2017-06-15'));
SELECT EXTRACT(YEAR FROM toDate('2017-06-15'));
```

Dans l'exemple suivant, nous créons un tableau et de les insérer dans une valeur avec le `DateTime` type.

``` sql
CREATE TABLE test.Orders
(
    OrderId UInt64,
    OrderName String,
    OrderDate DateTime
)
ENGINE = Log;
```

``` sql
INSERT INTO test.Orders VALUES (1, 'Jarlsberg Cheese', toDateTime('2008-10-11 13:23:44'));
```

``` sql
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
┌─OrderYear─┬─OrderMonth─┬─OrderDay─┬─OrderHour─┬─OrderMinute─┬─OrderSecond─┐
│      2008 │         10 │       11 │        13 │          23 │          44 │
└───────────┴────────────┴──────────┴───────────┴─────────────┴─────────────┘
```

Vous pouvez voir plus d'exemples de [test](https://github.com/ClickHouse/ClickHouse/blob/master/dbms/tests/queries/0_stateless/00619_extract.sql).

### INTERVAL {#operator-interval}

Crée un [Intervalle](../data_types/special_data_types/interval.md)- valeur de type qui doit être utilisée dans les opérations arithmétiques avec [Date](../data_types/date.md) et [DateTime](../data_types/datetime.md)-type de valeurs.

Types d'intervalles:
- `SECOND`
- `MINUTE`
- `HOUR`
- `DAY`
- `WEEK`
- `MONTH`
- `QUARTER`
- `YEAR`

!!! warning "Avertissement"
    Les intervalles avec différents types ne peuvent pas être combinés. Vous ne pouvez pas utiliser des expressions comme `INTERVAL 4 DAY 1 HOUR`. Exprimer des intervalles en unités plus petites ou égales à la plus petite unité de l'intervalle, par exemple `INTERVAL 25 HOUR`. Vous pouvez utiliser des opérations conséquentes comme dans l'exemple ci-dessous.

Exemple:

``` sql
SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR
```

``` text
┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐
│ 2019-10-23 11:16:28 │                                    2019-10-27 14:16:28 │
└─────────────────────┴────────────────────────────────────────────────────────┘
```

**Voir Aussi**

-   [Intervalle](../data_types/special_data_types/interval.md) type de données
-   [toInterval](functions/type_conversion_functions.md#function-tointerval) type fonctions de conversion

## Opérateur De Négation Logique {#logical-negation-operator}

`NOT a` – The `not(a)` fonction.

## Logique ET de l'Opérateur {#logical-and-operator}

`a AND b` – The`and(a, b)` fonction.

## Logique ou opérateur {#logical-or-operator}

`a OR b` – The `or(a, b)` fonction.

## Opérateur Conditionnel {#conditional-operator}

`a ? b : c` – The `if(a, b, c)` fonction.

Note:

L'opérateur conditionnel calcule les valeurs de b et c, puis vérifie si la condition a est remplie, puis renvoie la valeur correspondante. Si `b` ou `C` est un [arrayJoin()](functions/array_join.md#functions_arrayjoin) fonction, chaque ligne sera répliquée indépendamment de la “a” condition.

## Expression Conditionnelle {#operator_case}

``` sql
CASE [x]
    WHEN a THEN b
    [WHEN ... THEN ...]
    [ELSE c]
END
```

Si `x` est spécifié, alors `transform(x, [a, ...], [b, ...], c)` function is used. Otherwise – `multiIf(a, b, ..., c)`.

Si il n'y a pas de `ELSE c` dans l'expression, la valeur par défaut est `NULL`.

Le `transform` la fonction ne fonctionne pas avec `NULL`.

## Opérateur De Concaténation {#concatenation-operator}

`s1 || s2` – The `concat(s1, s2) function.`

## Opérateur De Création Lambda {#lambda-creation-operator}

`x -> expr` – The `lambda(x, expr) function.`

Les opérateurs suivants n'ont pas de priorité, puisqu'ils sont des parenthèses:

## Opérateur De Création De Tableau {#array-creation-operator}

`[x1, ...]` – The `array(x1, ...) function.`

## Opérateur De Création De Tuple {#tuple-creation-operator}

`(x1, x2, ...)` – The `tuple(x2, x2, ...) function.`

## Associativité {#associativity}

Tous les opérateurs binaires ont associativité gauche. Exemple, `1 + 2 + 3` est transformé à `plus(plus(1, 2), 3)`.
Parfois, cela ne fonctionne pas de la façon que vous attendez. Exemple, `SELECT 4 > 2 > 3` résultat sera 0.

Pour l'efficacité, le `and` et `or` les fonctions acceptent n'importe quel nombre d'arguments. Les chaînes de `AND` et `OR` les opérateurs sont transformés en un seul appel de ces fonctions.

## La vérification de `NULL` {#checking-for-null}

Clickhouse soutient le `IS NULL` et `IS NOT NULL` opérateur.

### IS NULL {#operator-is-null}

-   Pour [Nullable](../data_types/nullable.md) type de valeurs, l' `IS NULL` opérateur retourne:
    -   `1` si la valeur est `NULL`.
    -   `0` autrement.
-   Pour les autres valeurs, la `IS NULL` l'opérateur renvoie toujours `0`.

<!-- -->

``` sql
SELECT x+100 FROM t_null WHERE y IS NULL
```

``` text
┌─plus(x, 100)─┐
│          101 │
└──────────────┘
```

### IS NOT NULL {#is-not-null}

-   Pour [Nullable](../data_types/nullable.md) type de valeurs, l' `IS NOT NULL` opérateur retourne:
    -   `0` si la valeur est `NULL`.
    -   `1` autrement.
-   Pour les autres valeurs, la `IS NOT NULL` l'opérateur renvoie toujours `1`.

<!-- -->

``` sql
SELECT * FROM t_null WHERE y IS NOT NULL
```

``` text
┌─x─┬─y─┐
│ 2 │ 3 │
└───┴───┘
```

[Article Original](https://clickhouse.tech/docs/en/query_language/operators/) <!--hide-->