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

Copy

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

Copy

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.