Fonctions arithmétiques - ClickHouse Documentation

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 :

SELECT toTypeName(0), toTypeName(0 + 0), toTypeName(0 + 0 + 0), toTypeName(0 + 0 + 0 + 0)

┌─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

abs(x)

Arguments

x — Valeur dont on veut obtenir la valeur absolue

Valeur renvoyée La valeur absolue de x Exemples Exemple d’utilisation

Query

SELECT abs(-0.5)

Response

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

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

Query

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

┌─result─┬─type────┐
│      2 │ Float64 │
└────────┴─────────┘

Types décimaux

Query

SELECT avg2(toDecimal32(1, 2), 2) AS result, toTypeName(result) AS type;

Response

┌─result─┬─type──────────┐
│    1.5 │ Decimal(9, 2) │
└────────┴───────────────┘

Types Date

Query

SELECT avg2(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;

Response

┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘

Types DateTime

Query

SELECT avg2(toDateTime('2025-01-01 00:00:00'), toDateTime('2025-01-03 12:00:00')) AS result, toTypeName(result) AS type;

Response

┌──────────────result─┬─type─────┐
│ 2025-01-02 06:00:00 │ DateTime │
└─────────────────────┴──────────┘

Types Time64

Query

SELECT avg2(toTime64('12:00:00', 0), toTime64('14:00:00', 0)) AS result, toTypeName(result) AS type;

Response

┌───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. L’exemple ci-dessous peut être décomposé comme suit :

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)
Inversez les octets, c.-à-d. C7 C7 FB CD -> CD FB C7 C7
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 :

┌─toIPv4(byteSwap(toUInt32(toIPv4('205.251.199.199'))))─┐
│ 199.199.251.205                                       │
└───────────────────────────────────────────────────────┘

Syntaxe

byteSwap(x)

Arguments

x — Un nombre entier. (U)Int*

Valeur renvoyée Renvoie x avec l’ordre des octets inversé. (U)Int* Exemples Exemple d’utilisation

Query

SELECT byteSwap(3351772109)

Response

3455829959

8 bits

Query

SELECT byteSwap(54)

Response

16 bits

Query

SELECT byteSwap(4135)

Response

32 bits

Query

SELECT byteSwap(3351772109)

Response

3455829959

64 bits

Query

SELECT byteSwap(123294967295)

Response

18439412204227788800

divide

Introduit dans : v1.1.0 Calcule le quotient de deux valeurs a et b. Le type de résultat est toujours Float64. La division entière est assurée par la fonction intDiv.

La division par 0 renvoie inf, -inf ou nan.

Syntaxe

divide(x, y)

Arguments

x — Dividende - y — Diviseur

Valeur renvoyée Le quotient de x par y Exemples Division de deux nombres

Query

SELECT divide(25,5) AS quotient, toTypeName(quotient)

Response

5	Float64

Division par zéro

Query

SELECT divide(25,0)

Response

inf

divideDecimal

Introduit dans : v22.12.0 Effectue la division de deux valeurs décimales. La valeur résultante sera de type Decimal256. 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.

Syntaxe

divideDecimal(x, y[, result_scale])

Arguments

x — Première valeur : Decimal. - y — Deuxième valeur : Decimal. - result_scale — Échelle du résultat. Type Int/UInt.

Valeur renvoyée Le résultat de la division avec l’échelle indiquée. Decimal256 Exemples Exemple 1

Query

SELECT divideDecimal(toDecimal256(-12, 0), toDecimal32(2.1, 1), 10)

Response

┌─divideDecimal(toDecimal256(-12, 0), toDecimal32(2.1, 1), 10)─┐
│                                                -5.7142857142 │
└──────────────────────────────────────────────────────────────┘

Exemple 2

Query

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

┌─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

divideOrNull(x, y)

Arguments

x — Dividende - y — Diviseur

Valeur renvoyée Le quotient de x par y, ou NULL. Exemples Division par zéro

Query

SELECT divideOrNull(25, 0)

Response

\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

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

Query

SELECT gcd(12, 18)

Response

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 : isFinite(x) ? x : y. Syntaxe

ifNotFinite(x,y)

Arguments

