Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour générer une sortie numérique à partir d’une ou plusieurs expressions d’entrée.

Les expressions d’entrée doivent être numériques (virgule fixe ou virgule flottante), sauf dans les cas suivants :

  • L’opérateur unaire + peut prendre une chaîne numérique, mais cela entraîne la conversion implicite de la chaîne en sa valeur numérique correspondante.

  • L’opérateur binaire :code`-` peut être appliqué aux expressions DATE.

Dans ce chapitre :

Liste des opérateurs arithmétiques

Opérateur

Syntaxe

Description

+ (unaire)

+a

Retourne a, ce qui provoque la conversion implicite de a en une valeur numérique. Si a est une chaîne, mais que la chaîne ne peut pas être convertie en valeur numérique, une erreur est renvoyée.

+

a + b

Ajoute deux expressions numériques (a et b).

- (unaire)

-a

Nie l’expression numérique d’entrée.

-

a - b

Soustrait une expression numérique (b) d’une autre (a).

-

a - b

Soustrait une expression de date (b) d’une autre (a). Le résultat est un nombre entier de jours. La soustraction est la seule opération arithmétique autorisée sur les expressions DATE.

*

a * b

Multiplie deux expressions numériques (a et b).

/

a / b

Divise une expression numérique (a) par une autre (b).

%

a % b

Calcule le modulo de l’expression numérique a par b. Voir aussi MOD.

Échelle et précision dans les opérations arithmétiques

L”échelle et la précision de la sortie d’une opération arithmétique dépendent de l’échelle et de la précision de la ou des entrées.

Ce chapitre décrit les calculs que Snowflake utilise pour préserver l’échelle et la précision de la sortie numérique générée par diverses opérations arithmétiques (multiplication, division, etc.). Les descriptions suivantes sont utilisées dans cette section :

Chiffres principaux

Nombre de chiffres (L) à gauche de la virgule décimale dans une valeur numérique.

Échelle

Nombre de chiffres (S) à droite de la virgule décimale dans une valeur numérique.

Précision

Nombre total de chiffres (P) d’une valeur numérique, calculé comme la somme de ses premiers chiffres et de son échelle (c’est-à-dire P = L + S). Notez que la précision dans Snowflake est toujours limitée à 38.

Aussi :

  • Les types de données à virgule fixe (NUMBER, DECIMAL, etc.) utilisent la précision et l’échelle. Par exemple, pour le type de données DECIMAL(8,2), la précision est de 8, l’échelle est de 2 et le premier chiffre est 6.

  • Les types de données en virgule flottante (FLOAT, DOUBLE, REAL, etc.) utilisent des doubles de 8 octets.

Pour les sorties, notez qu’il s’agit du nombre maximum de chiffres ; le nombre réel de chiffres pour une sortie donnée pourrait être inférieur.

Multiplication

Lors de la multiplication :

  • Le nombre de premiers chiffres de la sortie est la somme des premiers chiffres des deux entrées.

  • Snowflake minimise le débordement potentiel (dû à la multiplication en chaîne) en ajoutant le nombre de chiffres dans l’échelle des deux entrées, jusqu’à un seuil maximum de 12 chiffres, à moins que l’une des entrées ait une échelle supérieure à 12, auquel cas l’échelle d’entrée supérieure est utilisée en sortie.

En d’autres termes, en supposant une opération de multiplication avec deux entrées (L1.S1 et L2.S2), le nombre maximum de chiffres dans la sortie est calculé comme suit :

Chiffres principaux

L = L1 + L2

Échelle

S = min(S1 + S2, max(S1, S2, 12))

Précision

P = L + S

Note

Snowflake multiplie les nombres entiers pour les valeurs numériques, de sorte que les résultats intermédiaires pourraient causer un certain débordement ; cependant, la sortie finale ne débordera pas.

Exemples

select 10.01 n1, 1.1 n2, n1 * n2;

+-------+-----+---------+
|    N1 |  N2 | N1 * N2 |
|-------+-----+---------|
| 10.01 | 1.1 |  11.011 |
+-------+-----+---------+

select 10.001 n1, .001 n2, n1 * n2;

+--------+-------+----------+
|     I1 |    I2 |  I1 * I2 |
|--------+-------+----------|
| 10.001 | 0.001 | 0.010001 |
+--------+-------+----------+

