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

> Документация по операторам

# Операторы

ClickHouse преобразует операторы в соответствующие им функции на этапе разбора запроса с учётом их приоритета, старшинства и ассоциативности.

<div id="access-operators">
  ## Операторы доступа
</div>

`a[N]` — доступ к элементу массива. Функция `arrayElement(a, N)`.

`a.N` — доступ к элементу кортежа. Функция `tupleElement(a, N)`.

<div id="numeric-negation-operator">
  ## Оператор числового отрицания
</div>

`-a` — функция `negate (a)`.

Для отрицания кортежей см. [tupleNegate](/ru/reference/functions/regular-functions/tuple-functions#tupleNegate).

<div id="multiplication-and-division-operators">
  ## Операторы умножения и деления
</div>

`a * b` – функция `multiply (a, b)`.

Для умножения кортежа на число используйте [tupleMultiplyByNumber](/ru/reference/functions/regular-functions/tuple-functions#tupleMultiplyByNumber), для скалярного произведения — [dotProduct](/ru/reference/functions/regular-functions/array-functions#arrayDotProduct).

`a / b` – функция `divide(a, b)`.

Для деления кортежа на число используйте [tupleDivideByNumber](/ru/reference/functions/regular-functions/tuple-functions#tupleDivideByNumber).

`a % b` – функция `modulo(a, b)`.

<div id="addition-and-subtraction-operators">
  ## Операторы сложения и вычитания
</div>

`a + b` — функция `plus(a, b)`.

Для сложения кортежей: [tuplePlus](/ru/reference/functions/regular-functions/tuple-functions#tuplePlus).

`a - b` — функция `minus(a, b)`.

Для вычитания кортежей: [tupleMinus](/ru/reference/functions/regular-functions/tuple-functions#tupleMinus).

<div id="comparison-operators">
  ## Операторы сравнения
</div>

<div id="equals-function">
  ### функция equals
</div>

`a = b` — функция `equals(a, b)`.

`a == b` — функция `equals(a, b)`.

<div id="notequals-function">
  ### Функция `notEquals`
</div>

`a != b` — функция `notEquals(a, b)`.

`a <> b` — функция `notEquals(a, b)`.

<div id="lessorequals-function">
  ### Функция lessOrEquals
</div>

`a <= b` — функция `lessOrEquals(a, b)`.

<div id="greaterorequals-function">
  ### функция greaterOrEquals
</div>

`a >= b` — функция `greaterOrEquals(a, b)`.

<div id="less-function">
  ### функция less
</div>

`a < b` — функция `less(a, b)`.

<div id="greater-function">
  ### функция greater
</div>

`a > b` — функция `greater(a, b)`.

<div id="like-function">
  ### функция like
</div>

`a LIKE b` — функция `like(a, b)`.

<div id="notlike-function">
  ### Функция notLike
</div>

`a NOT LIKE b` — функция `notLike(a, b)`.

<div id="ilike-function">
  ### Функция ilike
</div>

`a ILIKE b` — функция `ilike(a, b)`.

<div id="between-function">
  ### Функция BETWEEN
</div>

`a BETWEEN b AND c` – То же, что и `a >= b AND a <= c`.

`a NOT BETWEEN b AND c` – То же, что и `a < b OR a > c`.

<div id="is-not-distinct-from">
  ### Оператор `is not distinct from` (`<=>`)
</div>

<Note>
  Начиная с версии 25.10, `<=>` можно использовать так же, как и любой другой оператор.
  До версии 25.10 его можно было использовать только в выражениях JOIN, например:

  ```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 │
  └────────────┴────────────┘
  ```
</Note>

Оператор `<=>` — это оператор равенства, безопасный для `NULL`, эквивалентный `IS NOT DISTINCT FROM`.
Он работает как обычный оператор равенства (`=`), но при этом считает значения `NULL` сопоставимыми.
Два значения `NULL` считаются равными, а сравнение `NULL` с любым значением, отличным от `NULL`, возвращает 0 (`false`), а не `NULL`.

```sql theme={null}
SELECT
  'ClickHouse' <=> NULL,
  NULL <=> NULL
```

```response theme={null}
┌─isNotDistinc⋯use', NULL)─┬─isNotDistinc⋯NULL, NULL)─┐
│                        0 │                        1 │
└──────────────────────────┴──────────────────────────┘
```

<div id="operators-for-working-with-strings">
  ## Операторы для работы со строками
</div>

<div id="overlay">
  ### OVERLAY
</div>

* `OVERLAY(string PLACING replacement FROM offset)` - функция `overlay(string, replacement, offset)`.
* `OVERLAY(string PLACING replacement FROM offset FOR length)` - функция `overlay(string, replacement, offset, length)`.
* `OVERLAYUTF8(string PLACING replacement FROM offset)` - функция `overlayUTF8(string, replacement, offset)`.
* `OVERLAYUTF8(string PLACING replacement FROM offset FOR length)` - функция `overlayUTF8(string, replacement, offset, length)`.

<div id="operators-for-working-with-data-sets">
  ## Операторы для работы с наборами данных
</div>

См. [операторы IN](/ru/reference/statements/in) и [оператор EXISTS](/ru/reference/operators/exists).

<div id="in-function">
  ### функция in
</div>

`a IN ...` — функция `in(a, b)`.

<div id="notin-function">
  ### Функция notIn
</div>

`a NOT IN ...` — функция `notIn(a, b)`.

<div id="globalin-function">
  ### Функция globalIn
</div>

`a GLOBAL IN ...` — функция `globalIn(a, b)`.

<div id="globalnotin-function">
  ### Функция globalNotIn
</div>

`a GLOBAL NOT IN ...` — функция `globalNotIn(a, b)`.

<div id="in-subquery-function">
  ### функция in для подзапроса
</div>

`a = ANY (subquery)` — функция `in(a, subquery)`.

<div id="notin-subquery-function">
  ### функция notIn с подзапросом
</div>

`a != ANY (subquery)` — То же, что и `a NOT IN (SELECT singleValueOrNull(*) FROM subquery)`.

<div id="in-subquery-function">
  ### функция in для подзапроса
</div>

`a = ALL (subquery)` — то же, что `a IN (SELECT singleValueOrNull(*) FROM subquery)`.

<div id="notin-subquery-function">
  ### функция notIn с подзапросом
</div>

`a != ALL (subquery)` — функция `notIn(a, subquery)`.

**Примеры**

Запрос с 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 │
└───┘
```

Запрос с 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 │
└───┘
```

<div id="operators-for-working-with-dates-and-times">
  ## Операторы для работы с датами и временем
</div>

<div id="extract">
  ### EXTRACT
</div>

```sql theme={null}
EXTRACT(part FROM date);
```

Извлекает части заданной даты. Например, можно получить месяц из даты или секунду из времени.

Параметр `part` указывает, какую часть даты нужно извлечь. Доступны следующие значения:

* `SECOND` — Секунда. Возможные значения: 0–59.
* `MINUTE` — Минута. Возможные значения: 0–59.
* `HOUR` — Час. Возможные значения: 0–23.
* `DAY` — День месяца. Возможные значения: 1–31.
* `WEEK` — Номер недели по ISO 8601. Возможные значения: 1–53.
* `MONTH` — Номер месяца. Возможные значения: 1–12.
* `QUARTER` — Квартал. Возможные значения: 1–4.
* `YEAR` — Год.
* `EPOCH` — Unix-временная метка (секунды с 1970-01-01 00:00:00 UTC). Примечание: для `DateTime64` дробная часть секунды отбрасывается.
* `DOW` — День недели (совместимо с PostgreSQL). 0 = воскресенье, 6 = суббота.
* `DOY` — День года. Возможные значения: 1–366.
* `ISODOW` — День недели по ISO. 1 = понедельник, 7 = воскресенье.
* `ISOYEAR` — Год нумерации недель по ISO 8601.
* `CENTURY` — Век. Например, 2024 год относится к XXI веку.
* `DECADE` — Десятилетие (год, делённый на 10). Например, для 2024 года десятилетие равно 202.
* `MILLENNIUM` — Тысячелетие. Например, 2024 год относится к III тысячелетию.

Параметр `part` регистронезависимый.

Параметр `date` задаёт дату или время для обработки. Поддерживаются типы [Date](/ru/reference/data-types/date), [Date32](/ru/reference/data-types/date32), [DateTime](/ru/reference/data-types/datetime) и [DateTime64](/ru/reference/data-types/datetime64).

Примеры:

```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'));
```

В следующем примере мы создаём таблицу и вставляем в неё значение типа `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 │
└───────────┴────────────┴──────────┴───────────┴─────────────┴─────────────┘
```

Больше примеров можно найти в [tests](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00619_extract.sql).

<div id="interval">
  ### INTERVAL
</div>

Создаёт значение типа [Interval](/ru/reference/data-types/special-data-types/interval), которое используется в арифметических операциях со значениями типов [Date](/ru/reference/data-types/date) и [DateTime](/ru/reference/data-types/datetime).

Типы интервалов:

* `SECOND`
* `MINUTE`
* `HOUR`
* `DAY`
* `WEEK`
* `MONTH`
* `QUARTER`
* `YEAR`

При указании значения `INTERVAL` также можно использовать строковый литерал. Например, `INTERVAL 1 HOUR` эквивалентно `INTERVAL '1 hour'` или `INTERVAL '1' hour`.

<Tip>
  Интервалы разных типов нельзя комбинировать. Нельзя использовать выражения вида `INTERVAL 4 DAY 1 HOUR`. Указывайте интервалы в единицах, которые меньше или равны наименьшей единице интервала, например `INTERVAL 25 HOUR`. Также можно использовать последовательные операции, как в примере ниже.
</Tip>

Примеры:

```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 │
└─────────────────────┴────────────────────────────────────────────────────────────┘
```

<Note>
  Синтаксис `INTERVAL` или функция `addDays` всегда предпочтительнее. Простое сложение или вычитание (например, выражение вида `now() + ...`) не учитывает настройки времени, например переход на летнее время.
</Note>

Примеры:

```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 │
└─────────────────────┴─────────────────────┴─────────────────────┘
```

**См. также**

* тип данных [Interval](/ru/reference/data-types/special-data-types/interval)
* функции преобразования типов [toInterval](/ru/reference/functions/regular-functions/type-conversion-functions#toIntervalYear)

<div id="date-time-addition">
  ### Сложение даты и времени
</div>

Значение [Date](/ru/reference/data-types/date) или [Date32](/ru/reference/data-types/date32) можно сложить со значением [Time](/ru/reference/data-types/time) или [Time64](/ru/reference/data-types/time64) с помощью оператора `+`. В результате получается [DateTime](/ru/reference/data-types/datetime) или [DateTime64](/ru/reference/data-types/datetime64), представляющий дату с указанным временем суток. Эта операция коммутативна.

Тип результата зависит от типов операндов:

| Левый операнд | Правый операнд | Тип результата  |
| ------------- | -------------- | --------------- |
| `Date`        | `Time`         | `DateTime`      |
| `Date`        | `Time64(s)`    | `DateTime64(s)` |
| `Date32`      | `Time`         | `DateTime64(0)` |
| `Date32`      | `Time64(s)`    | `DateTime64(s)` |

<Note>
  В результате используется [часовой пояс сеанса](/ru/reference/settings/session-settings#session_timezone) (или часовой пояс сервера по умолчанию, если часовой пояс сеанса не задан). Настройка [`date_time_overflow_behavior`](/ru/reference/settings/formats#date_time_overflow_behavior) определяет, что произойдет, если результат выйдет за пределы представимого диапазона.
</Note>

Примеры:

```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)  │
└─────────────────────────┴────────────────┘
```

<div id="logical-and-operator">
  ## Оператор логического AND
</div>

Синтаксис `SELECT a AND b` — вычисляет результат логической конъюнкции `a` и `b` с помощью функции [and](/ru/reference/functions/regular-functions/logical-functions#and).

<div id="logical-or-operator">
  ## Оператор логического ИЛИ
</div>

Синтаксис `SELECT a OR b` — вычисляет логическую дизъюнкцию `a` и `b` с помощью функции [or](/ru/reference/functions/regular-functions/logical-functions#or).

<div id="logical-negation-operator">
  ## Оператор логического отрицания
</div>

Синтаксис: `SELECT NOT a` — вычисляет логическое отрицание `a` с помощью функции [not](/ru/reference/functions/regular-functions/logical-functions#not).

<div id="conditional-operator">
  ## Условный оператор
</div>

`a ? b : c` — функция `if(a, b, c)`.

Примечание:

Условный оператор вычисляет значения b и c, затем проверяет, выполняется ли условие a, и после этого возвращает соответствующее значение. Если `b` или `C` — функция [arrayJoin()](/ru/reference/functions/regular-functions/array-join), каждая строка будет продублирована независимо от условия `a`.

<div id="conditional-expression">
  ## Условное выражение
</div>

```sql theme={null}
CASE [x]
    WHEN a THEN b
    [WHEN ... THEN ...]
    [ELSE c]
END
```

Если указан `x`, используется функция `transform(x, [a, ...], [b, ...], c)`. В противном случае — `multiIf(a, b, ..., c)`.

Если в выражении отсутствует часть `ELSE c`, значением по умолчанию будет `NULL`.

Функция `transform` не работает с `NULL`.

<div id="concatenation-operator">
  ## Оператор конкатенации
</div>

`s1 || s2` — функция `concat(s1, s2)`.

<div id="lambda-creation-operator">
  ## Оператор создания лямбда-функции
</div>

`x -> expr` – функция `lambda(x, expr)`.

Следующие операторы не имеют приоритета, поскольку это скобки:

<div id="array-creation-operator">
  ## Оператор создания Array
</div>

`[x1, ...]` – Функция `array(x1, ...)`.

<div id="tuple-creation-operator">
  ## Оператор создания Tuple
</div>

`(x1, x2, ...)` — функция `tuple(x2, x2, ...)`.

<div id="associativity">
  ## Ассоциативность
</div>

Все бинарные операторы имеют левую ассоциативность. Например, `1 + 2 + 3` преобразуется в `plus(plus(1, 2), 3)`.
Иногда результат оказывается не таким, как вы ожидаете. Например, `SELECT 4 > 2 > 3` вернёт 0.

Для повышения эффективности функции `and` и `or` принимают произвольное число аргументов. Соответствующие цепочки операторов `AND` и `OR` преобразуются в один вызов этих функций.

<div id="checking-for-null">
  ## Проверка на `NULL`
</div>

ClickHouse поддерживает операторы `IS NULL` и `IS NOT NULL`.

<div id="is_null">
  ### IS NULL
</div>

* Для значений типа [Nullable](/ru/reference/data-types/nullable) оператор `IS NULL` возвращает:
  * `1`, если значение равно `NULL`.
  * `0` в противном случае.
* Для всех остальных значений оператор `IS NULL` всегда возвращает `0`.

Можно оптимизировать, включив настройку [optimize\_functions\_to\_subcolumns](/ru/reference/settings/session-settings#optimize_functions_to_subcolumns). При `optimize_functions_to_subcolumns = 1` функция читает только подстолбец [null](/ru/reference/data-types/nullable#finding-null) вместо чтения и обработки данных всего столбца. Запрос `SELECT n IS NULL FROM table` преобразуется в `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 │
└──────────────┘
```

<div id="is_not_null">
  ### IS NOT NULL
</div>

* Для значений типа [Nullable](/ru/reference/data-types/nullable) оператор `IS NOT NULL` возвращает:
  * `0`, если значение — `NULL`.
  * `1` в противном случае.
* Для всех остальных значений оператор `IS NOT NULL` всегда возвращает `1`.

```sql theme={null}
SELECT * FROM t_null WHERE y IS NOT NULL
```

```text theme={null}
┌─x─┬─y─┐
│ 2 │ 3 │
└───┴───┘
```

Можно повысить производительность, включив настройку [optimize\_functions\_to\_subcolumns](/ru/reference/settings/session-settings#optimize_functions_to_subcolumns). При `optimize_functions_to_subcolumns = 1` функция читает только подстолбец [null](/ru/reference/data-types/nullable#finding-null) вместо чтения и обработки всех данных столбца. Запрос `SELECT n IS NOT NULL FROM table` преобразуется в `SELECT NOT n.null FROM TABLE`.