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.

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.

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'

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, então o tipo de dados do valor retornado será FLOAT.

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

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

    Se a escala de entrada é negativa, então a escala de saída é 0.

    Por exemplo:

    • O tipo de dados devolvidos por ROUND(3,14::NUMBER(4, 1), 1) é NUMBER(4, 1).

    • O tipo de dados devolvidos por ROUND(3,14::NUMBER(4, 0), 0) é NUMBER(4, 0).

Se a escala for zero, então o valor é 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, então ele especificará o número de casas antes do ponto decimal para ajustar o número. Por exemplo, se a escala for -2, então 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, então 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 trouxer o número fora do intervalo de valores do tipo de dados, então um erro é retornado.

Exemplos

Este primeiro exemplo mostra um exemplo 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

O próximo exemplo mostra a diferença entre o modo de arredondamento padrão ('HALF_AWAY_FROM_ZERO') e o modo de arredondamento 'HALF_TO_EVEN':

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

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 próximo exemplo demonstra como especificar os argumentos para a função por nome, em vez de por posição.

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