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

> Documentation sur les fonctions arithmétiques

# Fonctions arithmétiques

<div id="overview">
  ## Vue d'ensemble
</div>

Les fonctions arithmétiques s’appliquent à deux opérandes quelconques de type `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Int8`, `Int16`, `Int32`, `Int64`, `Float32` ou `Float64`.

Avant d’effectuer l’opération, les deux opérandes sont convertis dans le type de résultat. Le type de résultat est déterminé comme suit (sauf indication contraire
dans la documentation de la fonction ci-dessous) :

* Si les deux opérandes font au plus 32 bits, la taille du type de résultat sera celle du type immédiatement supérieur au plus grand des deux
  opérandes (promotion de la taille des entiers). Par exemple, `UInt8 + UInt16 = UInt32` ou `Float32 * Float32 = Float64`.
* Si l’un des opérandes fait 64 bits ou plus, la taille du type de résultat sera la même que celle du plus grand des deux opérandes. Par
  exemple, `UInt32 + UInt128 = UInt128` ou `Float32 * Float64 = Float64`.
* Si l’un des opérandes est signé, le type de résultat le sera aussi, sinon il sera non signé. Par exemple, `UInt32 * Int32 = Int64` ou `UInt32 * UInt32 = UInt64`.

Ces règles garantissent que le type de résultat sera le plus petit type capable de représenter tous les résultats possibles. Bien que cela introduise un risque
de débordement aux limites de la plage de valeurs, cela permet d’effectuer rapidement les calculs en utilisant la largeur native maximale des entiers, soit
64 bits. Ce comportement garantit également la compatibilité avec de nombreuses autres bases de données qui proposent des entiers sur 64 bits (BIGINT) comme plus grand
type entier.

Exemple :

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

Les dépassements de capacité se produisent de la même manière qu'en C++.

{/*AUTOGENERATED_START*/}

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

Introduit dans : v1.1.0

Calcule la valeur absolue de `x`. N’a aucun effet si `x` est de type non signé. Si `x` est de type signé, renvoie un nombre non signé.

**Syntaxe**

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

**Arguments**

* `x` — Valeur dont on veut obtenir la valeur absolue

**Valeur renvoyée**

La valeur absolue de `x`

**Exemples**

**Exemple d’utilisation**

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

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

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

Introduit dans : v25.11.0

Calcule et renvoie la moyenne des arguments fournis.
Prend en charge les types numériques et temporels.

**Syntaxe**

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

**Arguments**

* `x1, x2]` — Accepte deux valeurs pour en calculer la moyenne.

**Valeur renvoyée**

Renvoie la moyenne des arguments fournis, promue vers le type compatible le plus large.

**Exemples**

**Types numériques**

```sql title=Query theme={null}
SELECT avg2(toUInt8(3), 1.0) AS result, toTypeName(result) AS type;
-- The type returned is a Float64 as the UInt8 must be promoted to 64 bit for the comparison.
```

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

**Types décimaux**

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

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

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

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

Introduit dans : v23.10.0

