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

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

# Арифметические функции

<div id="overview">
  ## Обзор
</div>

Арифметические функции применимы к любым двум операндам типа `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Int8`, `Int16`, `Int32`, `Int64`, `Float32` или `Float64`.

Перед выполнением операции оба операнда приводятся к типу результата. Тип результата определяется следующим образом (если в документации по функции ниже не указано
иначе):

* Если оба операнда имеют разрядность до 32 бит, размер типа результата будет равен размеру следующего большего типа после большего из
  двух операндов (повышение разрядности целых чисел). Например, `UInt8 + UInt16 = UInt32` или `Float32 * Float32 = Float64`.
* Если один из операндов имеет разрядность 64 бита или больше, размер типа результата будет таким же, как у большего из двух операндов. Например,
  `UInt32 + UInt128 = UInt128` или `Float32 * Float64 = Float64`.
* Если один из операндов знаковый, тип результата также будет знаковым, в противном случае — беззнаковым. Например, `UInt32 * Int32 = Int64` или `UInt32 * UInt32 = UInt64`.

Эти правила гарантируют, что тип результата будет наименьшим типом, способным представить все возможные результаты. Хотя это создает риск
переполнения на границах диапазона значений, такой подход обеспечивает быстрое выполнение вычислений с использованием максимальной нативной разрядности целых чисел —
64 бита. Такое поведение также гарантирует совместимость со многими другими базами данных, в которых 64-битные целые числа (BIGINT) являются самым большим целочисленным
типом.

Пример:

```sql theme={null}
SELECT toTypeName(0), toTypeName(0 + 0), toTypeName(0 + 0 + 0), toTypeName(0 + 0 + 0 + 0)
```

```text theme={null}
┌─toTypeName(0)─┬─toTypeName(plus(0, 0))─┬─toTypeName(plus(plus(0, 0), 0))─┬─toTypeName(plus(plus(plus(0, 0), 0), 0))─┐
│ UInt8         │ UInt16                 │ UInt32                          │ UInt64                                   │
└───────────────┴────────────────────────┴─────────────────────────────────┴──────────────────────────────────────────┘
```

Переполнения возникают так же, как в C++.

{/*AUTOGENERATED_START*/}

<div id="abs">
  ## abs
</div>

Добавленный в: v1.1.0

Вычисляет абсолютное значение `x`. Не имеет эффекта, если `x` имеет беззнаковый тип. Если `x` имеет знаковый тип, возвращает беззнаковое число.

**Синтаксис**

```sql theme={null}
abs(x)
```

**Аргументы**

* `x` — Значение, для которого вычисляется абсолютное значение

**Возвращаемое значение**

