> ## 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.
> Documentation sur les fonctions arithmétiques
# Fonctions arithmétiques
Vue d'ensemble
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++.
## abs
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
```
## avg2
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) │
└──────────┴───────────┘
```
## byteSwap
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
```
## divide
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`.
La division par `0` renvoie `inf`, `-inf` ou `nan`.
**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
```
## divideDecimal
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.
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).
**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}
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 │
└──────────────────────────────────────────────────────────────┘
```
**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(a, b, 1)─┬─divideDecimal(a, b, 5)─┐
│ -12 │ 2.1 │ -5.7 │ -5.71428 │
└─────┴─────┴────────────────────────┴────────────────────────┘
```
## divideOrNull
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
```
## gcd
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 plus petit nombre négatif 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
```
## ifNotFinite
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
```
## intDiv
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(res)─┐
│ 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)
```
## intDivOrNull
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
```
## intDivOrZero
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
```
## isFinite
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
```
## isInfinite
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
```
## isNaN
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
```
## kqlBin
Introduced in: v26.8.0
Arrondit une valeur à l'inférieur, vers un multiple de `roundTo`, comme le fait `bin()` en Kusto Query Language.
La règle dépend des types des arguments : un nombre est arrondi arithmétiquement, une durée (qui
est un `Interval`) est arrondie selon une durée, et une date-heure est arrondie selon une durée. Un date-heure
KQL est un `DateTime64` ; les porteurs plus étroits `DateTime` et `Date` sont rejetés, car
ils ne peuvent pas représenter tous les bins qu'un date-heure KQL peut produire.
Cette fonction sous-tend `bin()` lorsque `dialect = 'kusto'`. Elle n'est pas destinée à être appelée directement
depuis SQL.
**Syntax**
```sql theme={null}
kqlBin(value, roundTo)
```
**Arguments**
* `value` — Un nombre, une durée ou une date-heure (un `DateTime64`). - `roundTo` — La taille du bin.
**Valeur renvoyée**
`value` arrondi à l'inférieur au multiple de `roundTo` le plus proche.
**Exemples**
**number**
```sql title=Query theme={null}
SELECT kqlBin(4.5, 1)
```
```response title=Response theme={null}
4
```
**durée**
```sql title=Query theme={null}
SELECT kqlBin(toIntervalNanosecond(16 * 86400000000000), toIntervalNanosecond(7 * 86400000000000))
```
```response title=Response theme={null}
1209600000000000
```
**date-heure**
```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
Introduit dans : v26.8.0
Arrondit une valeur à l'inférieur, au multiple de `binSize` le plus proche compté à partir de `fixedPoint`, comme le fait la fonction `bin_at()` du Kusto Query Language. Les bins peuvent s'aligner avant ou après le point de référence.
La règle dépend des types d'arguments : un nombre est arrondi arithmétiquement, une durée (qui est un `Interval`) est arrondie par une durée à partir d'une durée, et une date-heure est arrondie par une durée comptée à partir d'un point de référence de type date-heure. Une date-heure KQL est un `DateTime64` ; les types porteurs plus restreints `DateTime` et `Date` sont rejetés, car ils ne peuvent pas représenter tous les bins qu'une date-heure KQL peut produire.
Cette fonction implémente `bin_at()` lorsque `dialect = 'kusto'`. Elle n'est pas destinée à être appelée directement depuis SQL.
**Syntaxe**
```sql theme={null}
kqlBinAt(value, binSize, fixedPoint)
```
**Arguments**
* `value` — Un nombre, une durée ou une date-heure (un `DateTime64`). - `binSize` — La taille du bin. - `fixedPoint` — Le point à partir duquel les bins sont comptés.
**Valeur renvoyée**
`value` arrondi vers le bas au multiple de `binSize` le plus proche, compté à partir de `fixedPoint`.
**Exemples**
**number**
```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
Introduit dans : v26.8.0
Arrondit une valeur date-heure à l'inférieur, sur un multiple d'une durée calculé à partir d'un point de référence date-heure.
**Syntaxe**
```sql theme={null}
kqlDateTimeBinAt(value, binSize, fixedPoint)
```
**Arguments**
* `value` — La date-heure à arrondir. - `binSize` — La taille du bin de durée. - `fixedPoint` — Le point de référence de date-heure.
**Valeur renvoyée**
La date-heure arrondie.
**Exemples**
## kqlDivide
Introduced in: v26.8.0
La division telle que la définit le Kusto Query Language : deux opérandes entiers donnent un entier,
donc `7 / 2` vaut `3`, tandis que deux opérandes de type durée (qui sont des valeurs `Interval`) donnent leur
ratio réel, donc `15ms / 10ms` vaut `1.5`. Toute autre combinaison de types d'opérandes est divisée
comme avec [`divide`](#divide).
Cette fonction sous-tend l'opérateur `/` lorsque `dialect = 'kusto'`. Elle n'est pas destinée à être appelée
directement depuis SQL.
**Syntaxe**
```sql theme={null}
kqlDivide(x, y)
```
**Arguments**
* `x` — Le dividende. - `y` — Le diviseur.
**Valeur renvoyée**
`intDiv(x, y)` lorsque les deux arguments sont des integers, le rapport des ticks des intervalles lorsque les deux sont des intervalles, `divide(x, y)` dans les autres cas.
**Exemples**
**integers**
```sql title=Query theme={null}
SELECT kqlDivide(7, 2)
```
```response title=Response theme={null}
3
```
**réels**
```sql title=Query theme={null}
SELECT kqlDivide(7.0, 2)
```
```response title=Response theme={null}
3.5
```
**durées**
```sql title=Query theme={null}
SELECT kqlDivide(toIntervalNanosecond(15000000), toIntervalNanosecond(10000000))
```
```response title=Response theme={null}
1.5
```
## kqlMultiply
Introduced in: v26.8.0
La multiplication telle que définie par le Kusto Query Language : une durée (un `Interval`) est mise à l'échelle par un
nombre placé de part et d'autre, si bien que `2 * 1h` vaut deux heures. Deux arguments sans intervalle se multiplient comme
avec [`multiply`](#multiply).
Cette fonction sous-tend l'opérateur `*` lorsque `dialect = 'kusto'`. Elle n'est pas destinée à être appelée
directement depuis SQL.
**Syntaxe**
```sql theme={null}
kqlMultiply(x, y)
```
**Arguments**
* `x` — Un nombre ou une durée. - `y` — Un nombre, ou une durée lorsque `x` est un nombre.
**Valeur renvoyée**
Le produit ; un intervalle du même type si l'un des arguments en est un.
**Exemples**
**durée**
```sql title=Query theme={null}
SELECT kqlMultiply(2, toIntervalNanosecond(3600000000000))
```
```response title=Response theme={null}
7200000000000
```
**nombres**
```sql title=Query theme={null}
SELECT kqlMultiply(6, 7)
```
```response title=Response theme={null}
42
```
## kqlRangeCount
Introduced in: v26.8.0
Le nombre de rows produites par la source `range` du Kusto Query Language : `floor((to - from)
/ step) + 1`, sans jamais être inférieur à zéro. Les limites et le step sont des nombres, ou des datetimes
espacés d'une durée (un `Interval`), ou encore des durées ; les formes temporelles sont comptées en
nanosecondes entières, ce qu'aucune division ClickHouse unique ne permet d'exprimer. Les integers et les
decimals sont comptés de façon exacte, et non via `Float64`.
Cette fonction sous-tend la source `range` lorsque `dialect = 'kusto'`. Elle n'est pas destinée à être appelée
directement depuis SQL.
**Syntaxe**
```sql theme={null}
kqlRangeCount(from, to, step)
```
**Arguments**
* `from` — La première valeur de la plage. - `to` — La valeur que la plage ne dépasse pas. - `step` — L'écart entre deux valeurs consécutives.
**Valeur renvoyée**
Le nombre de valeurs dans la plage.
**Exemples**
**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
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
```
## max2
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), [`BFloat16`](/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), [`BFloat16`](/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
```
## midpoint
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) │
└──────────┴───────────┘
```
## min2
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 [`BFloat16`](/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 [`BFloat16`](/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
```
## minus
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 integer à 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.
Il est également possible de soustraire un `Time` ou un `Time64` d'un `DateTime` ou d'un `DateTime64` ;
la valeur temporelle est appliquée comme un décalage en secondes. `DateTime` moins `Time` produit
un `DateTime`, tandis que toute combinaison impliquant `DateTime64` ou `Time64` produit un `DateTime64`
avec la scale maximale des deux arguments.
**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 integer et une date**
```sql title=Query theme={null}
SELECT minus(toDate('2025-01-01'),5)
```
```response title=Response theme={null}
2024-12-27
```
## modulo
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
```
## moduloLegacy
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
```
## moduloOrNull
Introduit dans : v25.5.0
Calcule le reste de la division de `a` par `b`. Comme la fonction `modulo`, sauf que `moduloOrNull` renvoie `NULL`
lorsque l'opération lèverait sinon une exception en virgule flottante. Pour les arguments en virgule flottante, cela se produit uniquement lorsque le
diviseur est `0` ; pour les arguments entiers, cela couvre également la valeur négative minimale modulo `-1` (par ex. `-128 % -1` pour `Int8`).
**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` lorsque l'opération entraînerait une exception en virgule flottante :
lorsque le diviseur est égal à zéro, ou, pour des arguments entiers, lors du calcul de la valeur négative minimale modulo `-1`.
**Exemples**
**moduloOrNull avec zéro**
```sql title=Query theme={null}
SELECT moduloOrNull(5, 0)
```
```response title=Response theme={null}
\N
```
**moduloOrNull de l’entier négatif minimal par -1**
```sql title=Query theme={null}
SELECT moduloOrNull(toInt8(-128), toInt8(-1))
```
```response title=Response theme={null}
\N
```
## moduloOrZero
Introduit dans : v20.3.0
Comme modulo, mais renvoie zéro au lieu d'une exception pour les résultats integer lorsque l'opération lèverait
sinon une exception. Pour les résultats à virgule flottante, un diviseur nul produit `NaN`.
**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`. Pour les résultats integer, renvoie `0` là où l'opération lèverait normalement une exception.
Pour les résultats en virgule flottante, un diviseur nul produit `NaN`.
**Exemples**
**Diviseur entier nul**
```sql title=Query theme={null}
SELECT moduloOrZero(5, 0)
```
```response title=Response theme={null}
0
```
**Diviseur à virgule flottante nul**
```sql title=Query theme={null}
SELECT moduloOrZero(toFloat64(5), toFloat64(0))
```
```response title=Response theme={null}
nan
```
## multiply
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
```
## multiplyDecimal
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.
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)
**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 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 │
└──────────────────────────────────────────────────────────────────┘
```
**Pas de dépassement de capacité avec 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 │
└───────────────┴───────────────┴───────────────────────┘
```
**Dépassement de capacité du type Decimal avec la multiplication standard**
```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
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
```
## plus
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`.
L’ajout d’un `Time` ou d’un `Time64` à un `DateTime` ou un `DateTime64` applique la valeur
d’heure comme un décalage en secondes. `DateTime` plus `Time` produit un `DateTime`,
et toute combinaison impliquant `DateTime64` ou `Time64` produit un `DateTime64`
avec la scale maximale des deux arguments.
**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
```
## positiveModulo
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
```
## positiveModuloOrNull
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`
lorsque l'opération provoquerait autrement une exception en virgule flottante. Pour les arguments à virgule flottante, cela se produit uniquement lorsque le
diviseur est `0` ; pour les arguments entiers, cela couvre également la valeur négative minimale modulo `-1` (par exemple `-128 % -1` pour `Int8`).
**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`, ou `NULL` lorsque l’opération lèverait une exception en virgule flottante : lorsque le diviseur est égal à zéro ou,
pour les arguments entiers, lors du calcul de la valeur négative minimale modulo `-1`.
**Exemples**
**positiveModuloOrNull par zéro**
```sql title=Query theme={null}
SELECT positiveModuloOrNull(5, 0)
```
```response title=Response theme={null}
\N
```
**positiveModuloOrNull du plus petit entier négatif par -1**
```sql title=Query theme={null}
SELECT positiveModuloOrNull(toInt8(-128), toInt8(-1))
```
```response title=Response theme={null}
\N
```
## sqr
Introduit dans : v26.7.0
Calcule le carré d’une valeur `x`.
**Syntaxe**
```sql theme={null}
sqr(x)
```
**Arguments**
* `x` — Valeur à mettre au carré. [`(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 le produit de `x` par lui-même.
**Exemples**
**Mise au carré d’un nombre**
```sql title=Query theme={null}
SELECT sqr(5)
```
```response title=Response theme={null}
25
```