x — Valeur dont il faut vérifier si elle est infinie. Float*
y — Valeur de repli. Float*

Valeur renvoyée

x si x est une valeur finie.
y si x n’est pas une valeur finie.

Exemples Exemple d’utilisation

Query

SELECT 1/0 AS infimum, ifNotFinite(infimum,42)

Response

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

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

Query

SELECT intDiv(toFloat64(1), 0.001) AS res, toTypeName(res)

Response

┌──res─┬─toTypeName(res)─┐
│ 1000 │ Int64           │
└──────┴─────────────────┘

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

Query

SELECT
intDiv(1, 0.001) AS res,
toTypeName(res)

Response

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

intDivOrNull(x, y)

Arguments

x — Opérande de gauche. (U)Int*
y — Opérande de droite. (U)Int*

Valeur renvoyée Résultat de la division entière de x par y, ou NULL. Exemples Division entière par zéro

Query

SELECT intDivOrNull(1, 0)

Response

\N

Division du nombre négatif minimal par -1

Query

SELECT intDivOrNull(-9223372036854775808, -1)

Response

\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

intDivOrZero(a, b)

Arguments

a — Opérande de gauche. (U)Int*
b — Opérande de droite. (U)Int*

Valeur renvoyée Résultat de la division entière de a par b, ou zéro. Exemples Division entière par zéro

Query

SELECT intDivOrZero(1, 0)

Response

Division du nombre négatif minimal par -1

Query

SELECT intDivOrZero(0.05, -1)

Response

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

isFinite(x)

Arguments

x — Nombre dont il faut vérifier s’il est fini. Float* ou BFloat16

Valeur renvoyée 1 si x n’est ni infini ni NaN, sinon 0. Exemples Tester si un nombre est fini

Query

SELECT isFinite(inf)

Response

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

isInfinite(x)

Arguments

x — Nombre dont il faut vérifier s’il est infini. Float* ou BFloat16

Valeur renvoyée 1 si x est infini, sinon 0 (y compris pour NaN). Exemples Vérifier si un nombre est infini

Query

SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10)

Response

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

isNaN(x)

Arguments

x — Argument à évaluer pour vérifier s’il est NaN. Float* ou BFloat16

Valeur renvoyée 1 si NaN, sinon 0 Exemples Exemple d’utilisation

Query

SELECT isNaN(NaN)

Response

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

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

Query

SELECT kqlBin(4.5, 1)

Response

durée

Query

SELECT kqlBin(toIntervalNanosecond(16 * 86400000000000), toIntervalNanosecond(7 * 86400000000000))

Response

1209600000000000

date-heure

Query

SELECT kqlBin(toDateTime64('2026-08-01 12:34:56', 7, 'UTC'), toIntervalHour(1))

Response

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

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

Query

SELECT kqlBinAt(6.5, 2.5, -0.5)

Response

4.5

datetime

Query

SELECT kqlBinAt(toDateTime64('2026-08-01 12:34:56', 7, 'UTC'), toIntervalHour(1), toDateTime64('2026-08-01 00:30:00', 7, 'UTC'))

Response

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

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. Cette fonction sous-tend l’opérateur / lorsque dialect = 'kusto'. Elle n’est pas destinée à être appelée directement depuis SQL. Syntaxe

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

Query

SELECT kqlDivide(7, 2)

Response

réels

Query

SELECT kqlDivide(7.0, 2)

Response

3.5

durées

Query

SELECT kqlDivide(toIntervalNanosecond(15000000), toIntervalNanosecond(10000000))

Response

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. Cette fonction sous-tend l’opérateur * lorsque dialect = 'kusto'. Elle n’est pas destinée à être appelée directement depuis SQL. Syntaxe

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

Query

SELECT kqlMultiply(2, toIntervalNanosecond(3600000000000))

Response

7200000000000

nombres

Query

SELECT kqlMultiply(6, 7)

Response

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

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

Query

SELECT kqlRangeCount(1, 7, 2)

Response

datetimes

Query

SELECT kqlRangeCount(toDateTime64('2026-08-01 00:00:00', 7, 'UTC'), toDateTime64('2026-08-01 12:00:00', 7, 'UTC'), toIntervalHour(5))