Абсолютное значение `x`

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT abs(-0.5)
```

```response title=Response theme={null}
0.5
```

<div id="avg2">
  ## avg2
</div>

Добавленный в: v25.11.0

Вычисляет и возвращает среднее значение указанных аргументов.
Поддерживает числовые и временные типы.

**Синтаксис**

```sql theme={null}
avg2(x1, x2])
```

**Аргументы**

* `x1, x2]` — Принимает два значения для вычисления среднего.

**Возвращаемое значение**

Возвращает среднее значение переданных аргументов с приведением к наиболее широкому совместимому типу.

**Примеры**

**Числовые типы**

```sql title=Query theme={null}
SELECT avg2(toUInt8(3), 1.0) AS result, toTypeName(result) AS type;
-- Возвращаемый тип — Float64, так как UInt8 необходимо расширить до 64 бит для выполнения сравнения.
```

```response title=Response theme={null}
┌─result─┬─type────┐
│      2 │ Float64 │
└────────┴─────────┘
```

**Типы Decimal**

```sql title=Query theme={null}
SELECT avg2(toDecimal32(1, 2), 2) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌─result─┬─type──────────┐
│    1.5 │ Decimal(9, 2) │
└────────┴───────────────┘
```

**Типы дат**

```sql title=Query theme={null}
SELECT avg2(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘
```

**Типы DateTime**

```sql title=Query theme={null}
SELECT avg2(toDateTime('2025-01-01 00:00:00'), toDateTime('2025-01-03 12:00:00')) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌──────────────result─┬─type─────┐
│ 2025-01-02 06:00:00 │ DateTime │
└─────────────────────┴──────────┘
```

**Типы Time64**

```sql title=Query theme={null}
SELECT avg2(toTime64('12:00:00', 0), toTime64('14:00:00', 0)) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌───result─┬─type──────┐
│ 13:00:00 │ Time64(0) │
└──────────┴───────────┘
```

<div id="byteSwap">
  ## byteSwap
</div>

Добавленный в: v23.10.0

Меняет порядок байтов целого числа на обратный, то есть изменяет его [порядок байтов](https://en.wikipedia.org/wiki/Endianness).

Приведённый ниже пример можно разобрать следующим образом:

1. Преобразуйте целое число из десятичной системы в эквивалентное шестнадцатеричное представление в формате big-endian, то есть 3351772109 -> C7 C7 FB CD (4 байта)
2. Переставьте байты в обратном порядке, то есть C7 C7 FB CD -> CD FB C7 C7
3. Преобразуйте результат обратно в целое число, предполагая формат big-endian, то есть CD FB C7 C7 -> 3455829959
   Одно из применений этой функции — перестановка байтов в IPv4-адресах:

```result theme={null}
┌─toIPv4(byteSwap(toUInt32(toIPv4('205.251.199.199'))))─┐
│ 199.199.251.205                                       │
└───────────────────────────────────────────────────────┘
```

**Синтаксис**

```sql theme={null}
byteSwap(x)
```

**Аргументы**

* `x` — Целое число. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает `x` с байтами в обратном порядке. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT byteSwap(3351772109)
```

```response title=Response theme={null}
3455829959
```

**8-битный**

```sql title=Query theme={null}
SELECT byteSwap(54)
```

```response title=Response theme={null}
54
```

**16-битный**

```sql title=Query theme={null}
SELECT byteSwap(4135)
```

```response title=Response theme={null}
10000
```

**32-разрядный**

```sql title=Query theme={null}
SELECT byteSwap(3351772109)
```

```response title=Response theme={null}
3455829959
```

**64-разрядная**

```sql title=Query theme={null}
SELECT byteSwap(123294967295)
```

```response title=Response theme={null}
18439412204227788800
```

<div id="divide">
  ## divide
</div>

Добавленный в: v1.1.0

Вычисляет частное двух значений `a` и `b`. Тип результата всегда — [Float64](/ru/reference/data-types/float).
Для целочисленного деления используется функция `intDiv`.

<Note>
  При делении на `0` возвращается `inf`, `-inf` или `nan`.
</Note>

**Синтаксис**

```sql theme={null}
divide(x, y)
```

**Аргументы**

* `x` — Делимое - `y` — Делитель

**Возвращаемое значение**

Частное от деления x на y

**Примеры**

**Деление двух чисел**

```sql title=Query theme={null}
SELECT divide(25,5) AS quotient, toTypeName(quotient)
```

```response title=Response theme={null}
5 Float64
```

**Деление на ноль**

```sql title=Query theme={null}
SELECT divide(25,0)
```

```response title=Response theme={null}
inf
```

<div id="divideDecimal">
  ## divideDecimal
</div>

Добавленный в: v22.12.0

Выполняет деление двух десятичных чисел. Результирующее значение имеет тип [Decimal256](/ru/reference/data-types/decimal).
Масштаб результата можно явно задать с помощью аргумента `result_scale` (константный Integer в диапазоне `[0, 76]`). Если он не указан, масштаб результата будет равен максимальному масштабу среди переданных аргументов.

<Note>
  Эта функция работает значительно медленнее, чем обычная `divide`.
  Если вам не требуется контролируемая точность и/или нужны быстрые вычисления, используйте [divide](#divide).
</Note>

**Синтаксис**

```sql theme={null}
divideDecimal(x, y[, result_scale])
```

**Аргументы**

* `x` — Первое значение: [Decimal](/ru/reference/data-types/decimal). - `y` — Второе значение: [Decimal](/ru/reference/data-types/decimal). - `result_scale` — Указанный масштаб результата. Тип: [Int/UInt](/ru/reference/data-types/int-uint).

**Возвращаемое значение**

Результат деления с указанным масштабом. [`Decimal256`](/ru/reference/data-types/decimal)

**Примеры**

**Пример 1**

```sql title=Query theme={null}
divideDecimal(toDecimal256(-12, 0), toDecimal32(2.1, 1), 10)
```

```response title=Response theme={null}
┌─divideDecimal(toDecimal256(-12, 0), toDecimal32(2.1, 1), 10)─┐
│                                                -5.7142857142 │
└──────────────────────────────────────────────────────────────┘
```

**Пример 2**

```sql title=Query theme={null}
SELECT toDecimal64(-12, 1) / toDecimal32(2.1, 1);
SELECT toDecimal64(-12, 1) as a, toDecimal32(2.1, 1) as b, divideDecimal(a, b, 1), divideDecimal(a, b, 5);
```

```response title=Response theme={null}
┌─divide(toDecimal64(-12, 1), toDecimal32(2.1, 1))─┐
│                                             -5.7 │
└──────────────────────────────────────────────────┘
┌───a─┬───b─┬─divideDecimal(toDecimal64(-12, 1), toDecimal32(2.1, 1), 1)─┬─divideDecimal(toDecimal64(-12, 1), toDecimal32(2.1, 1), 5)─┐
│ -12 │ 2.1 │                                                       -5.7 │                                                   -5.71428 │
└─────┴─────┴────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────┘
```

<div id="divideOrNull">
  ## divideOrNull
</div>

Добавленный в: v25.5.0

Аналогично `divide`, но при делении на ноль возвращает NULL.

**Синтаксис**

```sql theme={null}
divideOrNull(x, y)
```

**Аргументы**

* `x` — делимое - `y` — делитель

**Возвращаемое значение**

Результат деления `x` на `y`, или NULL.

**Примеры**

**Деление на ноль**

```sql title=Query theme={null}
SELECT divideOrNull(25, 0)
```

```response title=Response theme={null}
\N
```

<div id="gcd">
  ## gcd
</div>

Добавленный в: v1.1.0

Возвращает наибольший общий делитель двух значений a и b.

Исключение генерируется при делении на ноль или при делении минимального
отрицательного числа на -1.

**Синтаксис**

```sql theme={null}
gcd(x, y)
```

**Аргументы**

* `x` — Первое целое число - `y` — Второе целое число

**Возвращаемое значение**

Наибольший общий делитель чисел `x` и `y`.

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT gcd(12, 18)
```

```response title=Response theme={null}
6
```

<div id="ifNotFinite">
  ## ifNotFinite
</div>

Добавленный в: v20.3.0

Проверяет, является ли число с плавающей запятой конечным.

Аналогичный результат можно получить с помощью [тернарного оператора](/ru/reference/functions/regular-functions/conditional-functions#if): `isFinite(x) ? x : y`.

**Синтаксис**

```sql theme={null}
ifNotFinite(x,y)
```

**Аргументы**

* `x` — Значение, которое нужно проверить на бесконечность. [`Float*`](/ru/reference/data-types/float)
* `y` — Резервное значение. [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

* `x`, если `x` является конечным.
* `y`, если `x` не является конечным.

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT 1/0 AS infimum, ifNotFinite(infimum,42)
```

```response title=Response theme={null}
inf  42
```

<div id="intDiv">
  ## intDiv
</div>

Добавленный в: v1.1.0

Выполняет целочисленное деление значения `x` на `y`. Иными словами,
вычисляет частное, округлённое вниз до ближайшего меньшего целого числа.

Результат имеет ту же разрядность, что и делимое (первый параметр).

Исключение генерируется при делении на ноль, если частное не помещается
в диапазон делимого, или при делении минимального отрицательного числа на минус один.

**Синтаксис**

```sql theme={null}
intDiv(x, y)
```

**Аргументы**

* `x` — Левый операнд. - `y` — Правый операнд.

**Возвращаемое значение**

Результат целочисленного деления `x` на `y`

**Примеры**

**Целочисленное деление двух чисел с плавающей точкой**

```sql title=Query theme={null}
SELECT intDiv(toFloat64(1), 0.001) AS res, toTypeName(res)
```

```response title=Response theme={null}
┌──res─┬─toTypeName(intDiv(toFloat64(1), 0.001))─┐
│ 1000 │ Int64                                   │
└──────┴─────────────────────────────────────────┘
```

**Частное выходит за диапазон значений делимого**

```sql title=Query theme={null}
SELECT
intDiv(1, 0.001) AS res,
toTypeName(res)
```

```response title=Response theme={null}
Received exception from server (version 23.2.1):
Code: 153. DB::Exception: Received from localhost:9000. DB::Exception:
Cannot perform integer division, because it will produce infinite or too
large number: While processing intDiv(1, 0.001) AS res, toTypeName(res).
(ILLEGAL_DIVISION)
```

<div id="intDivOrNull">
  ## intDivOrNull
</div>

Добавленный в: v25.5.0

То же, что и `intDiv`, но возвращает NULL при делении на ноль или при делении
наименьшего отрицательного числа на минус единицу.

**Синтаксис**

```sql theme={null}
intDivOrNull(x, y)
```

**Аргументы**

* `x` — Левый операнд. [`(U)Int*`](/ru/reference/data-types/int-uint)
* `y` — Правый операнд. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Результат целочисленного деления `x` на `y` или NULL.

**Примеры**

**Целочисленное деление на ноль**

```sql title=Query theme={null}
SELECT intDivOrNull(1, 0)
```

```response title=Response theme={null}
\N
```

**Деление наименьшего отрицательного числа на -1**

```sql title=Query theme={null}
SELECT intDivOrNull(-9223372036854775808, -1)
```

```response title=Response theme={null}
\N
```

<div id="intDivOrZero">
  ## intDivOrZero
</div>

Добавленный в: v1.1.0

То же, что и `intDiv`, но возвращает ноль при делении на ноль или при делении
наименьшего отрицательного числа на минус единицу.

**Синтаксис**

```sql theme={null}
intDivOrZero(a, b)
```

**Аргументы**

* `a` — Левый операнд. [`(U)Int*`](/ru/reference/data-types/int-uint)
* `b` — Правый операнд. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Результат целочисленного деления `a` на `b`, либо ноль.

**Примеры**

**Целочисленное деление на ноль**

```sql title=Query theme={null}
SELECT intDivOrZero(1, 0)
```

```response title=Response theme={null}
0
```

**Деление минимального отрицательного числа на -1**

```sql title=Query theme={null}
SELECT intDivOrZero(0.05, -1)
```

```response title=Response theme={null}
0
```

<div id="isFinite">
  ## isFinite
</div>

Добавленный в: v1.1.0

Возвращает `1`, если аргумент Float32 или Float64 не является бесконечным и не равен `NaN`,
в противном случае возвращает `0`.

**Синтаксис**

```sql theme={null}
isFinite(x)
```

**Аргументы**

* `x` — Число для проверки на конечность. [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

`1`, если x не является бесконечным и не равно `NaN`, иначе `0`.

**Примеры**

**Проверка, является ли число конечным**

```sql title=Query theme={null}
SELECT isFinite(inf)
```

```response title=Response theme={null}
0
```

<div id="isInfinite">
  ## isInfinite
</div>

Добавленный в: v1.1.0

Возвращает `1`, если аргумент типа Float32 или Float64 является бесконечностью; в противном случае возвращает `0`.
Обратите внимание, что для `NaN` также возвращается `0`.

**Синтаксис**

```sql theme={null}
isInfinite(x)
```

**Аргументы**

* `x` — число, которое нужно проверить на бесконечность. [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

`1`, если x бесконечно, иначе — `0` (в том числе для `NaN`).

**Примеры**

**Проверка, является ли число бесконечным**

```sql title=Query theme={null}
SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10))
```

```response title=Response theme={null}
1 0 0
```

<div id="isNaN">
  ## isNaN
</div>

Добавленный в: v1.1.0

Возвращает `1`, если аргумент типа Float32 или Float64 имеет значение `NaN`, в противном случае возвращает `0`.

**Синтаксис**

```sql theme={null}
isNaN(x)
```

**Аргументы**

* `x` — аргумент, для которого проверяется, является ли он `NaN`. [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

`1`, если значение равно `NaN`, иначе `0`

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT isNaN(NaN)
```

```response title=Response theme={null}
1
```

<div id="lcm">
  ## lcm
</div>

Добавленный в: v1.1.0

Возвращает наименьшее общее кратное двух значений `x` и `y`.

Генерируется исключение при делении на ноль или при делении минимального отрицательного числа на минус один.

**Синтаксис**

```sql theme={null}
lcm(x, y)
```

**Аргументы**

* `x` — Первое целое число. [`(U)Int*`](/ru/reference/data-types/int-uint)
* `y` — Второе целое число. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Возвращает наименьшее общее кратное чисел `x` и `y`. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT lcm(6, 8)
```

```response title=Response theme={null}
24
```

<div id="max2">
  ## max2
</div>

Добавленный в: v21.11.0

Возвращает большее из двух чисел `x` и `y`.

**Синтаксис**

```sql theme={null}
max2(x, y)
```

**Аргументы**

* `x` — Первое значение [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float), или [`Decimal`](/ru/reference/data-types/decimal)
* `y` — Второе значение [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float), или [`Decimal`](/ru/reference/data-types/decimal)

**Возвращаемое значение**

Возвращает большее из значений `x` и `y`. [`Float64`](/ru/reference/data-types/float)

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT max2(-1, 2)
```

```response title=Response theme={null}
2
```

<div id="midpoint">
  ## midpoint
</div>

Добавленный в: v25.11.0

Вычисляет и возвращает среднее значение переданных аргументов.
Поддерживает числовые и временные типы.

**Синтаксис**

```sql theme={null}
midpoint(x1[, x2, ...])
```

**Аргументы**

* `x1[, x2, ...]` — Принимает одно или несколько значений для вычисления среднего.

**Возвращаемое значение**

Возвращает среднее значение переданных аргументов с приведением к наибольшему совместимому типу.

**Примеры**

**Числовые типы**

```sql title=Query theme={null}
SELECT midpoint(1, toUInt8(3), 0.5) AS result, toTypeName(result) AS type;
-- Возвращаемый тип — Float64, так как UInt8 необходимо расширить до 64 бит для выполнения сравнения.
```

```response title=Response theme={null}
┌─result─┬─type────┐
│    1.5 │ Float64 │
└────────┴─────────┘
```

**Десятичные типы**

```sql title=Query theme={null}
SELECT midpoint(toDecimal32(1.5, 2), toDecimal32(1, 1), 2) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌─result─┬─type──────────┐
│    1.5 │ Decimal(9, 2) │
└────────┴───────────────┘
```

**Типы данных даты**

```sql title=Query theme={null}
SELECT midpoint(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘
```

**Типы DateTime**

```sql title=Query theme={null}
SELECT midpoint(toDateTime('2025-01-01 00:00:00'), toDateTime('2025-01-03 12:00:00')) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌──────────────result─┬─type─────┐
│ 2025-01-02 06:00:00 │ DateTime │
└─────────────────────┴──────────┘
```

**Типы Time64**

```sql title=Query theme={null}
SELECT midpoint(toTime64('12:00:00', 0), toTime64('14:00:00', 0)) AS result, toTypeName(result) AS type;
```

```response title=Response theme={null}
┌───result─┬─type──────┐
│ 13:00:00 │ Time64(0) │
└──────────┴───────────┘
```

<div id="min2">
  ## min2
</div>

Добавленный в: v21.11.0

Возвращает меньшее из двух числовых значений `x` и `y`.

**Синтаксис**

```sql theme={null}
min2(x, y)
```

**Аргументы**

* `x` — Первое значение [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float), или [`Decimal`](/ru/reference/data-types/decimal)
* `y` — Второе значение [`(U)Int8/16/32/64`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float), или [`Decimal`](/ru/reference/data-types/decimal)

**Возвращаемое значение**

Возвращает меньшее из значений `x` и `y`. [`Float64`](/ru/reference/data-types/float)

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT min2(-1, 2)
```

```response title=Response theme={null}
-1
```

<div id="minus">
  ## minus
</div>

Добавленный в: v1.1.0

Вычисляет разность двух значений `a` и `b`. Результат всегда знаковый.
Как и в случае с plus, из значения типа дата или дата и время можно вычитать целое число.
Кроме того, поддерживается вычитание между значениями типа дата и время, в результате которого получается разница во времени между ними.

**Синтаксис**

```sql theme={null}
minus(x, y)
```

**Аргументы**

* `x` — Уменьшаемое. - `y` — Вычитаемое.

**Возвращаемое значение**

Разность x и y

**Примеры**

**Вычитание двух чисел**

```sql title=Query theme={null}
SELECT minus(10, 5)
```

```response title=Response theme={null}
5
```

**Вычитание целого числа из даты**

```sql title=Query theme={null}
SELECT minus(toDate('2025-01-01'),5)
```

```response title=Response theme={null}
2024-12-27
```

<div id="modulo">
  ## modulo
</div>

Добавленный в: v1.1.0

Вычисляет остаток от деления значения a на значение b.

Тип результата — целое число, если оба входных значения целые. Если одно из
входных значений — число с плавающей точкой, тип результата — Float64.

Остаток вычисляется так же, как в C++. Для
отрицательных чисел используется усечённое деление.

При делении на ноль или при делении минимального
отрицательного числа на минус единицу генерируется исключение.

**Синтаксис**

```sql theme={null}
modulo(a, b)
```

**Псевдонимы**: `mod`

**Аргументы**

* `a` — Делимое - `b` — Делитель (модуль)

**Возвращаемое значение**

Остаток от деления `a` на `b`

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT modulo(5, 2)
```

```response title=Response theme={null}
1
```

<div id="moduloLegacy">
  ## moduloLegacy
</div>

Добавленный в: v1.1.0

Вычисляет остаток от деления. Это устаревшая реализация modulo, использующая оператор `%` из C++, который может возвращать отрицательные результаты для отрицательных аргументов. Эта функция существует для обратной совместимости со старой логикой партиционирования таблиц. Для стандартного поведения используйте `modulo` или `positiveModulo`.

**Синтаксис**

```sql theme={null}
moduloLegacy(a, b)
```

**Аргументы**

* `a` — Делимое. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `b` — Делитель. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

Возвращает остаток от деления. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

**Примеры**

**Базовое использование**

```sql title=Query theme={null}
SELECT moduloLegacy(10, 3)
```

```response title=Response theme={null}
1
```

<div id="moduloOrNull">
  ## moduloOrNull
</div>

Добавленный в: v25.5.0

Вычисляет остаток при делении `a` на `b`. Аналогична функции `modulo`, но `moduloOrNull` возвращает NULL,
если правый аргумент равен 0.

**Синтаксис**

```sql theme={null}
moduloOrNull(x, y)
```

**Псевдонимы**: `modOrNull`

**Аргументы**

* `x` — Делимое. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `y` — Делитель (модуль). [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

Возвращает остаток от деления `x` на `y` или `NULL`, если делитель равен нулю.

**Примеры**

**moduloOrNull при делении на ноль**

```sql title=Query theme={null}
SELECT moduloOrNull(5, 0)
```

```response title=Response theme={null}
\N
```

<div id="moduloOrZero">
  ## moduloOrZero
</div>

Добавленный в: v20.3.0

Как `modulo`, но возвращает ноль, если делитель равен нулю, вместо
исключения, которое возникает в функции `modulo`.

**Синтаксис**

```sql theme={null}
moduloOrZero(a, b)
```

**Аргументы**

* `a` — Делимое. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)
* `b` — Делитель (модуль). [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float)

**Возвращаемое значение**

Возвращает остаток от деления `a % b` или `0`, если делитель равен `0`.

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT moduloOrZero(5, 0)
```

```response title=Response theme={null}
0
```

<div id="multiply">
  ## multiply
</div>

Добавленный в: v1.1.0

Вычисляет произведение двух значений `x` и `y`.

**Синтаксис**

```sql theme={null}
multiply(x, y)
```

**Аргументы**

* `x` — множитель. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal)
* `y` — множитель. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal)

**Возвращаемое значение**

Возвращает произведение `x` и `y`

**Примеры**

**Умножение двух чисел**

```sql title=Query theme={null}
SELECT multiply(5,5)
```

```response title=Response theme={null}
25
```

<div id="multiplyDecimal">
  ## multiplyDecimal
</div>

Добавленный в: v22.12.0

Выполняет умножение двух десятичных чисел. Результирующее значение будет иметь тип [Decimal256](/ru/reference/data-types/decimal).
Масштаб результата можно явно задать аргументом `result_scale` (константный Integer в диапазоне `[0, 76]`). Если он не указан, масштаб результата будет равен максимальному масштабу переданных аргументов.

<Note>
  Эти функции работают значительно медленнее, чем обычная `multiply`.
  Если вам не нужна контролируемая точность и/или важна высокая скорость вычислений, рассмотрите использование [multiply](#multiply)
</Note>

**Синтаксис**

```sql theme={null}
multiplyDecimal(a, b[, result_scale])
```

**Аргументы**

* `a` — Первое значение. [`Decimal`](/ru/reference/data-types/decimal)
* `b` — Второе значение. [`Decimal`](/ru/reference/data-types/decimal)
* `result_scale` — Масштаб результата. [`(U)Int*`](/ru/reference/data-types/int-uint)

**Возвращаемое значение**

Результат умножения с указанным масштабом. Тип: [`Decimal256`](/ru/reference/data-types/decimal)

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)
```

```response title=Response theme={null}
25.2
```

**Отличие от обычного умножения**

```sql title=Query theme={null}
SELECT multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)
```

```response title=Response theme={null}
┌─multiply(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4))─┐
│                                               -26.8609633 │
└───────────────────────────────────────────────────────────┘
┌─multiplyDecimal(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4))─┐
│                                                         -26.8609 │
└──────────────────────────────────────────────────────────────────┘
```

**Переполнение типа Decimal**

```sql title=Query theme={null}
SELECT
    toDecimal64(-12.647987876, 9) AS a,
    toDecimal64(123.967645643, 9) AS b,
    multiplyDecimal(a, b);
SELECT
    toDecimal64(-12.647987876, 9) AS a,
    toDecimal64(123.967645643, 9) AS b,
    a * b;
```

```response title=Response theme={null}
┌─────────────a─┬─────────────b─┬─multiplyDecimal(toDecimal64(-12.647987876, 9), toDecimal64(123.967645643, 9))─┐
│ -12.647987876 │ 123.967645643 │                                                               -1567.941279108 │
└───────────────┴───────────────┴───────────────────────────────────────────────────────────────────────────────┘
Получено исключение от сервера (версия 22.11.1):
Code: 407. DB::Exception: Received from localhost:9000. DB::Exception: Decimal math overflow:
While processing toDecimal64(-12.647987876, 9) AS a, toDecimal64(123.967645643, 9) AS b, a * b. (DECIMAL_OVERFLOW)
```

<div id="negate">
  ## negate
</div>

Добавленный в: v1.1.0

Меняет знак аргумента `x` на противоположный. Результат всегда знаковый.

**Синтаксис**

```sql theme={null}
negate(x)
```

**Аргументы**

* `x` — Значение, знак которого нужно изменить на противоположный.

**Возвращаемое значение**

Возвращает -x для значения x

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT negate(10)
```

```response title=Response theme={null}
-10
```

<div id="plus">
  ## plus
</div>

Добавленный в: v1.1.0

Вычисляет сумму двух значений `x` и `y`. Псевдоним: `x + y` (оператор).
Можно складывать целое число и дату или дату и время. В первом случае
увеличивается число дней в дате, во втором —
число секунд в дате и времени.
Также можно складывать дату и время. При сложении `Date` и `Time`
получается `DateTime`. При сложении `Date` и `Time64`, а также `Date32` и
`Time` или `Time64`, получается `DateTime64`.

**Синтаксис**

```sql theme={null}
plus(x, y)
```

**Аргументы**

* `x` — Левый операнд. - `y` — Правый операнд.

**Возвращаемое значение**

Возвращает сумму `x` и `y`

**Примеры**

**Сложение двух чисел**

```sql title=Query theme={null}
SELECT plus(5,5)
```

```response title=Response theme={null}
10
```

**Прибавление целого числа к дате**

```sql title=Query theme={null}
SELECT plus(toDate('2025-01-01'),5)
```

```response title=Response theme={null}
2025-01-06
```

**Добавление даты и времени**

```sql title=Query theme={null}
SELECT toDate('2025-01-01') + CAST('14:30:25', 'Time')
```

```response title=Response theme={null}
2025-01-01 14:30:25
```

<div id="positiveModulo">
  ## positiveModulo
</div>

Добавленный в: v22.11.0

Вычисляет остаток от деления `x` на `y`. Аналогична функции
`modulo`, но `positiveModulo` всегда возвращает неотрицательное число.

**Синтаксис**

```sql theme={null}
positiveModulo(x, y)
```

**Псевдонимы**: `positive_modulo`, `pmod`

**Аргументы**

* `x` — Делимое. [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal)
* `y` — Делитель (модуль). [`(U)Int*`](/ru/reference/data-types/int-uint) или [`Float*`](/ru/reference/data-types/float) или [`Decimal`](/ru/reference/data-types/decimal)

**Возвращаемое значение**

Возвращает разность между `x` и ближайшим к нему целым числом, которое не превышает
`x` и делится на `y`.

**Примеры**

**Пример использования**

```sql title=Query theme={null}
SELECT positiveModulo(-1, 10)
```

```response title=Response theme={null}
9
```

<div id="positiveModuloOrNull">
  ## positiveModuloOrNull
</div>

Добавленный в: v25.5.0

Вычисляет остаток от деления `a` на `b`. Аналогична функции `positiveModulo`, но `positiveModuloOrNull` возвращает NULL,
если правый аргумент равен 0.

**Синтаксис**

```sql theme={null}
positiveModuloOrNull(x, y)
```

**Псевдонимы**: `positive_modulo_or_null`, `pmodOrNull`

**Аргументы**

* `x` — Делимое. [`(U)Int*`](/ru/reference/data-types/int-uint)/[`Float32/64`](/ru/reference/data-types/float). - `y` — Делитель (модуль). [`(U)Int*`](/ru/reference/data-types/int-uint)/[`Float32/64`](/ru/reference/data-types/float).

**Возвращаемое значение**

Возвращает разность между `x` и ближайшим целым числом, не превышающим
`x` и кратным `y`; `null`, если делитель равен нулю.

**Примеры**

**positiveModuloOrNull**

```sql title=Query theme={null}
SELECT positiveModuloOrNull(5, 0)
```

```response title=Response theme={null}
\N
```