Catégories :: Fonctions numériques (arrondi et troncation)

ROUND¶

Renvoie des valeurs arrondies pour input_expr.

Voir aussi :: CEIL, FLOOR, TRUNCATE , TRUNC

Syntaxe¶

ROUND( <input_expr> [ , <scale_expr> [ , '<rounding_mode>' ] ] )

Copy

ROUND( EXPR => <input_expr> ,
       SCALE => <scale_expr>
       [ , ROUNDING_MODE => '<rounding_mode>'  ] )

Copy

Arguments¶

Obligatoire :

input_expr . OR . EXPR => input_expr

Valeur ou expression sur laquelle opérer. Le type de données doit être l’un des types de données numériques, tels que FLOAT ou NUMBER.

Si vous spécifiez l’argument nommé EXPR =>, vous devez également spécifier l’argument nommé SCALE =>.

Facultatif :

scale_expr . OR . SCALE => scale_expr

Nombre de chiffres que la sortie comprend après le point décimal. L’expression doit correspondre à un entier compris entre -38 et +38.

La valeur scale_expr par défaut est zéro, ce qui signifie que la fonction supprime tous les chiffres après le point décimal.

Pour plus d’informations sur les nombres négatifs, voir Notes sur l’utilisation.

Si vous spécifiez l’argument nommé SCALE =>, vous devez spécifier EXPR => comme argument nommé précédent.

'rounding_mode' . OR . ROUNDING_MODE => 'rounding_mode'

Le mode d’arrondi à utiliser. Vous pouvez spécifier l’une des valeurs suivantes :

HALF_AWAY_FROM_ZERO. Ce mode arrondit la valeur à la moitié de zéro.
HALF_TO_EVEN. Ce mode arrondit la valeur à la moitié du nombre pair.

Par défaut : HALF_AWAY_FROM_ZERO

Si vous spécifiez l’argument nommé ROUNDING_MODE =>, vous devez spécifier à la fois EXPR => et SCALE => comme arguments nommés précédents.

Note

Si vous spécifiez l’une ou l’autre valeur pour l’argument rounding_mode , le type de données de input_expr doit être l’un des types de données pour un nombre à virgule fixe.

Les types de données pour les nombres à virgule flottante (par exemple, FLOAT) ne sont pas pris en charge avec cet argument.

Renvoie¶

Le type de retour est basé sur le type d’entrée :

Si l’expression d’entrée est un FLOAT, le type renvoyé est un FLOAT.
Si l’expression d’entrée est un NUMBER, le type renvoyé est un NUMBER.
- Si l’échelle d’entrée est constante :
  - Si l’échelle d’entrée est positive, le type renvoyé a une échelle égale à l’échelle d’entrée et a une précision suffisamment grande pour englober tout résultat possible.
  - Si l’échelle d’entrée est négative, le type renvoyé a une échelle de 0.
- Si l’échelle d’entrée n’est pas constante, l’échelle du type renvoyé est la même que celle de l’expression d’entrée.

Si l’échelle est égale à zéro, la valeur est effectivement un INTEGER.

Par exemple :

Le type de données renvoyé par ROUND(3.14::FLOAT, 1) est FLOAT.
Le NUMBER retourné par ROUND(3.14, 1) a une échelle de 1 et une précision d’au moins 3.
Le NUMBER retourné par ROUND(-9.99, 0) a une échelle de 0 et une précision d’au moins 2.
Le NUMBER retourné par ROUND(33.33, -1) a une échelle de 0 et une précision d’au moins 3.

Si input_expr ou scale_expr est NULL, la fonction renvoie NULL.

Notes sur l’utilisation¶

Vous devez spécifier tous les arguments soit par leur nom, soit par leur position. Vous ne pouvez pas spécifier certains arguments par leur nom et d’autres par leur position.

Lorsque vous spécifiez un argument par son nom, vous ne pouvez pas utiliser de guillemets doubles autour du nom de l’argument.
Si scale_expr est négatif, il spécifie le nombre de positions avant le point décimal auquel le nombre doit être ajusté. Par exemple, si l’échelle est -2, le résultat est un multiple de 100.
Si scale_expr est plus grand que l’échelle d’expression en entrée, la fonction n’a aucun effet.
Par défaut, les demi-points sont arrondis à zéro pour les décimales. Par exemple, -0,5 est arrondi à -1,0.