Response

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

lcm(x, y)

Arguments

x — Premier entier. (U)Int*
y — Deuxième entier. (U)Int*

Valeur renvoyée Renvoie le plus petit commun multiple de x et y. (U)Int* Exemples Exemple d’utilisation

Query

SELECT lcm(6, 8)

Response

max2

Introduit dans : v21.11.0 Renvoie la plus grande des deux valeurs numériques x et y. Syntaxe

max2(x, y)

Arguments

x — Première valeur (U)Int8/16/32/64, Float*, BFloat16 ou Decimal
y — Deuxième valeur (U)Int8/16/32/64, Float*, BFloat16 ou Decimal

Valeur renvoyée Renvoie la plus grande des deux valeurs x et y. Float64 Exemples Exemple d’utilisation

Query

SELECT max2(-1, 2)

Response

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

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

Query

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

┌─result─┬─type────┐
│    1.5 │ Float64 │
└────────┴─────────┘

Types décimaux

Query

SELECT midpoint(toDecimal32(1.5, 2), toDecimal32(1, 1), 2) AS result, toTypeName(result) AS type;

Response

┌─result─┬─type──────────┐
│    1.5 │ Decimal(9, 2) │
└────────┴───────────────┘

Types Date

Query

SELECT midpoint(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;

Response

┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘

Types de DateTime

Query

SELECT midpoint(toDateTime('2025-01-01 00:00:00'), toDateTime('2025-01-03 12:00:00')) AS result, toTypeName(result) AS type;

Response

┌──────────────result─┬─type─────┐
│ 2025-01-02 06:00:00 │ DateTime │
└─────────────────────┴──────────┘

Types Time64

Query

SELECT midpoint(toTime64('12:00:00', 0), toTime64('14:00:00', 0)) AS result, toTypeName(result) AS type;

Response

┌───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

min2(x, y)

Arguments

x — Première valeur (U)Int8/16/32/64 ou Float* ou BFloat16 ou Decimal
y — Deuxième valeur (U)Int8/16/32/64 ou Float* ou BFloat16 ou Decimal

Valeur renvoyée Renvoie la plus petite des valeurs x et y. Float64 Exemples Exemple d’utilisation

Query

SELECT min2(-1, 2)

Response

-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

minus(x, y)

Arguments

x — Diminuende. - y — Soustrahende.

Valeur renvoyée x moins y Exemples Soustraction de deux nombres

Query

SELECT minus(10, 5)

Response

Soustraction entre un integer et une date

Query

SELECT minus(toDate('2025-01-01'),5)

Response

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

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

Query

SELECT modulo(5, 2)

Response

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

moduloLegacy(a, b)

Arguments

a — Le dividende. (U)Int* ou Float*
b — Le diviseur. (U)Int* ou Float*

Valeur renvoyée Renvoie le reste de la division. (U)Int* ou Float* Exemples Utilisation de base

Query

SELECT moduloLegacy(10, 3)

Response

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

moduloOrNull(x, y)

Alias : modOrNull Arguments

x — Le dividende. (U)Int* ou Float*
y — Le diviseur (modulo). (U)Int* ou 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

Query

SELECT moduloOrNull(5, 0)

Response

\N

moduloOrNull de l’entier négatif minimal par -1

Query

SELECT moduloOrNull(toInt8(-128), toInt8(-1))

Response

\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

moduloOrZero(a, b)

Arguments

a — Le dividende. (U)Int* ou Float*
b — Le diviseur (modulo). (U)Int* ou 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

Query

SELECT moduloOrZero(5, 0)

Response

Diviseur à virgule flottante nul

Query

SELECT moduloOrZero(toFloat64(5), toFloat64(0))

Response

nan

multiply

Introduit dans : v1.1.0 Calcule le produit des deux valeurs x et y. Syntaxe

multiply(x, y)

Arguments

x — facteur. (U)Int* ou Float* ou Decimal
y — facteur. (U)Int* ou Float* ou Decimal

Valeur de retour Renvoie le produit de x et y Exemples Multiplier deux nombres

Query

SELECT multiply(5,5)

Response

multiplyDecimal

Introduit dans : v22.12.0 Effectue la multiplication de deux nombres décimaux. La valeur de résultat est de type Decimal256. 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

Syntaxe

multiplyDecimal(a, b[, result_scale])

Arguments

a — Première valeur. Decimal
b — Deuxième valeur. Decimal
result_scale — Échelle du résultat. (U)Int*

Valeur renvoyée Résultat de la multiplication avec l’échelle indiquée. Type : Decimal256 Exemples Exemple d’utilisation

Query

SELECT multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)

