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

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(toDecimal64(-12, 1), toDecimal32(2.1, 1), 1)─┬─divideDecimal(toDecimal64(-12, 1), toDecimal32(2.1, 1), 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 nombre négatif minimal 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(intDiv(toFloat64(1), 0.001))─┐
│ 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

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* ou Decimal
y — Deuxième valeur (U)Int8/16/32/64, Float* 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 Decimal
y — Deuxième valeur (U)Int8/16/32/64 ou Float* 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 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

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 entier 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 si l’argument de droite est 0. 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 si le diviseur est égal à zéro. Exemples moduloOrNull avec zéro

Query

SELECT moduloOrNull(5, 0)

Response

\N

moduloOrZero

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

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, ou 0 lorsque le diviseur est 0. Exemples Exemple d’utilisation

Query

SELECT moduloOrZero(5, 0)

Response

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 multiplyDecimal(toDecimal256(-12, 0), toDecimal32(-2.1, 1), 1)

Response

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

Query

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

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

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. 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 si l’argument de droite est 0. 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, null si le diviseur est égal à zéro. Exemples positiveModuloOrNull

Query

SELECT positiveModuloOrNull(5, 0)

Response

\N

​Vue d’ensemble

​abs

​avg2

​byteSwap

​divide

​divideDecimal

​divideOrNull

​gcd

​ifNotFinite

​intDiv

​intDivOrNull

​intDivOrZero

​isFinite

​isInfinite

​isNaN

​lcm

​max2

​midpoint

​min2

​minus

​modulo

​moduloLegacy

​moduloOrNull

​moduloOrZero

​multiply

​multiplyDecimal

​negate

​plus

​positiveModulo

​positiveModuloOrNull

Vue d’ensemble

abs

avg2

byteSwap

divide

divideDecimal

divideOrNull

gcd

ifNotFinite

intDiv

intDivOrNull

intDivOrZero

isFinite

isInfinite

isNaN

lcm

max2

midpoint

min2

minus

modulo

moduloLegacy

moduloOrNull

moduloOrZero

multiply

multiplyDecimal

negate

plus

positiveModulo

positiveModuloOrNull