Categorias:

Funções numéricas (Arredondamento e truncamento)

ROUND

Retorna valores arredondados para input_expr.

Consulte também:

CEIL , FLOOR , TRUNCATE , TRUNC

Sintaxe

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

Argumentos

Obrigatório:

input_expr . OR . EXPR => input_expr

O valor ou expressão a ser utilizado. O tipo de dados deve ser um dos tipos de dados numéricos, como FLOAT ou NUMBER.

Se você especificar o argumento nomeado EXPR =>, também deverá especificar o argumento nomeado SCALE =>.

Opcional:

scale_expr . OR . SCALE => scale_expr

O número de dígitos que a saída deve incluir após o ponto decimal. A expressão deve ser avaliada como um número inteiro de -38 a +38.

O padrão scale_expr é zero, o que significa que a função remove todos os dígitos após o ponto decimal.

Para obter mais informações sobre números negativos, consulte as Notas de uso abaixo.

Se você especificar o argumento nomeado SCALE =>, deverá especificar EXPR => como o argumento nomeado anterior.

rounding_mode . OR . ROUNDING_MODE => rounding_mode

O modo de arredondamento a ser usado. Especifique um dos seguintes valores:

Padrão: 'HALF_AWAY_FROM_ZERO'

Se você especificar o argumento nomeado ROUNDING_MODE =>, deverá especificar EXPR => e SCALE => como argumentos nomeados anteriores.

Nota

Se você especificar qualquer um dos valores para o argumento rounding_mode, o tipo de dados input_expr deve ser um dos tipos de dados para um número de ponto fixo.

Os tipos de dados para números de ponto flutuante (por exemplo, FLOAT) não são suportados com este argumento.

Retornos

O tipo de retorno é baseado no tipo de entrada:

  • Se a entrada for FLOAT, o tipo de dados do valor retornado será FLOAT.

  • Se a entrada for NUMBER, o tipo de dados do valor retornado será NUMBER.

    Se a escala de entrada for maior ou igual a zero, a escala de saída geralmente corresponde à escala de entrada.

    Se a escala de entrada for negativa, a escala de saída será 0.

    Por exemplo:

    • O tipo de dados retornado por ROUND(3.14::NUMBER(4, 1), 1) é NUMBER(4, 1).

    • O tipo de dados retornado por ROUND(3.14::NUMBER(4, 0), 0) é NUMBER(4, 0).

Se a escala for zero, o valor será efetivamente um número inteiro.

Notas de uso

  • Você deve especificar todos os argumentos por nome ou por posição. Você não pode especificar alguns dos argumentos por nome e outros argumentos por posição.

    Ao especificar um argumento por nome, você não pode usar aspas duplas no nome do argumento.

  • Se scale_expr for negativo, ele especificará o número de casas antes do ponto decimal para ajustar o número. Por exemplo, se a escala for -2, o resultado será um múltiplo de 100.

  • Se scale_expr for maior do que a escala de expressão de entrada, a função não tem qualquer efeito.

  • Se o input_expr ou o scale_expr for NULL, o resultado será NULL.

  • Por padrão, os meios pontos são arredondadas para cima para os decimais. Por exemplo, -0,5 é arredondado para -1,0.

    Para mudar o modo de arredondamento para arredondar o valor para o par mais próximo (por exemplo, para arredondar -0,5 para 0), passe em 'HALF_TO_EVEN' para o argumento rounding_mode.

    Nota

    Se você especificar o argumento rounding_mode, o tipo de dados do argumento input_expr deve ser um dos tipos de dados para um número de ponto fixo.

  • Os números de pontos flutuantes são valores aproximados. Um número de ponto flutuante pode não arredondar como esperado.

  • Se o arredondamento colocar o número fora do intervalo de valores do tipo de dados, a função retornará um erro.

Exemplos

Este primeiro exemplo mostra um uso simples de ROUND, com o número padrão de casas decimais (0):

SELECT ROUND(135.135), ROUND(-975.975);
+----------------+-----------------+
| ROUND(135.135) | ROUND(-975.975) |
|----------------+-----------------|
|            135 |            -976 |
+----------------+-----------------+
Copy

O próximo exemplo utiliza uma gama de valores para o parâmetro de escala:

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

Os próximos dois exemplos mostram a diferença entre o uso do modo de arredondamento padrão ('HALF_AWAY_FROM_ZERO') e o modo de arredondamento 'HALF_TO_EVEN': Ambos os exemplos chamam a função ROUND duas vezes, primeiro com o comportamento de arredondamento padrão e depois com 'HALF_TO_EVEN'.

O primeiro exemplo usa um valor de entrada positivo 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 |
+---------------+-------------------------------+

O segundo exemplo usa um valor de entrada negativo 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 |
+---------------+--------------------------------+

Os próximos dois exemplos mostram como especificar os argumentos para a função por nome, em vez de por posição.

SELECT ROUND(
  EXPR => -2.5,
  SCALE => 0);
Copy
+---------------------------------+
| ROUND(EXPR => -2.5, SCALE => 0) |
|---------------------------------|
|                              -3 |
+---------------------------------+

SELECT ROUND(
  EXPR => -2.5,
  SCALE => 0,
  ROUNDING_MODE => 'HALF_TO_EVEN');
Copy
+------------------------------------------------------------------+
| ROUND(EXPR => -2.5, SCALE => 0, ROUNDING_MODE => 'HALF_TO_EVEN') |
|------------------------------------------------------------------|
|                                                               -2 |
+------------------------------------------------------------------+

O próximo exemplo mostra que os valores FLOAT nem sempre são armazenados exatamente. Como você pode ver abaixo, em alguns casos ,005 é arredondado para ,01, enquanto em outros casos é arredondado para 0. A diferença não está no arredondamento; a diferença está na realidade na representação subjacente do número do ponto flutuante; 1.005 é armazenado como um número muito menor que 1.005 (aproximadamente 1,004999). O valor DECIMAL, entretanto, é armazenado como um número exato, e é arredondado para ,01 como esperado em todos os casos.

Criar e carregar uma tabela:

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

Mostrar exemplos da diferença entre os valores arredondados FLOAT e os valores arredondados DECIMAL:

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 |
+---------+-------------+---------+-------------+
Copy
Linguagem: Português