Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

Fonctions arithmétiques

View as MarkdownEdit this pageReport an issueSet up docs MCP

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

SELECT abs(-0.5)
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

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

Types décimaux

SELECT avg2(toDecimal32(1, 2), 2) AS result, toTypeName(result) AS type;
┌─result─┬─type──────────┐
│    1.5 │ Decimal(9, 2) │
└────────┴───────────────┘

Types Date

SELECT avg2(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;
┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘

Types DateTime

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

Types Time64

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

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 :

  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 :
┌─toIPv4(byteSwap(toUInt32(toIPv4('205.251.199.199'))))─┐
│ 199.199.251.205                                       │
└───────────────────────────────────────────────────────┘

Syntaxe

byteSwap(x)

Arguments

Valeur renvoyée

Renvoie x avec l’ordre des octets inversé. (U)Int*

Exemples

Exemple d'utilisation

SELECT byteSwap(3351772109)
3455829959

8 bits

SELECT byteSwap(54)
54

16 bits

SELECT byteSwap(4135)
10000

32 bits

SELECT byteSwap(3351772109)
3455829959

64 bits

SELECT byteSwap(123294967295)
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.

Syntaxe

divide(x, y)

Arguments

  • 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)
5	Float64

Division par zéro

SELECT divide(25,0)
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.

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

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

Exemple 2

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

SELECT divideOrNull(25, 0)
\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

SELECT gcd(12, 18)
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 : 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

SELECT 1/0 AS infimum, ifNotFinite(infimum,42)
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

SELECT intDiv(toFloat64(1), 0.001) AS res, toTypeName(res)
┌──res─┬─toTypeName(res)─┐
│ 1000 │ Int64           │
└──────┴─────────────────┘

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

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)

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

SELECT intDivOrNull(1, 0)
\N

Division du nombre négatif minimal par -1

SELECT intDivOrNull(-9223372036854775808, -1)
\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

SELECT intDivOrZero(1, 0)
0

Division du nombre négatif minimal par -1

SELECT intDivOrZero(0.05, -1)
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

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

SELECT isFinite(inf)
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

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

SELECT isInfinite(inf), isInfinite(NaN), isInfinite(10)
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

SELECT isNaN(NaN)
1

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

Valeur renvoyée

Renvoie le plus petit commun multiple de x et y. (U)Int*

Exemples

Exemple d’utilisation

SELECT lcm(6, 8)
24

max2

Introduit dans : v21.11.0

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

Syntaxe

max2(x, y)

Arguments

Valeur renvoyée

Renvoie la plus grande des deux valeurs x et y. Float64

Exemples

Exemple d'utilisation

SELECT max2(-1, 2)
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

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

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

Types décimaux

SELECT midpoint(toDecimal32(1.5, 2), toDecimal32(1, 1), 2) AS result, toTypeName(result) AS type;
┌─result─┬─type──────────┐
│    1.5 │ Decimal(9, 2) │
└────────┴───────────────┘

Types Date

SELECT midpoint(toDate('2025-01-01'), toDate('2025-01-05')) AS result, toTypeName(result) AS type;
┌─────result─┬─type─┐
│ 2025-01-03 │ Date │
└────────────┴──────┘

Types de DateTime

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

Types Time64

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

min2

Introduit dans : v21.11.0

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

Syntaxe

min2(x, y)

Arguments

Valeur renvoyée

Renvoie la plus petite des valeurs x et y. Float64

Exemples

Exemple d'utilisation

SELECT min2(-1, 2)
-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

SELECT minus(10, 5)
5

Soustraction entre un entier et une date

SELECT minus(toDate('2025-01-01'),5)
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

SELECT modulo(5, 2)
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

moduloLegacy(a, b)

Arguments

Valeur renvoyée

Renvoie le reste de la division. (U)Int* ou Float*

Exemples

Utilisation de base

SELECT moduloLegacy(10, 3)
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

moduloOrNull(x, y)

Alias : modOrNull

Arguments

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

SELECT moduloOrNull(5, 0)
\N

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

SELECT moduloOrNull(toInt8(-128), toInt8(-1))
\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

Valeur renvoyée

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

Exemples

Exemple d'utilisation

SELECT moduloOrZero(5, 0)
0

multiply

Introduit dans : v1.1.0

Calcule le produit des deux valeurs x et y.

Syntaxe

multiply(x, y)

Arguments

Valeur de retour

Renvoie le produit de x et y

Exemples

Multiplier deux nombres

SELECT multiply(5,5)
25

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.

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

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

Différence avec la multiplication standard

SELECT multiply(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4));
SELECT multiplyDecimal(toDecimal64(-12.647, 3), toDecimal32(2.1239, 4));
┌─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

SELECT
    toDecimal64(-12.647987876, 9) AS a,
    toDecimal64(123.967645643, 9) AS b,
    multiplyDecimal(a, b);
┌─────────────a─┬─────────────b─┬─multiplyDecimal(a, b)─┐
│ -12.647987876 │ 123.967645643 │       -1567.941279108 │
└───────────────┴───────────────┴───────────────────────┘

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

SELECT
    toDecimal64(-12.647987876, 9) AS a,
    toDecimal64(123.967645643, 9) AS b,
    a * b;
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

SELECT negate(10)
-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

SELECT plus(5,5)
10

Addition d’un entier et d’une Date

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

Ajouter une date et une heure

SELECT toDate('2025-01-01') + CAST('14:30:25', 'Time')
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

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

positiveModuloOrNull(x, y)

Alias : 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, 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

SELECT positiveModuloOrNull(5, 0)
\N

positiveModuloOrNull du plus petit entier négatif par -1

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

sqr

Introduit dans : v26.7.0

Calcule le carré d’une valeur x.

Syntaxe

sqr(x)

Arguments

Valeur renvoyée

Renvoie le produit de x par lui-même.

Exemples

Mise au carré d’un nombre

SELECT sqr(5)
25
Navigation