Arithmetische Operatoren¶

Arithmetische Operatoren werden verwendet, um numerische Ausgaben aus einem oder mehreren Eingabeausdrücken zu generieren.

Die Eingabeausdrücke müssen numerisch sein (Festkomma oder Gleitkomma), außer in den folgenden Fällen:

Der unäre Operator + kann eine Zahlenfolge annehmen, dies bewirkt jedoch, dass die Zeichenfolge implizit in den entsprechenden numerischen Wert konvertiert wird.
Der binäre Operator - kann auf DATE-Ausdrücke angewendet werden.

Unter diesem Thema:

Liste der arithmetischen Operatoren¶

Operator	Syntax	Beschreibung
`+` (unär)	`+a`	Gibt `a` zurück, was eine implizite Umwandlung von `a` in einen numerischen Wert bewirkt. Wenn `a` eine Zeichenfolge ist, die Zeichenfolge aber nicht in einen numerischen Wert umgewandelt werden kann, wird ein Fehler zurückgegeben.
`+`	`a + b`	Addiert zwei numerische Ausdrücke (`a` und `b`).
`-` (unär)	`-a`	Negiert den eingegebenen numerischen Ausdruck.
`-`	`a - b`	Subtrahiert einen numerischen Ausdruck (`b`) von einem anderen (`a`).
`-`	`a - b`	Subtrahiert einen Datumsausdruck (`b`) von einem anderen (`a`). Das Ergebnis ist eine ganze Zahl von Tagen. Subtraktion ist die einzige arithmetische Operation, die für DATE-Ausdrücke zulässig ist.
`*`	`a * b`	Multipliziert zwei numerische Ausdrücke (`a` und `b`).
`/`	`a / b`	Teilt einen numerischen Ausdruck (`a`) durch einen anderen (`b`). Weitere Informationen zu Funktionen, die bei Division durch 0 oder NULL den Wert 0 zurückgeben, finden Sie unter DIV0 und DIV0NULL.
`%`	`a % b`	Berechnet den Restwert (Modulo) der Division des numerischen Ausdrucks `a` durch Divisor `b`. Siehe auch MOD.

Maßstab und Genauigkeit von arithmetischen Operationen¶

Die Skalierung und Genauigkeit der Ausgabe einer arithmetischen Operation hängt von der Skalierung und Genauigkeit der Eingabe(n) ab.

In diesem Abschnitt werden die Berechnungen beschrieben, die Snowflake verwendet, um Skalierung und Genauigkeit in numerischen Ausgaben zu erhalten, die durch verschiedene arithmetische Operationen (Multiplikation, Division usw.) generiert werden. Die folgenden Beschreibungen werden in diesem Abschnitt verwendet:

Führende Stellen:

Anzahl der Stellen (L) links neben dem Dezimalpunkt bei einem numerischen Wert.

Skalierung:

Anzahl der Stellen (S) rechts neben dem Dezimalpunkt bei einem numerischen Wert.

Genauigkeit:

Gesamtzahl der Stellen (P) bei einem numerischen Wert, berechnet als Summe der führenden Stellen und Skalierung (d. h. P = L + S). Beachten Sie, dass die Genauigkeit in Snowflake immer auf 38 begrenzt ist.

Außerdem:

Bei Festkommadatentypen (NUMBER, DECIMAL usw.) werden Genauigkeit und Skalierung verwendet. So ist beispielsweise beim Datentyp DECIMAL(8,2) die Genauigkeit 8, die Skalierung 2 und die Anzahl der führenden Stellen 6.
Gleitkommadatentypen (FLOAT, DOUBLE, REAL usw.) verwenden 8-Byte-Double-Werte.

Beachten Sie bei Ausgaben, dass dies die maximale Anzahl von Stellen ist. Die tatsächliche Anzahl von Stellen bei einer bestimmten Ausgabe kann geringer sein.

Multiplikation¶

Bei der Multiplikation:

Die Anzahl der führenden Stellen bei der Ausgabe ist die Summe der führenden Stellen bei beiden Eingaben.
Snowflake minimiert den potenziellen Überlauf (durch verkettete Multiplikation), indem die Anzahl der Stellen in der Skalierung beider Eingaben bis zu einem maximalen Schwellenwert von 12 Stellen addiert wird – es sei denn, eine der Eingaben hat eine Skalierung von größer als 12. In diesem Fall wird die größere Eingabeskalierung als Ausgabeskalierung verwendet.