Inverse les octets d’un entier, c.-à-d. modifie son [ordre des octets](https://en.wikipedia.org/wiki/Endianness).

L’exemple ci-dessous peut être décomposé comme suit :

1. Convertissez l’entier en base 10 dans son équivalent au format hexadécimal en big-endian, c.-à-d. 3351772109 -> C7 C7 FB CD (4 octets)
2. Inversez les octets, c.-à-d. C7 C7 FB CD -> CD FB C7 C7
3. Reconvertissez le résultat en entier en supposant un format big-endian, c.-à-d. CD FB C7 C7 -> 3455829959
   Un cas d’utilisation de cette fonction est l’inversion des adresses IPv4 :

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

**Syntaxe**

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

**Arguments**

* `x` — Un nombre entier. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie `x` avec l’ordre des octets inversé. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d'utilisation**

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

Introduit dans : v1.1.0

Calcule le quotient de deux valeurs `a` et `b`. Le type de résultat est toujours [Float64](/fr/reference/data-types/float).
La division entière est assurée par la fonction `intDiv`.

<Note>
  La division par `0` renvoie `inf`, `-inf` ou `nan`.
</Note>

**Syntaxe**

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

**Arguments**

* `x` — Dividende - `y` — Diviseur

**Valeur renvoyée**

Le quotient de x par y

**Exemples**

**Division de deux nombres**

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

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

**Division par zéro**

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

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

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

Introduit dans : v22.12.0

Effectue la division de deux valeurs décimales. La valeur résultante sera de type [Decimal256](/fr/reference/data-types/decimal).
L’échelle du résultat peut être explicitement spécifiée à l’aide de l’argument `result_scale` (const Integer dans l’intervalle `[0, 76]`). Si elle n’est pas spécifiée, l’échelle du résultat correspond à l’échelle maximale des arguments fournis.

<Note>
  Cette fonction est nettement plus lente que `divide`.
  Si vous n’avez pas réellement besoin d’une précision contrôlée et/ou d’un calcul rapide, envisagez d’utiliser [divide](#divide).
</Note>

**Syntaxe**

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

**Arguments**

* `x` — Première valeur : [Decimal](/fr/reference/data-types/decimal). - `y` — Deuxième valeur : [Decimal](/fr/reference/data-types/decimal). - `result_scale` — Échelle du résultat. Type [Int/UInt](/fr/reference/data-types/int-uint).

**Valeur renvoyée**

Le résultat de la division avec l’échelle indiquée. [`Decimal256`](/fr/reference/data-types/decimal)

**Exemples**

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

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

Introduit dans : v25.5.0

Identique à `divide`, mais renvoie NULL en cas de division par zéro.

**Syntaxe**

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

**Arguments**

* `x` — Dividende - `y` — Diviseur

**Valeur renvoyée**

Le quotient de x par y, ou NULL.

**Exemples**

**Division par zéro**

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

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

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

Introduit dans : v1.1.0

Renvoie le plus grand commun diviseur de deux valeurs, a et b.

Une exception est levée en cas de division par zéro ou lorsqu'un nombre négatif minimal est divisé par moins un.

**Syntaxe**

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

**Arguments**

* `x` — Premier entier - `y` — Deuxième entier

**Valeur renvoyée**

Le plus grand diviseur commun de `x` et `y`.

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v20.3.0

Vérifie si une valeur en virgule flottante est finie.

Vous pouvez obtenir un résultat similaire en utilisant l’[opérateur ternaire](/fr/reference/functions/regular-functions/conditional-functions#if) : `isFinite(x) ? x : y`.

**Syntaxe**

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

**Arguments**

* `x` — Valeur dont il faut vérifier si elle est infinie. [`Float*`](/fr/reference/data-types/float)
* `y` — Valeur de repli. [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

* `x` si `x` est une valeur finie.
* `y` si `x` n'est pas une valeur finie.

**Exemples**

**Exemple d'utilisation**

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

Introduit dans : v1.1.0

Effectue une division entière de `x` par `y`. En d'autres termes, cette fonction
calcule le quotient arrondi à l'entier inférieur.

Le résultat a la même largeur que le dividende (le premier paramètre).

Une exception est levée en cas de division par zéro, lorsque le quotient ne tient pas
dans la plage de valeurs du dividende, ou lors de la division du plus petit nombre négatif par moins un.

**Syntaxe**

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

**Arguments**

* `x` — Opérande de gauche. - `y` — Opérande de droite.

**Valeur renvoyée**

Résultat de la division entière de `x` par `y`

**Exemples**

**Division entière de deux nombres flottants**

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

**Le quotient n’est pas compris dans l’intervalle du dividende**

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

Introduit dans : v25.5.0

Identique à `intDiv`, mais renvoie NULL en cas de division par zéro ou lors de la division du plus petit nombre négatif par moins un.

**Syntaxe**

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

**Arguments**

* `x` — Opérande de gauche. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `y` — Opérande de droite. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Résultat de la division entière de `x` par `y`, ou NULL.

**Exemples**

**Division entière par zéro**

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

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

**Division du nombre négatif minimal par -1**

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

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

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

Introduit dans : v1.1.0

Identique à `intDiv`, mais renvoie zéro en cas de division par zéro ou lors de la division du plus petit nombre négatif par moins un.

**Syntaxe**

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

**Arguments**

* `a` — Opérande de gauche. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `b` — Opérande de droite. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Résultat de la division entière de a par b, ou zéro.

**Exemples**

**Division entière par zéro**

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

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

**Division du nombre négatif minimal par -1**

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

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

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

Introduit dans : v1.1.0

Renvoie `1` si l’argument Float32, Float64 ou BFloat16 n’est ni infini ni `NaN`,
sinon cette fonction renvoie `0`.

**Syntaxe**

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

**Arguments**

* `x` — Nombre dont il faut vérifier s’il est fini. [`Float*`](/fr/reference/data-types/float) ou [`BFloat16`](/fr/reference/data-types/float)

**Valeur renvoyée**

`1` si x n’est ni infini ni `NaN`, sinon `0`.

**Exemples**

**Tester si un nombre est fini**

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

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

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

Introduit dans : v1.1.0

Renvoie `1` si l’argument de type Float32, Float64 ou BFloat16 est infini ; sinon, cette fonction renvoie `0`.
Notez que `0` est également renvoyé pour un `NaN`.

**Syntaxe**

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

**Arguments**

* `x` — Nombre dont il faut vérifier s’il est infini. [`Float*`](/fr/reference/data-types/float) ou [`BFloat16`](/fr/reference/data-types/float)

**Valeur renvoyée**

`1` si x est infini, sinon `0` (y compris pour `NaN`).

**Exemples**

**Vérifier si un nombre est infini**

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

Introduit dans : v1.1.0

Renvoie `1` si l’argument de type Float32, Float64 ou BFloat16 est `NaN`, sinon `0`.

**Syntaxe**

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

**Arguments**

* `x` — Argument à évaluer pour vérifier s’il est `NaN`. [`Float*`](/fr/reference/data-types/float) ou [`BFloat16`](/fr/reference/data-types/float)

**Valeur renvoyée**

`1` si `NaN`, sinon `0`

**Exemples**

**Exemple d’utilisation**

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

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

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

Introduit dans : v1.1.0

Renvoie le plus petit multiple commun de deux valeurs `x` et `y`.

Une exception est levée en cas de division par zéro ou lors de la division du plus petit nombre négatif par moins un.

**Syntaxe**

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

**Arguments**

* `x` — Premier entier. [`(U)Int*`](/fr/reference/data-types/int-uint)
* `y` — Deuxième entier. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Renvoie le plus petit commun multiple de `x` et `y`. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Exemples**

**Exemple d’utilisation**

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

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

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

Introduit dans : v21.11.0

Renvoie la plus grande des deux valeurs numériques `x` et `y`.

**Syntaxe**

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

**Arguments**

* `x` — Première valeur [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint), [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `y` — Deuxième valeur [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint), [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)

**Valeur renvoyée**

Renvoie la plus grande des deux valeurs `x` et `y`. [`Float64`](/fr/reference/data-types/float)

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v25.11.0

Calcule et renvoie la valeur moyenne des arguments fournis.
Prend en charge les types numériques et temporels.

**Syntaxe**

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

**Arguments**

* `x1[, x2, ...]` — Accepte une valeur unique ou plusieurs valeurs pour en calculer la moyenne.

**Valeur renvoyée**

Renvoie la valeur moyenne des arguments fournis, promue au plus grand type compatible.

**Exemples**

**Types numériques**

```sql title=Query theme={null}
SELECT midpoint(1, toUInt8(3), 0.5) AS result, toTypeName(result) AS type;
-- The type returned is a Float64 as the UInt8 must be promoted to 64 bit for the comparison.
```

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

**Types décimaux**

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

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

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

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

Introduit dans : v21.11.0

Renvoie la plus petite de deux valeurs numériques `x` et `y`.

**Syntaxe**

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

**Arguments**

* `x` — Première valeur [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `y` — Deuxième valeur [`(U)Int8/16/32/64`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)

**Valeur renvoyée**

Renvoie la plus petite des valeurs `x` et `y`. [`Float64`](/fr/reference/data-types/float)

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v1.1.0

Calcule la différence entre deux valeurs `a` et `b`. Le résultat est toujours signé.
Comme avec plus, il est possible de soustraire un entier à une date ou à une date avec heure.
En outre, la soustraction entre des dates avec heure est prise en charge, ce qui produit la différence de temps entre elles.

**Syntaxe**

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

**Arguments**

* `x` — Diminuende. - `y` — Soustrahende.

**Valeur renvoyée**

x moins y

**Exemples**

**Soustraction de deux nombres**

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

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

**Soustraction entre un entier et une date**

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

Introduit dans : v1.1.0

Calcule le reste de la division de deux valeurs a par b.

Le type du résultat est un entier si les deux entrées sont des entiers. Si l'une des
entrées est un nombre à virgule flottante, le type du résultat est Float64.

Le reste est calculé comme en C++. Une division tronquée est utilisée pour les
nombres négatifs.

Une exception est levée en cas de division par zéro ou lors de la division d'un nombre négatif
minimal par moins un.

**Syntaxe**

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

**Alias** : `mod`

**Arguments**

* `a` — Le dividende - `b` — Le diviseur (modulo)

**Valeur renvoyée**

Le reste de a % b

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v1.1.0

Calcule le reste d’une division. Il s’agit de l’implémentation legacy du modulo qui utilise l’opérateur `%` de C++, ce qui peut produire des résultats négatifs lorsque les arguments sont négatifs. Cette fonction existe pour assurer la rétrocompatibilité avec l’ancienne logique de partitionnement des tables. Utilisez `modulo` ou `positiveModulo` pour obtenir le comportement standard.

**Syntaxe**

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

**Arguments**

* `a` — Le dividende. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `b` — Le diviseur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le reste de la division. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Exemples**

**Utilisation de base**

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

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

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

Introduit dans : v25.5.0

Calcule le reste de la division de `a` par `b`. Comme la fonction `modulo`, sauf que `moduloOrNull` renvoie NULL
si l'argument de droite est 0.

**Syntaxe**

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

**Alias** : `modOrNull`

**Arguments**

* `x` — Le dividende. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `y` — Le diviseur (modulo). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le reste de la division de `x` par `y`, ou `NULL` si le diviseur est égal à zéro.

**Exemples**

**moduloOrNull avec zéro**

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

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

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

Introduit dans : v20.3.0

Comme modulo, mais renvoie zéro lorsque le diviseur vaut zéro, au lieu de lever une
exception avec la fonction modulo.

**Syntaxe**

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

**Arguments**

* `a` — Le dividende. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `b` — Le diviseur (modulo). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)

**Valeur renvoyée**

Renvoie le reste de `a % b`, ou `0` lorsque le diviseur est `0`.

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v1.1.0

Calcule le produit des deux valeurs `x` et `y`.

**Syntaxe**

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

**Arguments**

* `x` — facteur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `y` — facteur. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)

**Valeur de retour**

Renvoie le produit de x et y

**Exemples**

**Multiplier deux nombres**

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

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

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

Introduit dans : v22.12.0

Effectue la multiplication de deux nombres décimaux. La valeur de résultat est de type [Decimal256](/fr/reference/data-types/decimal).
La scale du résultat peut être spécifiée explicitement à l’aide de l’argument `result_scale` (constante entière dans l’intervalle `[0, 76]`). Si elle n’est pas spécifiée, la scale du résultat correspond à la scale maximale des arguments fournis.

<Note>
  Ces fonctions sont nettement plus lentes que `multiply`.
  Si vous n’avez pas réellement besoin d’une précision contrôlée et/ou d’un calcul rapide, envisagez d’utiliser [multiply](#multiply)
</Note>

**Syntaxe**

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

**Arguments**

* `a` — Première valeur. [`Decimal`](/fr/reference/data-types/decimal)
* `b` — Deuxième valeur. [`Decimal`](/fr/reference/data-types/decimal)
* `result_scale` — Échelle du résultat. [`(U)Int*`](/fr/reference/data-types/int-uint)

**Valeur renvoyée**

Résultat de la multiplication avec l’échelle indiquée. Type : [`Decimal256`](/fr/reference/data-types/decimal)

**Exemples**

**Exemple d’utilisation**

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

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

**Différence avec la multiplication standard**

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

**Dépassement de capacité du type 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>

Introduit dans : v1.1.0

Retourne l’opposé de l’argument `x`. Le résultat est toujours de type signé.

**Syntaxe**

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

**Arguments**

* `x` — La valeur à opposer.

**Valeur renvoyée**

Renvoie -x pour x

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v1.1.0

Calcule la somme de deux valeurs `x` et `y`. Alias : `x + y` (opérateur).
Il est possible d’additionner un entier et une date ou une date avec heure. La première
opération incrémente le nombre de jours de la date, la seconde
incrémente le nombre de secondes de la date avec heure.
Il est également possible d’additionner une date et une heure. L’addition d’un `Date` et d’un `Time`
produit un `DateTime`. L’addition d’un `Date` et d’un `Time64`, ou d’un `Date32` et
d’un `Time` ou `Time64`, produit un `DateTime64`.

**Syntaxe**

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

**Arguments**

* `x` — Opérande de gauche. - `y` — Opérande de droite.

**Valeur renvoyée**

Renvoie la somme de x et y

**Exemples**

**Addition de deux nombres**

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

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

**Addition d’un entier et d’une Date**

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

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

**Ajouter une date et une heure**

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

Introduit dans : v22.11.0

Calcule le reste de la division de `x` par `y`. Comme la fonction
`modulo`, à ceci près que `positiveModulo` renvoie toujours un nombre non négatif.

**Syntaxe**

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

**Alias** : `positive_modulo`, `pmod`

**Arguments**

* `x` — Le dividende. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
* `y` — Le diviseur (modulo). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)

**Valeur renvoyée**

Renvoie la différence entre `x` et le plus grand entier inférieur ou égal à
`x` divisible par `y`.

**Exemples**

**Exemple d'utilisation**

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

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

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

Introduit dans : v25.5.0

Calcule le reste de la division de `a` par `b`. Similaire à la fonction `positiveModulo`, à ceci près que `positiveModuloOrNull` renvoie NULL
si l'argument de droite est 0.

**Syntaxe**

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

**Alias** : `positive_modulo_or_null`, `pmodOrNull`

**Arguments**

* `x` — Le dividende. [`(U)Int*`](/fr/reference/data-types/int-uint)/[`Float32/64`](/fr/reference/data-types/float). - `y` — Le diviseur (modulo). [`(U)Int*`](/fr/reference/data-types/int-uint)/[`Float32/64`](/fr/reference/data-types/float).

**Valeur renvoyée**

Renvoie la différence entre `x` et le plus grand entier inférieur ou égal à
`x` divisible par `y`, `null` si le diviseur est égal à zéro.

**Exemples**

**positiveModuloOrNull**

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

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