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 │
└───────────────┴────────────────────────┴─────────────────────────────────┴──────────────────────────────────────────┘
x. N’a aucun effet si x est de type non signé. Si x est de type signé, renvoie un nombre non signé.
Syntaxe
Arguments
x — Valeur dont on veut obtenir la valeur absolue
Valeur renvoyée
La valeur absolue de x
Exemples
Exemple d’utilisation
Introduit dans : v25.11.0
Calcule et renvoie la moyenne des arguments fournis.
Prend en charge les types numériques et temporels.
Syntaxe
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
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.
┌─result─┬─type────┐
│ 2 │ Float64 │
└────────┴─────────┘
SELECT avg2(toDecimal32(1, 2), 2) AS result, toTypeName(result) AS type;
┌─result─┬─type──────────┐
│ 1.5 │ Decimal(9, 2) │
└────────┴───────────────┘
SELECT avg2(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;
┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘
SELECT avg2(toDateTime('2025-01-01 00:00:00'), toDateTime('2025-01-03 12:00:00')) AS result, toTypeName(result) AS type;
┌──────────────result─┬─type─────┐
│ 2025-01-02 06:00:00 │ DateTime │
└─────────────────────┴──────────┘
SELECT avg2(toTime64('12:00:00', 0), toTime64('14:00:00', 0)) AS result, toTypeName(result) AS type;
┌───result─┬─type──────┐
│ 13:00:00 │ Time64(0) │
└──────────┴───────────┘
- 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 │
└───────────────────────────────────────────────────────┘
x avec l’ordre des octets inversé. (U)Int*
Exemples
Exemple d’utilisation
SELECT byteSwap(3351772109)
SELECT byteSwap(3351772109)
SELECT byteSwap(123294967295)
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.
x — Dividende - y — Diviseur
Valeur renvoyée
Le quotient de x par y
Exemples
Division de deux nombres
SELECT divide(25,5) AS quotient, toTypeName(quotient)
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. divideDecimal(x, y[, result_scale])
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
divideDecimal(toDecimal256(-12, 0), toDecimal32(2.1, 1), 10)
┌─divideDecimal(toDecimal256(-12, 0), toDecimal32(2.1, 1), 10)─┐
│ -5.7142857142 │
└──────────────────────────────────────────────────────────────┘
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);
┌─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 │
└─────┴─────┴────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────┘
divide, mais renvoie NULL en cas de division par zéro.
Syntaxe
Arguments
x — Dividende - y — Diviseur
Valeur renvoyée
Le quotient de x par y, ou NULL.
Exemples
Division par zéro
SELECT divideOrNull(25, 0)
x — Premier entier - y — Deuxième entier
Valeur renvoyée
Le plus grand diviseur commun de x et y.
Exemples
Exemple d’utilisation
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
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
SELECT 1/0 AS infimum, ifNotFinite(infimum,42)
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
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
SELECT intDiv(toFloat64(1), 0.001) AS res, toTypeName(res)
┌──res─┬─toTypeName(intDiv(toFloat64(1), 0.001))─┐
│ 1000 │ Int64 │
└──────┴─────────────────────────────────────────┘
SELECT
intDiv(1, 0.001) AS res,
toTypeName(res)
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)
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
Arguments
Valeur renvoyée
Résultat de la division entière de x par y, ou NULL.
Exemples
Division entière par zéro
SELECT intDivOrNull(1, 0)
SELECT intDivOrNull(-9223372036854775808, -1)
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
Arguments
Valeur renvoyée
Résultat de la division entière de a par b, ou zéro.
Exemples
Division entière par zéro
SELECT intDivOrZero(1, 0)
SELECT intDivOrZero(0.05, -1)
1 si l’argument Float32, Float64 ou BFloat16 n’est ni infini ni NaN,
sinon cette fonction renvoie 0.
Syntaxe
Arguments
Valeur renvoyée
1 si x n’est ni infini ni NaN, sinon 0.
Exemples
Tester si un nombre est fini
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
Arguments
Valeur renvoyée
1 si x est infini, sinon 0 (y compris pour NaN).
Exemples
Vérifier si un nombre est infini
SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10))
1 si l’argument de type Float32, Float64 ou BFloat16 est NaN, sinon 0.
Syntaxe
Arguments
Valeur renvoyée
1 si NaN, sinon 0
Exemples
Exemple d’utilisation
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
Arguments
Valeur renvoyée
Renvoie le plus petit commun multiple de x et y. (U)Int*
Exemples
Exemple d’utilisation
Introduit dans : v21.11.0
Renvoie la plus grande des deux valeurs numériques x et y.
Syntaxe
Arguments
Valeur renvoyée
Renvoie la plus grande des deux valeurs x et y. Float64
Exemples
Exemple d’utilisation
Introduit dans : v25.11.0
Calcule et renvoie la valeur moyenne des arguments fournis.
Prend en charge les types numériques et temporels.
Syntaxe
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
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.
┌─result─┬─type────┐
│ 1.5 │ Float64 │
└────────┴─────────┘
SELECT midpoint(toDecimal32(1.5, 2), toDecimal32(1, 1), 2) AS result, toTypeName(result) AS type;
┌─result─┬─type──────────┐
│ 1.5 │ Decimal(9, 2) │
└────────┴───────────────┘
SELECT midpoint(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;
┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘
SELECT midpoint(toDateTime('2025-01-01 00:00:00'), toDateTime('2025-01-03 12:00:00')) AS result, toTypeName(result) AS type;
┌──────────────result─┬─type─────┐
│ 2025-01-02 06:00:00 │ DateTime │
└─────────────────────┴──────────┘
SELECT midpoint(toTime64('12:00:00', 0), toTime64('14:00:00', 0)) AS result, toTypeName(result) AS type;
┌───result─┬─type──────┐
│ 13:00:00 │ Time64(0) │
└──────────┴───────────┘
x et y.
Syntaxe
Arguments
Valeur renvoyée
Renvoie la plus petite des valeurs x et y. Float64
Exemples
Exemple d’utilisation
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
Arguments
x — Diminuende. - y — Soustrahende.
Valeur renvoyée
x moins y
Exemples
Soustraction de deux nombres
Soustraction entre un entier et une date
SELECT minus(toDate('2025-01-01'),5)
mod
Arguments
a — Le dividende - b — Le diviseur (modulo)
Valeur renvoyée
Le reste de a % b
Exemples
Exemple d’utilisation
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
Arguments
Valeur renvoyée
Renvoie le reste de la division. (U)Int* ou Float*
Exemples
Utilisation de base
SELECT moduloLegacy(10, 3)
a par b. Comme la fonction modulo, sauf que moduloOrNull renvoie NULL
si l’argument de droite est 0.
Syntaxe
Alias : modOrNull
Arguments
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
SELECT moduloOrNull(5, 0)
a % b, ou 0 lorsque le diviseur est 0.
Exemples
Exemple d’utilisation
SELECT moduloOrZero(5, 0)
x et y.
Syntaxe
Arguments
Valeur de retour
Renvoie le produit de x et y
Exemples
Multiplier deux nombres
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 multiplyDecimal(a, b[, result_scale])
Decimal256
Exemples
Exemple d’utilisation
SELECT multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)
SELECT multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)
┌─multiply(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4))─┐
│ -26.8609633 │
└───────────────────────────────────────────────────────────┘
┌─multiplyDecimal(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4))─┐
│ -26.8609 │
└──────────────────────────────────────────────────────────────────┘
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;
┌─────────────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)
x. Le résultat est toujours de type signé.
Syntaxe
Arguments
Valeur renvoyée
Renvoie -x pour x
Exemples
Exemple d’utilisation
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
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
Addition d’un entier et d’une Date
SELECT plus(toDate('2025-01-01'),5)
SELECT toDate('2025-01-01') + CAST('14:30:25', 'Time')
x par y. Comme la fonction
modulo, à ceci près que positiveModulo renvoie toujours un nombre non négatif.
Syntaxe
Alias : positive_modulo, pmod
Arguments
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
SELECT positiveModulo(-1, 10)
a par b. Similaire à la fonction positiveModulo, à ceci près que positiveModuloOrNull renvoie NULL
si l’argument de droite est 0.
Syntaxe
positiveModuloOrNull(x, y)
positive_modulo_or_null, pmodOrNull
Arguments
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
SELECT positiveModuloOrNull(5, 0)