Mit anderen Worten, unter der Annahme einer Multiplikationsoperation mit zwei Eingaben (L1.S1 und L2.S2) wird die maximale Anzahl von Stellen in der Ausgabe wie folgt berechnet:

Führende Stellen:

L = L1 + L2

Skalierung:

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

Genauigkeit:

P = L + S

Bemerkung

Snowflake führt eine Ganzzahlmultiplikation für numerische Werte durch, sodass Zwischenergebnisse zu einem Überlauf führen können. Bei der endgültigen Ausgabe kommt es jedoch zu keinem Überlauf.

Beispiele¶

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¶

Bei der Division:

Die führenden Stellen bei der Ausgabe sind die Summe der führenden Stellen des Zählers und der Skalierung des Nenners.
Snowflake minimiert den potenziellen Überlauf in der Ausgabe (aufgrund der verketteten Division) und den Skalierungsverlust, indem 6 Stellen zur Skalierung des Zählers bis zu einem maximalen Schwellenwert von 12 Stellen addiert werden – es sei denn, die Skalierung des Zählers ist größer als 12. In diesem Fall wird die Zählerskalierung als Ausgabeskalierung verwendet.

Mit anderen Worten, unter der Annahme einer Divisionsoperation mit Zähler L1.S1 und Nenner L2.S2 wird die maximale Anzahl von Stellen in der Ausgabe wie folgt berechnet:

Führende Stellen:

L = L1 + S2

Skalierung:

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

Genauigkeit:

P = L + S

Wenn das Ergebnis der Divisionsoperation die Ausgabeskalierung überschreitet, rundet Snowflake die Ausgabe ab (anstatt die Ausgabe abzuschneiden).

Bemerkung

Ähnlich wie bei der Multiplikation können Zwischenergebnisse zum Überlauf führen. Bei der endgültigen Ausgabe kommt es jedoch zu keinem Überlauf.

Beispiele¶

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 und Subtraktion¶

Bei Addition oder Subtraktion:

Die führenden Stellen bei der Ausgabe sind die größte Anzahl der führenden Stellen der Eingaben plus 1 (um die Werte zu erhalten).
Die Skalierung bei der Ausgabe ist die größte Skalierung der Eingaben.

Unter der Annahme, dass eine Additions- oder Subtraktionsoperation zwei Eingaben (L1.S1 und L2.S2) hat, wird die maximale Anzahl von Stellen in der Ausgabe wie folgt berechnet:

Führende Stellen:

L = max(L1, L2) + 1

Skalierung:

S = max(S1, S2)

Genauigkeit:

P = L + S

Andere n-stufige Operationen¶

Für alle anderen Rechenoperationen mit mehr als einer numerischen Eingabe, wie z. B. modulo (a % b oder MOD):

Die führenden Stellen bei der Ausgabe sind die größte Anzahl der führenden Stellen der Eingaben.
Die Skalierung bei der Ausgabe ist die größte Skalierung der Eingaben.

Mit anderen Worten, unter der Annahme einer n-stufigen Operation mit Eingängen L1.S1, L2.S2 usw. wird die maximale Anzahl von Stellen in der Ausgabe wie folgt berechnet:

Führende Stellen:

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

Skalierung:

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

Genauigkeit:

P = L + S

Unäre Operationen¶

Unäre arithmetische Operationen haben die gleiche Ausgabegenauigkeit und Skalierung wie die Eingabegenauigkeit und Skalierung, mit Ausnahme von ROUND, wodurch die Ausgabeskalierung explizit angegeben werden kann.

Bitweise Operationen¶

Die Liste der unterstützten bitweisen Rechenoperationen steht unter Funktionen für bedingte Ausdrücke zur Verfügung.

Anmerkung:

Bei numerischen Werten wirken bitweise Operationen nur auf die führenden Stellen der Eingabe. Die Ausgabe hat immer eine Skalierung von Null.
Bei binären bitweisen Operationen hat die Ausgabe die gleiche Anzahl von führenden Stellen wie die maximalen führenden Stellen der Eingabe.