Pour changer le mode d’arrondi afin d’arrondir la valeur à la moitié du nombre pair (par exemple, pour arrondir -0,5 à 0), spécifiez 'HALF_TO_EVEN' pour l’argument rounding_mode.

Note

Si vous spécifiez l’argument rounding_mode, le type de données de l’argument input_expr doit être l’un des types de données pour un nombre à virgule fixe.
Les nombres à virgule flottante sont des valeurs approximatives. Un nombre à virgule flottante pourrait ne pas s’arrondir comme prévu.
Si vous arrondissez le nombre pour l’amener en dehors de la plage de valeurs du type de données, la fonction renvoie une erreur.

Exemples¶

L’exemple suivant montre un exemple simple de ROUND, avec le nombre de décimales par défaut (0) :

SELECT ROUND(135.135), ROUND(-975.975);

Copy

+----------------+-----------------+
| ROUND(135.135) | ROUND(-975.975) |
|----------------+-----------------|
|            135 |            -976 |
+----------------+-----------------+

L’exemple suivant interroge les données du tableau suivant :

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

Copy

Interroger la table et utiliser une plage de valeurs pour l’argument scale_expr :

SELECT n, scale, ROUND(n, scale)
  FROM test_ceiling
  ORDER BY n, scale;

Copy

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

Les deux exemples suivants montrent la différence entre l’utilisation du mode d’arrondi par défaut ('HALF_AWAY_FROM_ZERO') et le mode d’arrondi 'HALF_TO_EVEN'. Les deux exemples appellent la fonction ROUND deux fois, d’abord avec le comportement d’arrondi par défaut, puis avec 'HALF_TO_EVEN'.

Le premier exemple utilise une valeur d’entrée positive de 2,5 :

SELECT ROUND(2.5, 0), ROUND(2.5, 0, 'HALF_TO_EVEN');

Copy

+---------------+-------------------------------+
| ROUND(2.5, 0) | ROUND(2.5, 0, 'HALF_TO_EVEN') |
|---------------+-------------------------------|
|             3 |                             2 |
+---------------+-------------------------------+

Le deuxième exemple utilise une valeur d’entrée négative de -2,5 :

SELECT ROUND(-2.5, 0), ROUND(-2.5, 0, 'HALF_TO_EVEN');

Copy

+----------------+--------------------------------+
| ROUND(-2.5, 0) | ROUND(-2.5, 0, 'HALF_TO_EVEN') |
|----------------+--------------------------------|
|             -3 |                             -2 |
+----------------+--------------------------------+

Les deux exemples suivants illustrent comment spécifier les arguments de la fonction par leur nom, plutôt que par leur position :

SELECT ROUND(
  EXPR => -2.5,
  SCALE => 0) AS named_arguments;

Copy

+-----------------+
| NAMED_ARGUMENTS |
|-----------------|
|              -3 |
+-----------------+

SELECT ROUND(
  EXPR => -2.5,
  SCALE => 0,
  ROUNDING_MODE => 'HALF_TO_EVEN') AS named_with_rounding_mode;

Copy

+--------------------------+
| NAMED_WITH_ROUNDING_MODE |
|--------------------------|
|                       -2 |
+--------------------------+

L’exemple suivant montre que les valeurs de FLOAT ne sont pas toujours stockées avec exactitude. Comme vous pouvez le voir ci-dessous, dans certains cas, 0,005 est arrondi à 0,01, alors que dans d’autres cas, il est arrondi à 0. La différence n’est pas dans l’arrondi ; la différence est en réalité dans la représentation sous-jacente du nombre à virgule flottante, car 1,005 est stocké sous forme d’un nombre très légèrement inférieur à 1,005 (environ 1,004999). La valeur DECIMAL est toutefois stockée sous forme de nombre exact et est arrondie à 0,01 comme prévu dans tous les cas.

Créer et charger une table :

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

Copy

Montrer des exemples de différence entre les valeurs arrondies FLOAT et les valeurs arrondies DECIMAL :

SELECT f,
       ROUND(f, 2),
       d,
       ROUND(d, 2)
  FROM rnd1
  ORDER BY 1;

Copy

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