- Kategorien:
Numerische Funktionen (Rundung und Kürzung)
ROUND¶
Gibt gerundete Werte für den Eingabeausdruck input_expr
zurück.
- Siehe auch:
Syntax¶
ROUND( <input_expr> [ , <scale_expr> [ , '<rounding_mode>' ] ] )
ROUND( EXPR => <input_expr> ,
SCALE => <scale_expr>
[ , ROUNDING_MODE => '<rounding_mode>' ] )
Argumente¶
Erforderlich:
input_expr
. OR .EXPR => input_expr
Der Wert oder Ausdruck, der verarbeitet werden soll. Der Datentyp muss aus einem der numerischen Datentypen bestehen, z. B. FLOAT oder NUMBER.
Wenn Sie das benannte Argument
EXPR =>
angeben, müssen Sie auch das benannte ArgumentSCALE =>
angeben.
Optional:
scale_expr
. OR .SCALE => scale_expr
Die Anzahl der Stellen, die die Ausgabe nach dem Dezimalpunkt enthält. Der Ausdruck muss eine Ganzzahl von -38 bis +38 ergeben.
Der Standardwert für
scale_expr
ist null. Das bedeutet, dass die Funktion alle Nachkommastellen entfernt.Weitere Informationen zu negativen Zahlen finden Sie unter Nutzungshinweise.
Wenn Sie das benannte Argument
SCALE =>
angeben, müssen SieEXPR =>
als vorangehendes benanntes Argument angeben.'rounding_mode'
. OR .ROUNDING_MODE => 'rounding_mode'
Der zu verwendende Rundungsmodus. Sie können einen der folgenden Werte angeben:
HALF_AWAY_FROM_ZERO
. Bei diesem Modus werden halbe Werte weg von Null gerundet.HALF_TO_EVEN
. Bei diesem Modus werden halbe Werte auf das nächste gerade Ergebnis gerundet.
Standard:
HALF_AWAY_FROM_ZERO
Wenn Sie das benannte Argument
ROUNDING_MODE =>
angeben, müssen Sie sowohlEXPR =>
als auchSCALE =>
als vorangehende benannte Argumente angeben.Bemerkung
Wenn Sie einen der beiden Werte für das Argument
rounding_mode
angeben, muss der Datentyp voninput_expr
einer der Datentypen für eine Festkommazahl sein.Datentypen für Gleitkommazahlen (z. B. FLOAT) werden bei diesem Argument nicht unterstützt.
Rückgabewerte¶
Der Rückgabetyp richtet sich nach dem Eingabetyp:
Wenn der Eingabeausdruck FLOAT ist, ist der zurückgegebene Typ FLOAT.
Wenn der Eingabeausdruck NUMBER ist, ist der zurückgegebene Typ NUMBER.
Wenn die Eingabeskalierung konstant ist:
Wenn die Eingabeskala positiv ist, hat der zurückgegebene Typ eine Skala, die der Eingabeskala entspricht, und eine Präzision, die groß genug ist, um jedes mögliche Ergebnis zu umfassen.
Wenn die Eingabeskalierung negativ ist, hat der zurückgegebene Typ eine Skalierung von 0.
Wenn die Eingabeskalierung nicht konstant ist, entspricht die Skalierung des zurückgegebenen Typs der des Eingabeausdrucks.
Wenn die Skalierung null ist, dann ist der Wert effektiv eine INTEGER.
Beispiel:
Der von
ROUND(3.14::FLOAT, 1)
zurückgegebene Datentyp ist FLOAT.Die von
ROUND(3.14, 1)
zurückgegebene NUMBER hat eine Skalierung von 1 und eine Präzision von mindestens 3.Die von
ROUND(-9.99, 0)
zurückgegebene NUMBER hat eine Skalierung von 0 und eine Präzision von mindestens 2.Die von
ROUND(33.33, -1)
zurückgegebene NUMBER hat eine Skalierung von 0 und eine Präzision von mindestens 3.
Wenn entweder input_expr
oder scale_expr
den Wert NULL haben, gibt die Funktion NULL zurück.
Nutzungshinweise¶
Sie müssen alle Argumente entweder über den Namen oder über die Position angeben. Sie können nicht einige der Argumente über den Namen und andere Argumente über die Position angeben.
Wenn Sie ein Argument über den Namen angeben, können Sie den Argumentnamen nicht in doppelten Anführungszeichen einschließen.
Wenn
scale_expr
negativ ist, gibt dies die Anzahl der Stellen vor dem Dezimalpunkt an, an die die Zahl angepasst werden soll. Wenn die Dezimalstellenzahl beispielsweise -2 ist, ist das Ergebnis ein Vielfaches von 100.Wenn
scale_expr
größer als die Dezimalstellenzahl des Eingabeausdrucks ist, hat die Funktion keine Auswirkungen.Standardmäßig werden bei Dezimalzahlen halbe Werte von Null weg gerundet. Beispielsweise wird -0,5 auf -1,0 gerundet.
Um den Rundungsmodus so zu ändern, dass halbe Werte auf das nächste gerade Ergebnis gerundet werden (z. B. -0,5 auf 0), geben Sie
'HALF_TO_EVEN'
für dasrounding_mode
-Argument an.Bemerkung
Wenn Sie das Argument
rounding_mode
angeben, muss der Datentyp des Argumentsinput_expr
einer der Datentypen für eine Festkommazahl sein.Gleitkommazahlen sind approximierte Werte. Eine Gleitkommazahl wird möglicherweise nicht wie erwartet gerundet.
Wenn die Zahl durch Runden außerhalb des Wertebereichs des Datentyps liegt, gibt die Funktion einen Fehler zurück.
Beispiele¶
Das folgende Beispiel ist ein einfaches Beispiel für ROUND mit der Standardanzahl der Dezimalstellen (0):
SELECT ROUND(135.135), ROUND(-975.975);
+----------------+-----------------+
| ROUND(135.135) | ROUND(-975.975) |
|----------------+-----------------|
| 135 | -976 |
+----------------+-----------------+
Im nächsten Beispiel werden die Daten in der folgenden Tabelle abgefragt:
CREATE TABLE test_ceiling (n FLOAT, scale INTEGER);
INSERT INTO test_ceiling (n, scale) VALUES
(-975.975, -1),
(-975.975, 0),
(-975.975, 2),
( 135.135, -2),
( 135.135, 0),
( 135.135, 1),
( 135.135, 3),
( 135.135, 50),
( 135.135, NULL);
Fragen Sie die Tabelle ab und verwenden Sie einen Wertebereich für das scale_expr
-Argument:
SELECT n, scale, ROUND(n, scale)
FROM test_ceiling
ORDER BY n, scale;
+----------+-------+-----------------+
| N | SCALE | ROUND(N, SCALE) |
|----------+-------+-----------------|
| -975.975 | -1 | -980 |
| -975.975 | 0 | -976 |
| -975.975 | 2 | -975.98 |
| 135.135 | -2 | 100 |
| 135.135 | 0 | 135 |
| 135.135 | 1 | 135.1 |
| 135.135 | 3 | 135.135 |
| 135.135 | 50 | 135.135 |
| 135.135 | NULL | NULL |
+----------+-------+-----------------+
Die nächsten beiden Beispiele zeigen den Unterschied zwischen dem Standard-Rundungsmodus ('HALF_AWAY_FROM_ZERO'
) und dem Rundungsmodus 'HALF_TO_EVEN'
: In beiden Beispielen wird die Funktion ROUND zweimal aufgerufen, zuerst mit dem Standard-Rundungsverhalten, dann mit 'HALF_TO_EVEN'
.
Im ersten Beispiel wird ein positiver Eingangswert von 2,5 verwendet:
SELECT ROUND(2.5, 0), ROUND(2.5, 0, 'HALF_TO_EVEN');
+---------------+-------------------------------+
| ROUND(2.5, 0) | ROUND(2.5, 0, 'HALF_TO_EVEN') |
|---------------+-------------------------------|
| 3 | 2 |
+---------------+-------------------------------+
Im zweiten Beispiel wird ein negativer Eingangswert von -2,5 verwendet:
SELECT ROUND(-2.5, 0), ROUND(-2.5, 0, 'HALF_TO_EVEN');
+----------------+--------------------------------+
| ROUND(-2.5, 0) | ROUND(-2.5, 0, 'HALF_TO_EVEN') |
|----------------+--------------------------------|
| -3 | -2 |
+----------------+--------------------------------+
Die nächsten beiden Beispiele zeigen, wie Sie die Argumente für die Funktion nicht über die Position, sondern über den Namen angeben:
SELECT ROUND(
EXPR => -2.5,
SCALE => 0) AS named_arguments;
+-----------------+
| NAMED_ARGUMENTS |
|-----------------|
| -3 |
+-----------------+
SELECT ROUND(
EXPR => -2.5,
SCALE => 0,
ROUNDING_MODE => 'HALF_TO_EVEN') AS named_with_rounding_mode;
+--------------------------+
| NAMED_WITH_ROUNDING_MODE |
|--------------------------|
| -2 |
+--------------------------+
Das nächste Beispiel zeigt, dass FLOAT-Werte nicht immer genau gespeichert werden. Wie Sie unten sehen können, wird .005 in einigen Fällen auf .01 gerundet, während in anderen Fällen auf 0 gerundet wird. Der Unterschied hängt nicht mit der Rundung zusammen; vielmehr hat er mit der zugrunde liegenden Darstellung der Gleitkommazahl zu tun, da 1.005 als Zahl gespeichert wird, die etwas kleiner als 1.005 ist (ungefähr 1.004999). Der DECIMAL-Wert wird jedoch als exakte Zahl gespeichert und wie in allen Fällen erwartet auf .01 gerundet.
Erstellen und laden Sie eine Tabelle:
CREATE OR REPLACE TEMP TABLE rnd1(f float, d DECIMAL(10, 3));
INSERT INTO rnd1 (f, d) VALUES
( -10.005, -10.005),
( -1.005, -1.005),
( 1.005, 1.005),
( 10.005, 10.005);
Zeigen Sie Beispiele für die Unterschiede zwischen gerundeten FLOAT-Werten und gerundeten DECIMAL-Werten an:
SELECT f,
ROUND(f, 2),
d,
ROUND(d, 2)
FROM rnd1
ORDER BY 1;
+---------+-------------+---------+-------------+
| F | ROUND(F, 2) | D | ROUND(D, 2) |
|---------+-------------+---------+-------------|
| -10.005 | -10.01 | -10.005 | -10.01 |
| -1.005 | -1 | -1.005 | -1.01 |
| 1.005 | 1 | 1.005 | 1.01 |
| 10.005 | 10.01 | 10.005 | 10.01 |
+---------+-------------+---------+-------------+