Response

25.2

Différence avec la multiplication standard

Query

SELECT multiply(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4));
SELECT multiplyDecimal(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4));

Response

┌─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

Query

SELECT
    toDecimal64(-12.647987876, 9) AS a,
    toDecimal64(123.967645643, 9) AS b,
    multiplyDecimal(a, b);

Response

┌─────────────a─┬─────────────b─┬─multiplyDecimal(a, b)─┐
│ -12.647987876 │ 123.967645643 │       -1567.941279108 │
└───────────────┴───────────────┴───────────────────────┘

Dépassement de capacité du type Decimal avec la multiplication standard

Query

SELECT
    toDecimal64(-12.647987876, 9) AS a,
    toDecimal64(123.967645643, 9) AS b,
    a * b;

Response

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

negate(x)

Arguments

x — La valeur à opposer.

Valeur renvoyée Renvoie -x pour x Exemples Exemple d’utilisation

Query

SELECT negate(10)

Response

-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

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

Query

SELECT plus(5,5)

Response

Addition d’un entier et d’une Date

Query

SELECT plus(toDate('2025-01-01'),5)

Response

2025-01-06

Ajouter une date et une heure

Query

SELECT toDate('2025-01-01') + CAST('14:30:25', 'Time')

Response

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

positiveModulo(x, y)

Alias : positive_modulo, pmod Arguments

x — Le dividende. (U)Int* ou Float* ou Decimal
y — Le diviseur (modulo). (U)Int* ou Float* ou 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

Query

SELECT positiveModulo(-1, 10)

Response

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

positiveModuloOrNull(x, y)

Alias : positive_modulo_or_null, pmodOrNull Arguments

x — Le dividende. (U)Int*/Float32/64. - y — Le diviseur (modulo). (U)Int*/Float32/64.

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

Query

SELECT positiveModuloOrNull(5, 0)

Response

\N

positiveModuloOrNull du plus petit entier négatif par -1

Query

SELECT positiveModuloOrNull(toInt8(-128), toInt8(-1))

Response

\N

sqr

Introduit dans : v26.7.0 Calcule le carré d’une valeur x. Syntaxe

sqr(x)

Arguments

x — Valeur à mettre au carré. (U)Int* ou Float* ou Decimal

Valeur renvoyée Renvoie le produit de x par lui-même. Exemples Mise au carré d’un nombre

Query

SELECT sqr(5)

Response

​Vue d’ensemble

​abs

​avg2

​byteSwap

​divide

​divideDecimal

​divideOrNull

​gcd

​ifNotFinite

​intDiv

​intDivOrNull

​intDivOrZero

​isFinite

​isInfinite

​isNaN

​kqlBin

​kqlBinAt

​kqlDateTimeBinAt

​kqlDivide

​kqlMultiply

​kqlRangeCount

​lcm

​max2

​midpoint

​min2

​minus

​modulo

​moduloLegacy

​moduloOrNull

​moduloOrZero

​multiply

​multiplyDecimal

​negate

​plus

​positiveModulo

​positiveModuloOrNull

​sqr

Vue d’ensemble

abs

avg2

byteSwap

divide

divideDecimal

divideOrNull

gcd

ifNotFinite

intDiv

intDivOrNull

intDivOrZero

isFinite

isInfinite

isNaN

kqlBin

kqlBinAt

kqlDateTimeBinAt

kqlDivide

kqlMultiply

kqlRangeCount

lcm

max2

midpoint

min2

minus

modulo

moduloLegacy

moduloOrNull

moduloOrZero

multiply

multiplyDecimal

negate

plus

positiveModulo

positiveModuloOrNull

sqr