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

> Documentación sobre funciones aritméticas

# Funciones aritméticas

<div id="overview">
  ## Descripción general
</div>

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++.

{/*AUTOGENERATED_START*/}

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

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
```

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

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

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

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
```

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

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.

<Note>
  La división por `0` devuelve `inf`, `-inf` o `nan`.
</Note>

**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
```

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

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.

<Note>
  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).
</Note>

**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}
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(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>

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
```

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

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
```

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

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
```

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

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(intDiv(toFloat64(1), 0.001))─┐
│ 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)
```

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

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
```

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

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
```

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

Introducido en: v1.1.0

Devuelve `1` si el argumento Float32 o Float64 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)

**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
```

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

Introducido en: v1.1.0

Devuelve `1` si el argumento de tipo Float32 o Float64 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)

**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
```

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

Introducido en: v1.1.0

Devuelve `1` si el argumento de tipo Float32 o Float64 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)

**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
```

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

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
```

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

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 [`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 [`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
```

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

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

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

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 [`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 [`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
```

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

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.

**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
```

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

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
```

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

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
```

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

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
si el argumento de la derecha es 0.

**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 el divisor es cero.

**Ejemplos**

**moduloOrNull con cero**

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

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

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

Introducido en: v20.3.0

Como `modulo`, pero devuelve cero cuando el divisor es cero, en lugar de
generar una excepción con la función `modulo`.

**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, o `0` si el divisor es `0`.

**Ejemplos**

**Ejemplo de uso**

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

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

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

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
```

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

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.

<Note>
  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)
</Note>

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

**Desbordamiento del tipo 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 │
└───────────────┴───────────────┴───────────────────────────────────────────────────────────────────────────────┘
Received exception from server (version 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>

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
```

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

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`.

**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
```

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

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
```

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

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
si el argumento de la derecha es 0.

**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`; `null` cuando el divisor es cero.

**Ejemplos**

**positiveModuloOrNull**

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

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