> ## 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.
> Documentación sobre funciones aritméticas
# Funciones aritméticas
Descripción general
Las funciones aritméticas se aplican a cualquier par de operandos de tipo `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Int8`, `Int16`, `Int32`, `Int64`, `Float32` o `Float64`.
Antes de realizar la operación, ambos operandos se convierten al tipo de resultado. El tipo de resultado se determina de la siguiente manera (a menos que se especifique
lo contrario en la documentación de la función que aparece a continuación):
* Si ambos operandos tienen hasta 32 bits, el tamaño del tipo de resultado será el del siguiente tipo de mayor tamaño después del mayor de los
dos operandos (promoción de tamaño de enteros). Por ejemplo, `UInt8 + UInt16 = UInt32` o `Float32 * Float32 = Float64`.
* Si uno de los operandos tiene 64 bits o más, el tamaño del tipo de resultado será el mismo que el del mayor de los dos operandos. Por
ejemplo, `UInt32 + UInt128 = UInt128` o `Float32 * Float64 = Float64`.
* Si uno de los operandos es con signo, el tipo de resultado también será con signo; en caso contrario, será sin signo. Por ejemplo, `UInt32 * Int32 = Int64` o `UInt32 * UInt32 = UInt64`.
Estas reglas garantizan que el tipo de resultado será el tipo más pequeño capaz de representar todos los resultados posibles. Aunque esto introduce un riesgo
de desbordamiento cerca de los límites del rango de valores, garantiza que los cálculos se realicen rápidamente utilizando el ancho nativo máximo de enteros de
64 bits. Este comportamiento también garantiza la compatibilidad con muchas otras bases de datos que ofrecen enteros de 64 bits (BIGINT) como el mayor
tipo entero.
Ejemplo:
```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 │
└───────────────┴────────────────────────┴─────────────────────────────────┴──────────────────────────────────────────┘
```
Los desbordamientos se producen de la misma forma que en C++.
## abs
Introducido en: v1.1.0
Calcula el valor absoluto de `x`. No tiene efecto si `x` es de tipo sin signo. Si `x` es de tipo con signo, devuelve un número sin signo.
**Sintaxis**
```sql theme={null}
abs(x)
```
**Argumentos**
* `x` — Valor del que se obtiene el valor absoluto
**Valor devuelto**
El valor absoluto de `x`
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT abs(-0.5)
```
```response title=Response theme={null}
0.5
```
## avg2
Introducido en: v25.11.0
Calcula y devuelve el valor medio de los argumentos proporcionados.
Admite tipos numéricos y temporales.
**Sintaxis**
```sql theme={null}
avg2(x1, x2])
```
**Argumentos**
* `x1, x2]` — Acepta dos valores para promediarlos.
**Valor devuelto**
Devuelve el valor medio de los argumentos proporcionados, expresado en el tipo compatible de mayor tamaño.
**Ejemplos**
**Tipos numéricos**
```sql title=Query theme={null}
SELECT avg2(toUInt8(3), 1.0) AS result, toTypeName(result) AS type;
-- El tipo devuelto es Float64 ya que el UInt8 debe promoverse a 64 bits para la comparación.
```
```response title=Response theme={null}
┌─result─┬─type────┐
│ 2 │ Float64 │
└────────┴─────────┘
```
**Tipos decimales**
```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) │
└────────┴───────────────┘
```
**Tipos de dato Date**
```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 │
└────────────┴──────┘
```
**Tipos de 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 │
└─────────────────────┴──────────┘
```
**Tipos 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) │
└──────────┴───────────┘
```
## byteSwap
Introducido en: v23.10.0
Invierte los bytes de un entero, es decir, cambia su [endianness](https://en.wikipedia.org/wiki/Endianness).
El ejemplo siguiente puede desglosarse de la siguiente manera:
1. Convierta el entero en base 10 a su formato hexadecimal equivalente en orden big-endian; es decir, 3351772109 -> C7 C7 FB CD (4 bytes)
2. Invierta los bytes; es decir, C7 C7 FB CD -> CD FB C7 C7
3. Convierta el resultado de nuevo en un entero asumiendo el orden big-endian; es decir, CD FB C7 C7 -> 3455829959
Un caso de uso de esta función es invertir direcciones IPv4:
```result theme={null}
┌─toIPv4(byteSwap(toUInt32(toIPv4('205.251.199.199'))))─┐
│ 199.199.251.205 │
└───────────────────────────────────────────────────────┘
```
**Sintaxis**
```sql theme={null}
byteSwap(x)
```
**Argumentos**
* `x` — Un valor entero. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve `x` con los bytes en orden inverso. [`(U)Int*`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT byteSwap(3351772109)
```
```response title=Response theme={null}
3455829959
```
**8 bits**
```sql title=Query theme={null}
SELECT byteSwap(54)
```
```response title=Response theme={null}
54
```
**16 bits**
```sql title=Query theme={null}
SELECT byteSwap(4135)
```
```response title=Response theme={null}
10000
```
**32 bits**
```sql title=Query theme={null}
SELECT byteSwap(3351772109)
```
```response title=Response theme={null}
3455829959
```
**64 bits**
```sql title=Query theme={null}
SELECT byteSwap(123294967295)
```
```response title=Response theme={null}
18439412204227788800
```
## divide
Introducido en: v1.1.0
Calcula el cociente de dos valores, `a` y `b`. El tipo de resultado siempre es [Float64](/es/reference/data-types/float).
La función `intDiv` proporciona la división entera.
La división por `0` devuelve `inf`, `-inf` o `nan`.
**Sintaxis**
```sql theme={null}
divide(x, y)
```
**Argumentos**
* `x` — Dividendo - `y` — Divisor
**Valor devuelto**
El cociente de x entre y
**Ejemplos**
**División de dos números**
```sql title=Query theme={null}
SELECT divide(25,5) AS quotient, toTypeName(quotient)
```
```response title=Response theme={null}
5 Float64
```
**División por cero**
```sql title=Query theme={null}
SELECT divide(25,0)
```
```response title=Response theme={null}
inf
```
## divideDecimal
Introducido en: v22.12.0
Realiza la división de dos números decimales. El valor resultante será de tipo [Decimal256](/es/reference/data-types/decimal).
La escala del resultado puede especificarse explícitamente mediante el argumento `result_scale` (un Integer constante en el rango `[0, 76]`). Si no se especifica, la escala del resultado será la escala máxima de los argumentos proporcionados.
Esta función es significativamente más lenta que `divide`.
Si realmente no necesita precisión controlada y/o necesita un cálculo rápido, considere usar [divide](#divide).
**Sintaxis**
```sql theme={null}
divideDecimal(x, y[, result_scale])
```
**Argumentos**
* `x` — Primer valor: [Decimal](/es/reference/data-types/decimal). - `y` — Segundo valor: [Decimal](/es/reference/data-types/decimal). - `result_scale` — Escala del resultado. Tipo [Int/UInt](/es/reference/data-types/int-uint).
**Valor devuelto**
El resultado de la división con la escala especificada. [`Decimal256`](/es/reference/data-types/decimal)
**Ejemplos**
**Ejemplo 1**
```sql title=Query theme={null}
SELECT 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 │
└──────────────────────────────────────────────────────────────┘
```
**Ejemplo 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(a, b, 1)─┬─divideDecimal(a, b, 5)─┐
│ -12 │ 2.1 │ -5.7 │ -5.71428 │
└─────┴─────┴────────────────────────┴────────────────────────┘
```
## divideOrNull
Introducido en: v25.5.0
Igual que `divide`, pero devuelve NULL cuando se divide entre cero.
**Sintaxis**
```sql theme={null}
divideOrNull(x, y)
```
**Argumentos**
* `x` — Dividendo - `y` — Divisor
**Valor devuelto**
El cociente de x entre y, o NULL.
**Ejemplos**
**División entre cero**
```sql title=Query theme={null}
SELECT divideOrNull(25, 0)
```
```response title=Response theme={null}
\N
```
## gcd
Introducido en: v1.1.0
Devuelve el máximo común divisor de dos valores, a y b.
Se produce una excepción al dividir por cero o al dividir el número negativo
mínimo entre menos uno.
**Sintaxis**
```sql theme={null}
gcd(x, y)
```
**Argumentos**
* `x` — Primer número entero - `y` — Segundo número entero
**Valor devuelto**
El máximo común divisor de `x` y `y`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT gcd(12, 18)
```
```response title=Response theme={null}
6
```
## ifNotFinite
Introducido en: v20.3.0
Comprueba si un valor de punto flotante es finito.
Puede obtener un resultado similar utilizando el [operador ternario](/es/reference/functions/regular-functions/conditional-functions#if): `isFinite(x) ? x : y`.
**Sintaxis**
```sql theme={null}
ifNotFinite(x,y)
```
**Argumentos**
* `x` — Valor que se comprueba para ver si es infinito. [`Float*`](/es/reference/data-types/float)
* `y` — Valor alternativo. [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
* `x` si `x` es finito.
* `y` si `x` no es finito.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT 1/0 AS infimum, ifNotFinite(infimum,42)
```
```response title=Response theme={null}
inf 42
```
## intDiv
Introducido en: v1.1.0
Realiza una división entera de dos valores, `x` entre `y`. En otras palabras,
calcula el cociente redondeado hacia abajo al entero inferior más próximo.
El resultado tiene el mismo tamaño que el dividendo (el primer parámetro).
Se lanza una excepción al dividir por cero, cuando el cociente no cabe
en el rango del dividendo o al dividir el número negativo mínimo entre menos uno.
**Sintaxis**
```sql theme={null}
intDiv(x, y)
```
**Argumentos**
* `x` — Operando izquierdo. - `y` — Operando derecho.
**Valor devuelto**
Resultado de la división entera entre `x` e `y`
**Ejemplos**
**División entera de dos números de punto flotante**
```sql title=Query theme={null}
SELECT intDiv(toFloat64(1), 0.001) AS res, toTypeName(res)
```
```response title=Response theme={null}
┌──res─┬─toTypeName(res)─┐
│ 1000 │ Int64 │
└──────┴─────────────────┘
```
**El cociente no está dentro del rango del dividendo**
```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)
```
## intDivOrNull
Introducido en: v25.5.0
Igual que `intDiv`, pero devuelve NULL al dividir por cero o al dividir el
número negativo mínimo entre menos uno.
**Sintaxis**
```sql theme={null}
intDivOrNull(x, y)
```
**Argumentos**
* `x` — Operando izquierdo. [`(U)Int*`](/es/reference/data-types/int-uint)
* `y` — Operando derecho. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Resultado de la división entera de `x` e `y`, o NULL.
**Ejemplos**
**División entera entre cero**
```sql title=Query theme={null}
SELECT intDivOrNull(1, 0)
```
```response title=Response theme={null}
\N
```
**División del número negativo mínimo entre -1**
```sql title=Query theme={null}
SELECT intDivOrNull(-9223372036854775808, -1)
```
```response title=Response theme={null}
\N
```
## intDivOrZero
Introducido en: v1.1.0
Igual que `intDiv`, pero devuelve cero al dividir por cero o al dividir el
número negativo mínimo entre menos uno.
**Sintaxis**
```sql theme={null}
intDivOrZero(a, b)
```
**Argumentos**
* `a` — Operando izquierdo. [`(U)Int*`](/es/reference/data-types/int-uint)
* `b` — Operando derecho. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Resultado de la división entera de a entre b, o cero.
**Ejemplos**
**División entera por cero**
```sql title=Query theme={null}
SELECT intDivOrZero(1, 0)
```
```response title=Response theme={null}
0
```
**Dividir el número negativo mínimo entre -1**
```sql title=Query theme={null}
SELECT intDivOrZero(0.05, -1)
```
```response title=Response theme={null}
0
```
## isFinite
Introducido en: v1.1.0
Devuelve `1` si el argumento Float32 o Float64, o BFloat16 no es infinito ni es `NaN`;
de lo contrario, esta función devuelve `0`.
**Sintaxis**
```sql theme={null}
isFinite(x)
```
**Argumentos**
* `x` — Número cuya finitud se comprueba. [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float)
**Valor devuelto**
`1` si x no es infinito ni `NaN`; en caso contrario, `0`.
**Ejemplos**
**Comprobar si un número es finito**
```sql title=Query theme={null}
SELECT isFinite(inf)
```
```response title=Response theme={null}
0
```
## isInfinite
Introducido en: v1.1.0
Devuelve `1` si el argumento de tipo Float32 o Float64, o BFloat16 es infinito; en caso contrario, esta función devuelve `0`.
Tenga en cuenta que también se devuelve `0` para un `NaN`.
**Sintaxis**
```sql theme={null}
isInfinite(x)
```
**Argumentos**
* `x` — Número que se comprueba para determinar si es infinito. [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float)
**Valor devuelto**
`1` si x es infinito; de lo contrario, `0` (también para `NaN`).
**Ejemplos**
**Comprobar si un número es infinito**
```sql title=Query theme={null}
SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10)
```
```response title=Response theme={null}
1 0 0
```
## isNaN
Introducido en: v1.1.0
Devuelve `1` si el argumento de tipo Float32 o Float64, o BFloat16, es `NaN`; de lo contrario, devuelve `0`.
**Sintaxis**
```sql theme={null}
isNaN(x)
```
**Argumentos**
* `x` — Argumento que se evalúa para determinar si es `NaN`. [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float)
**Valor devuelto**
`1` si es `NaN`; de lo contrario, `0`
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT isNaN(NaN)
```
```response title=Response theme={null}
1
```
## kqlBin
Introducido en: v26.8.0
Redondea un valor hacia abajo hasta un múltiplo de `roundTo`, como lo hace `bin()` de Kusto Query Language.
La regla depende de los tipos de los argumentos: un número se redondea aritméticamente, un intervalo de tiempo (que
es un `Interval`) se redondea a un intervalo de tiempo y un DateTime se redondea a un intervalo de tiempo. Un DateTime de KQL
es un `DateTime64`; los tipos portadores más restringidos, `DateTime` y `Date`, se rechazan porque
no pueden representar todos los bins que puede producir un DateTime de KQL.
Esta función implementa `bin()` cuando `dialect = 'kusto'`. No está pensada para invocarse directamente
desde SQL.
**Sintaxis**
```sql theme={null}
kqlBin(value, roundTo)
```
**Argumentos**
* `value` — Un número, un intervalo de tiempo o un DateTime (un `DateTime64`). - `roundTo` — El tamaño del bin.
**Valor devuelto**
`value` redondeado hacia abajo al múltiplo de `roundTo` más cercano.
**Ejemplos**
**número**
```sql title=Query theme={null}
SELECT kqlBin(4.5, 1)
```
```response title=Response theme={null}
4
```
**intervalo de tiempo**
```sql title=Query theme={null}
SELECT kqlBin(toIntervalNanosecond(16 * 86400000000000), toIntervalNanosecond(7 * 86400000000000))
```
```response title=Response theme={null}
1209600000000000
```
**DateTime**
```sql title=Query theme={null}
SELECT kqlBin(toDateTime64('2026-08-01 12:34:56', 7, 'UTC'), toIntervalHour(1))
```
```response title=Response theme={null}
2026-08-01 12:00:00.0000000
```
## kqlBinAt
Disponible desde: v26.8.0
Redondea un valor hacia abajo hasta un múltiplo de `binSize` contado desde `fixedPoint`, como hace
`bin_at()` de Kusto Query Language. Los bins pueden alinearse antes o después del punto fijo.
La regla depende de los tipos de los argumentos: un número se redondea aritméticamente; un intervalo de tiempo (que
es un `Interval`) se redondea mediante un intervalo de tiempo respecto a otro intervalo de tiempo, y un DateTime se redondea mediante un
intervalo de tiempo contado desde un punto fijo de DateTime. Un DateTime de KQL es un `DateTime64`; los tipos más restringidos
`DateTime` y `Date` se rechazan, ya que no pueden representar todos los bins que puede
producir un DateTime de KQL.
Esta función implementa `bin_at()` cuando `dialect = 'kusto'`. No está pensada para llamarse directamente
desde SQL.
**Sintaxis**
```sql theme={null}
kqlBinAt(value, binSize, fixedPoint)
```
**Argumentos**
* `value` — Un número, un intervalo de tiempo o un DateTime (un `DateTime64`). - `binSize` — El tamaño del intervalo. - `fixedPoint` — El punto a partir del cual se cuentan los intervalos.
**Valor devuelto**
`value` redondeado hacia abajo al múltiplo de `binSize` más cercano, a partir de `fixedPoint`.
**Ejemplos**
**número**
```sql title=Query theme={null}
SELECT kqlBinAt(6.5, 2.5, -0.5)
```
```response title=Response theme={null}
4.5
```
**DateTime**
```sql title=Query theme={null}
SELECT kqlBinAt(toDateTime64('2026-08-01 12:34:56', 7, 'UTC'), toIntervalHour(1), toDateTime64('2026-08-01 00:30:00', 7, 'UTC'))
```
```response title=Response theme={null}
2026-08-01 12:30:00.0000000
```
## kqlDateTimeBinAt
Introducido en: v26.8.0
Redondea un DateTime hacia abajo al múltiplo de intervalo de tiempo contado desde un punto fijo DateTime.
**Sintaxis**
```sql theme={null}
kqlDateTimeBinAt(value, binSize, fixedPoint)
```
**Argumentos**
* `value` — El DateTime que se redondeará. - `binSize` — El tamaño del intervalo de tiempo. - `fixedPoint` — El punto fijo de DateTime.
**Valor devuelto**
El DateTime redondeado.
**Ejemplos**
## kqlDivide
Introducido en: v26.8.0
División tal como la define Kusto Query Language: dos operandos enteros dan como resultado un entero,
por lo que `7 / 2` es `3`, y dos operandos intervalo de tiempo (que son valores `Interval`) dan como resultado
su cociente de valor real, por lo que `15ms / 10ms` es `1.5`. Cualquier otra combinación de tipos de operandos se divide
como [`divide`](#divide).
Esta función implementa el operador `/` cuando `dialect = 'kusto'`. No está pensada para invocarse
directamente desde SQL.
**Sintaxis**
```sql theme={null}
kqlDivide(x, y)
```
**Argumentos**
* `x` — El dividendo. - `y` — El divisor.
**Valor devuelto**
`intDiv(x, y)` si ambos argumentos son enteros; la razón entre los ticks de los intervalos si ambos son intervalos; `divide(x, y)` en caso contrario.
**Ejemplos**
**enteros**
```sql title=Query theme={null}
SELECT kqlDivide(7, 2)
```
```response title=Response theme={null}
3
```
**reales**
```sql title=Query theme={null}
SELECT kqlDivide(7.0, 2)
```
```response title=Response theme={null}
3.5
```
**intervalos de tiempo**
```sql title=Query theme={null}
SELECT kqlDivide(toIntervalNanosecond(15000000), toIntervalNanosecond(10000000))
```
```response title=Response theme={null}
1.5
```
## kqlMultiply
Introducido en: v26.8.0
Multiplicación tal como la define Kusto Query Language: un intervalo de tiempo (un `Interval`) se multiplica por un número a cualquiera de los lados, por lo que `2 * 1h` equivale a dos horas. Dos argumentos sin un intervalo se multiplican como lo hace [`multiply`](#multiply).
Esta función implementa el operador `*` cuando `dialect = 'kusto'`. No está pensada para invocarse directamente desde SQL.
**Sintaxis**
```sql theme={null}
kqlMultiply(x, y)
```
**Argumentos**
* `x` — Un número o un intervalo de tiempo. - `y` — Un número o un intervalo de tiempo si `x` es un número.
**Valor devuelto**
El producto; un intervalo del mismo tipo cuando alguno de los argumentos lo es.
**Ejemplos**
**intervalo de tiempo**
```sql title=Query theme={null}
SELECT kqlMultiply(2, toIntervalNanosecond(3600000000000))
```
```response title=Response theme={null}
7200000000000
```
**números**
```sql title=Query theme={null}
SELECT kqlMultiply(6, 7)
```
```response title=Response theme={null}
42
```
## kqlRangeCount
Introducida en: v26.8.0
El número de filas que genera la fuente `range` de Kusto Query Language: `floor((to - from)
/ step) + 1`, y nunca inferior a cero. Los límites y el paso pueden ser números, valores de fecha y hora
incrementados mediante un intervalo de tiempo (un `Interval`) o intervalos de tiempo; las formas temporales se cuentan en
nanosegundos enteros, algo que no puede expresarse con una única división de ClickHouse. Los enteros y los decimales se cuentan
de forma exacta, no mediante `Float64`.
Esta función respalda la fuente `range` cuando `dialect = 'kusto'`. No está diseñada para invocarse
directamente desde SQL.
**Sintaxis**
```sql theme={null}
kqlRangeCount(from, to, step)
```
**Argumentos**
* `from` — El primer valor del rango. - `to` — El valor que el rango no supera. - `step` — La diferencia entre dos valores consecutivos.
**Valor devuelto**
El número de valores del rango.
**Ejemplos**
**numbers**
```sql title=Query theme={null}
SELECT kqlRangeCount(1, 7, 2)
```
```response title=Response theme={null}
4
```
**datetimes**
```sql title=Query theme={null}
SELECT kqlRangeCount(toDateTime64('2026-08-01 00:00:00', 7, 'UTC'), toDateTime64('2026-08-01 12:00:00', 7, 'UTC'), toIntervalHour(5))
```
```response title=Response theme={null}
3
```
## lcm
Introducido en: v1.1.0
Devuelve el mínimo común múltiplo de dos valores `x` e `y`.
Se produce una excepción al dividir por cero o al dividir el número negativo mínimo entre menos uno.
**Sintaxis**
```sql theme={null}
lcm(x, y)
```
**Argumentos**
* `x` — Primer entero. [`(U)Int*`](/es/reference/data-types/int-uint)
* `y` — Segundo entero. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve el mínimo común múltiplo de `x` e `y`. [`(U)Int*`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT lcm(6, 8)
```
```response title=Response theme={null}
24
```
## max2
Introducida en: v21.11.0
Devuelve el valor mayor de dos valores numéricos `x` e `y`.
**Sintaxis**
```sql theme={null}
max2(x, y)
```
**Argumentos**
* `x` — Primer valor [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `y` — Segundo valor [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve el mayor de los valores `x` e `y`. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT max2(-1, 2)
```
```response title=Response theme={null}
2
```
## midpoint
Introducido en: v25.11.0
Calcula y devuelve el valor medio de los argumentos proporcionados.
Admite tipos numéricos y temporales.
**Sintaxis**
```sql theme={null}
midpoint(x1[, x2, ...])
```
**Argumentos**
* `x1[, x2, ...]` — Acepta un solo valor o varios para calcular el promedio.
**Valor devuelto**
Devuelve el valor medio de los argumentos proporcionados, convertido al tipo compatible de mayor tamaño.
**Ejemplos**
**Tipos numéricos**
```sql title=Query theme={null}
SELECT midpoint(1, toUInt8(3), 0.5) AS result, toTypeName(result) AS type;
-- El tipo devuelto es Float64 ya que el UInt8 debe promoverse a 64 bits para la comparación.
```
```response title=Response theme={null}
┌─result─┬─type────┐
│ 1.5 │ Float64 │
└────────┴─────────┘
```
**Tipos decimales**
```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) │
└────────┴───────────────┘
```
**Tipos de Date**
```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 │
└────────────┴──────┘
```
**Tipos de 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 │
└─────────────────────┴──────────┘
```
**Tipos de 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) │
└──────────┴───────────┘
```
## min2
Introducido en: v21.11.0
Devuelve el más pequeño de dos valores numéricos, `x` e `y`.
**Sintaxis**
```sql theme={null}
min2(x, y)
```
**Argumentos**
* `x` — Primer valor [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `y` — Segundo valor [`(U)Int8/16/32/64`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`BFloat16`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve el menor valor entre `x` e `y`. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT min2(-1, 2)
```
```response title=Response theme={null}
-1
```
## minus
Introducido en: v1.1.0
Calcula la diferencia entre dos valores, `a` y `b`. El resultado siempre tiene signo.
Al igual que con plus, es posible restar un entero de una fecha o de una fecha con hora.
Además, se admite la resta entre fechas con hora, lo que da como resultado la diferencia de tiempo entre ambas.
También es posible restar un `Time` o `Time64` de un `DateTime` o `DateTime64`;
el valor de tiempo se aplica como un desplazamiento en segundos. `DateTime` menos `Time` produce
un `DateTime`; cualquier combinación que incluya `DateTime64` o `Time64` produce un `DateTime64`
con la escala máxima de los dos argumentos.
**Sintaxis**
```sql theme={null}
minus(x, y)
```
**Argumentos**
* `x` — Minuendo. - `y` — Sustraendo.
**Valor devuelto**
x menos y
**Ejemplos**
**Resta de dos números**
```sql title=Query theme={null}
SELECT minus(10, 5)
```
```response title=Response theme={null}
5
```
**Resta entre un entero y una fecha**
```sql title=Query theme={null}
SELECT minus(toDate('2025-01-01'),5)
```
```response title=Response theme={null}
2024-12-27
```
## modulo
Introducido en: v1.1.0
Calcula el resto de la división de dos valores, a entre b.
El tipo de resultado es un entero si ambas entradas son enteras. Si una de las
entradas es un número de coma flotante, el tipo de resultado es Float64.
El resto se calcula igual que en C++. Para los números negativos, se usa la
división truncada.
Se genera una excepción al dividir por cero o al dividir el número negativo
mínimo entre menos uno.
**Sintaxis**
```sql theme={null}
modulo(a, b)
```
**Alias**: `mod`
**Argumentos**
* `a` — El dividendo - `b` — El divisor (módulo)
**Valor devuelto**
El resto de a % b
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT modulo(5, 2)
```
```response title=Response theme={null}
1
```
## moduloLegacy
Introducido en: v1.1.0
Calcula el resto de una división. Esta es la implementación heredada de módulo que usa el operador `%` de C++, que puede producir resultados negativos con argumentos negativos. Esta función existe por compatibilidad retroactiva con la lógica antigua de particionado de tablas. Utilice `modulo` o `positiveModulo` para el comportamiento estándar.
**Sintaxis**
```sql theme={null}
moduloLegacy(a, b)
```
**Argumentos**
* `a` — El dividendo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `b` — El divisor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve el resto de la división. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT moduloLegacy(10, 3)
```
```response title=Response theme={null}
1
```
## moduloOrNull
Introducido en: v25.5.0
Calcula el resto de dividir `a` entre `b`. Es similar a la función `modulo`, excepto que `moduloOrNull` devuelve `NULL`
cuando, de otro modo, la operación produciría una excepción de coma flotante. En el caso de argumentos de coma flotante, esto ocurre solo cuando el
divisor es `0`; para argumentos enteros, además cubre el caso del valor negativo mínimo módulo `-1` (por ejemplo, `-128 % -1` para `Int8`).
**Sintaxis**
```sql theme={null}
moduloOrNull(x, y)
```
**Alias**: `modOrNull`
**Argumentos**
* `x` — El dividendo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `y` — El divisor (módulo). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve el resto de la división de `x` entre `y`, o `NULL` cuando la operación produciría una excepción de coma flotante:
cuando el divisor es cero o, en el caso de argumentos enteros, al calcular el valor negativo mínimo módulo `-1`.
**Ejemplos**
**moduloOrNull con cero**
```sql title=Query theme={null}
SELECT moduloOrNull(5, 0)
```
```response title=Response theme={null}
\N
```
**moduloOrNull del entero negativo mínimo con -1**
```sql title=Query theme={null}
SELECT moduloOrNull(toInt8(-128), toInt8(-1))
```
```response title=Response theme={null}
\N
```
## moduloOrZero
Introducido en: v20.3.0
Como `modulo`, pero devuelve cero en lugar de una excepción para resultados enteros cuando la operación generaría una
excepción. Para resultados de coma flotante, un divisor cero produce `NaN`.
**Sintaxis**
```sql theme={null}
moduloOrZero(a, b)
```
**Argumentos**
* `a` — El dividendo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `b` — El divisor (módulo). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve el resto de `a % b`. Para resultados enteros, devuelve `0` en los casos en que la operación generaría una excepción.
Para resultados de coma flotante, un divisor cero produce `NaN`.
**Ejemplos**
**Divisor cero entero**
```sql title=Query theme={null}
SELECT moduloOrZero(5, 0)
```
```response title=Response theme={null}
0
```
**Divisor cero de coma flotante**
```sql title=Query theme={null}
SELECT moduloOrZero(toFloat64(5), toFloat64(0))
```
```response title=Response theme={null}
nan
```
## multiply
Introducido en: v1.1.0
Calcula el producto de dos valores `x` y `y`.
**Sintaxis**
```sql theme={null}
multiply(x, y)
```
**Argumentos**
* `x` — factor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `y` — factor. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve el producto de x e y
**Ejemplos**
**Multiplicación de dos números**
```sql title=Query theme={null}
SELECT multiply(5,5)
```
```response title=Response theme={null}
25
```
## multiplyDecimal
Introducido en: v22.12.0
Realiza la multiplicación de dos valores decimales. El valor resultante será de tipo [Decimal256](/es/reference/data-types/decimal).
La escala del resultado puede especificarse explícitamente mediante el argumento `result_scale` (Integer constante en el rango `[0, 76]`). Si no se especifica, la escala del resultado será la escala máxima de los argumentos proporcionados.
Estas funciones son considerablemente más lentas que `multiply`.
Si realmente no necesita precisión controlada o necesita un cálculo rápido, considere usar [multiply](#multiply)
**Sintaxis**
```sql theme={null}
multiplyDecimal(a, b[, result_scale])
```
**Argumentos**
* `a` — Primer valor. [`Decimal`](/es/reference/data-types/decimal)
* `b` — Segundo valor. [`Decimal`](/es/reference/data-types/decimal)
* `result_scale` — Escala del resultado. [`(U)Int*`](/es/reference/data-types/int-uint)
**Valor devuelto**
El resultado de la multiplicación con la escala indicada. Tipo: [`Decimal256`](/es/reference/data-types/decimal)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)
```
```response title=Response theme={null}
25.2
```
**Diferencia con la multiplicación normal**
```sql title=Query theme={null}
SELECT multiply(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4));
SELECT multiplyDecimal(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4));
```
```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 │
└──────────────────────────────────────────────────────────────────┘
```
**Sin desbordamiento con multiplyDecimal**
```sql title=Query theme={null}
SELECT
toDecimal64(-12.647987876, 9) AS a,
toDecimal64(123.967645643, 9) AS b,
multiplyDecimal(a, b);
```
```response title=Response theme={null}
┌─────────────a─┬─────────────b─┬─multiplyDecimal(a, b)─┐
│ -12.647987876 │ 123.967645643 │ -1567.941279108 │
└───────────────┴───────────────┴───────────────────────┘
```
**Desbordamiento del tipo Decimal con la multiplicación normal**
```sql title=Query theme={null}
SELECT
toDecimal64(-12.647987876, 9) AS a,
toDecimal64(123.967645643, 9) AS b,
a * b;
```
```response title=Response theme={null}
Received exception:
Code: 407. DB::Exception: Decimal math overflow. (DECIMAL_OVERFLOW)
```
## negate
Introducido en: v1.1.0
Devuelve el valor negado del argumento `x`. El resultado siempre es con signo.
**Sintaxis**
```sql theme={null}
negate(x)
```
**Argumentos**
* `x` — El valor que se va a negar.
**Valor devuelto**
Devuelve -x de x
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT negate(10)
```
```response title=Response theme={null}
-10
```
## plus
Introducido en: v1.1.0
Calcula la suma de dos valores `x` e `y`. Alias: `x + y` (operador).
Es posible sumar un entero y una fecha o una fecha con hora. La primera
operación aumenta el número de días de la fecha; la segunda
aumenta el número de segundos de la fecha con hora.
También es posible sumar una fecha y una hora. Sumar un `Date` y un `Time`
produce un `DateTime`. Sumar un `Date` y un `Time64`, o un `Date32` y
un `Time` o `Time64`, produce un `DateTime64`.
Sumar un `Time` o `Time64` a un `DateTime` o `DateTime64` aplica el valor de tiempo
como un desplazamiento en segundos. `DateTime` más `Time` produce un `DateTime`;
cualquier combinación que incluya `DateTime64` o `Time64` produce un `DateTime64`
con la escala máxima de los dos argumentos.
**Sintaxis**
```sql theme={null}
plus(x, y)
```
**Argumentos**
* `x` — operando izquierdo. - `y` — operando derecho.
**Valor devuelto**
Devuelve la suma de x e y
**Ejemplos**
**Suma de dos números**
```sql title=Query theme={null}
SELECT plus(5,5)
```
```response title=Response theme={null}
10
```
**Sumar un entero a una fecha**
```sql title=Query theme={null}
SELECT plus(toDate('2025-01-01'),5)
```
```response title=Response theme={null}
2025-01-06
```
**Agregar fecha y hora**
```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
```
## positiveModulo
Introducido en: v22.11.0
Calcula el resto de dividir `x` entre `y`. Es similar a la función
`modulo`, salvo que `positiveModulo` siempre devuelve un número no negativo.
**Sintaxis**
```sql theme={null}
positiveModulo(x, y)
```
**Alias**: `positive_modulo`, `pmod`
**Argumentos**
* `x` — El dividendo. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
* `y` — El divisor (módulo). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve la diferencia entre `x` y el entero más cercano, no mayor que
`x`, que sea divisible por `y`.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT positiveModulo(-1, 10)
```
```response title=Response theme={null}
9
```
## positiveModuloOrNull
Introducido en: v25.5.0
Calcula el resto de dividir `a` entre `b`. Es similar a la función `positiveModulo`, salvo que `positiveModuloOrNull` devuelve `NULL`
cuando la operación provocaría de otro modo una excepción de coma flotante. En el caso de argumentos de coma flotante, esto solo ocurre cuando el
divisor es `0`; para argumentos enteros, además cubre el valor negativo mínimo módulo `-1` (por ejemplo, `-128 % -1` para `Int8`).
**Sintaxis**
```sql theme={null}
positiveModuloOrNull(x, y)
```
**Alias**: `positive_modulo_or_null`, `pmodOrNull`
**Argumentos**
* `x` — El dividendo. [`(U)Int*`](/es/reference/data-types/int-uint)/[`Float32/64`](/es/reference/data-types/float). - `y` — El divisor (módulo). [`(U)Int*`](/es/reference/data-types/int-uint)/[`Float32/64`](/es/reference/data-types/float).
**Valor devuelto**
Devuelve la diferencia entre `x` y el entero más cercano, no mayor que
`x`, divisible por `y`, o `NULL` cuando la operación produciría una excepción de coma flotante: cuando el divisor es cero o,
para argumentos enteros, al calcular el valor negativo mínimo módulo `-1`.
**Ejemplos**
**positiveModuloOrNull con cero**
```sql title=Query theme={null}
SELECT positiveModuloOrNull(5, 0)
```
```response title=Response theme={null}
\N
```
**positiveModuloOrNull del entero negativo mínimo dividido entre -1**
```sql title=Query theme={null}
SELECT positiveModuloOrNull(toInt8(-128), toInt8(-1))
```
```response title=Response theme={null}
\N
```
## sqr
Introducido en: v26.7.0
Calcula el cuadrado de un valor `x`.
**Sintaxis**
```sql theme={null}
sqr(x)
```
**Argumentos**
* `x` — Valor que se elevará al cuadrado. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve el producto de `x` por sí mismo.
**Ejemplos**
**Elevar al cuadrado un número**
```sql title=Query theme={null}
SELECT sqr(5)
```
```response title=Response theme={null}
25
```