select .1 n1, .0000000000001 n2, n1 * n2;

+-----+-----------------+-----------------+
|  N1 |              N2 |         N1 * N2 |
|-----+-----------------+-----------------|
| 0.1 | 0.0000000000001 | 0.0000000000000 |
+-----+-----------------+-----------------+

Division

Lors de la division :

  • Les premiers chiffres de la sortie sont la somme des premiers chiffres du numérateur et de l’échelle du dénominateur.

  • Snowflake minimise le débordement potentiel de la sortie (dû à la division en chaîne) et la perte d’échelle en ajoutant 6 chiffres à l’échelle du numérateur, jusqu’à un seuil maximum de 12 chiffres, sauf si l’échelle du numérateur est supérieure à 12, auquel cas l’échelle du numérateur est utilisée comme échelle de sortie.

En d’autres termes, en supposant une opération de division avec le numérateur L1.S1 et le dénominateur L2.S2, le nombre maximum de chiffres dans la sortie est calculé comme suit :

Chiffres principaux

L = L1 + S2

Échelle

S = max(S1, min(S1 + 6, 12))

Précision

P = L + S

De plus, Snowflake effectue des divisions entières avec arrondi.

Note

Comme pour la multiplication, les résultats de la division intermédiaire pourraient causer un certain débordement ; cependant, la sortie finale ne débordera pas.

Exemples

select 2 n1, 7 n2, n1 / n2;

+----+----+----------+
| N1 | N2 |  N1 / N2 |
|----+----+----------|
|  2 |  7 | 0.285714 |
+----+----+----------+

select 10.1 n1, 2.1 n2, n1 / n2;

+------+-----+-----------+
|   N1 |  N2 |   N1 / N2 |
|------+-----+-----------|
| 10.1 | 2.1 | 4.8095238 |
+------+-----+-----------+

select 10.001 n1, .001 n2, n1 / n2;

+--------+-------+-----------------+
|     N1 |    N2 |         N1 / N2 |
|--------+-------+-----------------|
| 10.001 | 0.001 | 10001.000000000 |
+--------+-------+-----------------+

select .1 n1, .0000000000001 n2, n1 / n2;

+-----+-----------------+-----------------------+
|  N1 |              N2 |               N1 / N2 |
|-----+-----------------+-----------------------|
| 0.1 | 0.0000000000001 | 1000000000000.0000000 |
+-----+-----------------+-----------------------+

Addition et soustraction

Pour une addition ou une soustraction :

  • Les premiers chiffres de la sortie correspondent au plus grand nombre de premiers chiffres des entrées plus 1 (pour préserver les valeurs portées).

  • L’échelle de la sortie est la plus grande échelle des entrées.

En d’autres termes, en supposant qu’une opération d’addition ou de soustraction a deux entrées (L1.S1 et L2.S2), le nombre maximum de chiffres dans la sortie est calculé comme suit :

Chiffres principaux

L = max(L1, L2) + 1

Échelle

S = max(S1, S2)

Précision

P = L + S

Autres opérations N-aire

Pour toutes les autres opérations arithmétiques comportant plus d’une entrée numérique, telles qu’un modulo (a % b ou MOD).

  • Les premiers chiffres de la sortie correspondent au plus grand nombre de premiers chiffres des entrées.

  • L’échelle de la sortie est la plus grande échelle des entrées.

En d’autres termes, en supposant une opération n-aire avec des entrées L1.S1, L2.S2, etc., le nombre maximum de chiffres dans la sortie est calculé comme suit :

Chiffres principaux

L = max(L1, L2, ...)

Échelle

S = max(S1, S2, ...)

Précision

P = L + S

Opérations unaires

Les opérations arithmétiques unaires ont la même précision et la même échelle de sortie que la précision et l’échelle d’entrée, sauf pour ROUND, qui permet de spécifier explicitement l’échelle de sortie.

Opérations au niveau du bit

La liste des opérations arithmétiques prises en charge au niveau du bit est disponible à l’adresse Fonctions d’expressions conditionnelles.

Remarque :

  • Pour les valeurs numériques, les opérations au niveau du bit ne fonctionnent que sur les premiers chiffres de l’entrée. La sortie possède toujours une échelle de zéro.

  • Pour les opérations binaires au niveau du bit, la sortie a le même nombre de premiers chiffres que les premiers chiffres maximums de l’entrée.