Operadores aritméticos

Os operadores aritméticos são usados para gerar uma saída numérica a partir de uma ou mais expressões de entrada.

As expressões de entrada devem ser numéricas (ponto fixo ou ponto flutuante), exceto nos seguintes casos:

  • O operador unário + pode tomar uma cadeia de caracteres numérica, mas isso faz com que a cadeia seja implicitamente convertida em seu valor numérico correspondente.

  • O operador binário - pode ser aplicado às expressões DATE.

Neste tópico:

Lista de operadores aritméticos

Operador

Sintaxe

Descrição

+ (unário)

+a

Retorna a, o que provocará a conversão implícita de a em um valor numérico. Se a for uma cadeia de caracteres, mas a cadeia não puder ser convertida em um valor numérico, um erro é retornado.

+

a + b

Acrescenta duas expressões numéricas (a e b).

- (unário)

-a

Nega a expressão numérica de entrada.

-

a - b

Subtrai uma expressão numérica (b) de outra (a).

-

a - b

Subtrai uma expressão de data (b) de outra (a). O resultado é um número inteiro de dias. A subtração é a única operação aritmética permitida nas expressões DATE.

*

a * b

Multiplica duas expressões numéricas (a e b).

/

a / b

Divide uma expressão numérica (a) por outra (b). Para funções que retornam 0 quando divididas por 0 ou NULL, consulte DIV0 e DIV0NULL.

%

a % b

Calcula o módulo da expressão numérica a por b. Consulte também MOD.

Escala e precisão em operações aritméticas

A escala e precisão da saída de uma operação aritmética depende da escala e precisão da(s) entrada(s).

Esta seção descreve os cálculos que o Snowflake utiliza para preservar a escala e a precisão na saída numérica gerada por várias operações aritméticas (multiplicação, divisão etc.). As seguintes descrições são usadas nesta seção:

Dígitos iniciais

Número de dígitos (L) à esquerda da vírgula decimal em um valor numérico.

Escala

Número de dígitos (S) à direita da vírgula decimal em um valor numérico.

Precisão

Número total de dígitos (P) em um valor numérico, calculado como a soma de seus dígitos iniciais e escala (isto é, P = L + S). Note que a precisão no Snowflake é sempre limitada a 38.

Além disso:

  • Os tipos de dados de ponto fixo (NUMBER, DECIMAL etc.) utilizam precisão e escala. Por exemplo, para o tipo de dados DECIMAL(8,2), a precisão é 8, a escala é 2, e os dígitos iniciais são 6.

  • Os tipos de dados de ponto flutuante (FLOAT, DOUBLE, REAL etc.) utilizam duplas de 8 bytes.

Para saídas, observe que esses são o número máximo de dígitos; o número real de dígitos para uma determinada saída pode ser menor.

Multiplicação

Ao realizar a multiplicação:

  • O número de dígitos iniciais na saída é a soma dos dígitos iniciais em ambas as entradas.

  • Para minimizar o potencial excedente (devido à multiplicação em cadeia), o Snowflake adiciona o número de dígitos na escala de ambas as entradas, até um limite máximo de 12 dígitos, a menos que uma das entradas tenha uma escala maior que 12, caso em que a escala de entrada maior é usada como escala de saída.

Em outras palavras, considerando uma operação de multiplicação com duas entradas (L1.S1 e L2.S2), o número máximo de dígitos na saída é calculado da seguinte forma:

Dígitos iniciais

L = L1 + L2

Escala

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

Precisão

P = L + S

Nota

O Snowflake realiza a multiplicação de inteiros para valores numéricos, portanto, resultados intermediários podem causar algum excedente; entretanto, a saída final não excederá.

Exemplos

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

Divisão

Ao realizar a divisão:

  • Os dígitos iniciais para a saída são a soma dos dígitos iniciais do numerador e a escala do denominador.

  • Para minimizar o potencial de excedente na saída (devido à divisão em cadeia) e perda de escala, o Snowflake adiciona 6 dígitos à escala do numerador, até um limite máximo de 12 dígitos, a menos que a escala do numerador seja maior que 12, caso em que a escala do numerador é usada como escala de saída.

Em outras palavras, considerando uma operação de divisão com numerador L1.S1 e denominador L2.S2, o número máximo de dígitos na saída é calculado da seguinte forma:

Dígitos iniciais

L = L1 + S2

Escala

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

Precisão

P = L + S

Se o resultado da operação de divisão exceder a escala de saída, o Snowflake arredonda a saída (em vez de truncar a saída).

Nota

Semelhante à multiplicação, os resultados da divisão intermediária podem causar algum excedente; entretanto, a saída final não excederá.

Exemplos

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

Adição e subtração

Para adição ou subtração:

  • Os dígitos iniciais para a saída são o maior número de dígitos iniciais das entradas mais 1 (para preservar os valores transportados).

  • A escala para a saída é a maior escala das entradas.

Em outras palavras, supondo que uma operação de adição ou subtração tenha duas entradas (L1.S1 e L2.S2), o número máximo de dígitos na saída é calculado da seguinte forma:

Dígitos iniciais

L = max(L1, L2) + 1

Escala

S = max(S1, S2)

Precisão

P = L + S

Outras operações eneárias

Para todas as outras operações aritméticas com mais de uma entrada numérica, como módulo (a % b ou MOD):

  • Os dígitos iniciais para a saída são o maior número de dígitos iniciais das entradas.

  • A escala para a saída é a maior escala das entradas.

Em outras palavras, considerando uma operação eneária com entradas L1.S1, L2.S2 etc., o número máximo de dígitos na saída é calculado da seguinte forma:

Dígitos iniciais

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

Escala

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

Precisão

P = L + S

Operações unárias

Operações aritméticas unárias têm a mesma precisão e escala de saída que a precisão e escala de entrada, exceto para ROUND, que permite especificar explicitamente a escala de saída.

Operações bit a bit

A lista de operações aritméticas bit a bit aceitas está disponível em Funções de expressão condicional.

Nota:

  • Para valores numéricos, as operações bit a bit operam apenas nos dígitos iniciais na entrada. A saída tem sempre uma escala de zero.

  • Para operações bit a bit binárias, a saída tem o mesmo número de dígitos iniciais que os dígitos iniciais máximos na entrada.