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 - peut être appliqué aux expressions DATE.

Dans ce chapitre :

Liste des opérateurs arithmétiques¶

Opérateur	Syntaxe	Description
`+` (unaire)	`+a`	Renvoie `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`). Pour les fonctions qui renvoient 0 lorsqu’elles sont divisées par 0 ou NULL, voir DIV0 et DIV0NULL.
`%`	`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 |
+-----+-----------------+-----------------+

Copy

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

Si le résultat de l’opération de division dépasse l’échelle de sortie, Snowflake arrondit la sortie (plutôt que de la tronquer).

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

Copy

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.