Tipos de dados numéricos¶

Este tópico descreve os tipos de dados numéricos compatíveis no Snowflake, juntamente com os formatos compatíveis para constantes e literais numéricos.

Tipos de dados para números de ponto fixo¶

O Snowflake oferece suporte aos seguintes tipos de dados para números de ponto fixo.

NUMBER¶

Números até 38 dígitos, com precisão e escala opcionais:

Precisão:: Número total de dígitos permitidos.
Escala:: Número de dígitos permitidos à direita da vírgula decimal.

Por padrão, a precisão é 38 e a escala é 0; ou seja, NUMBER(38, 0). A precisão limita o intervalo de valores que podem ser inseridos ou convertidos em colunas de um determinado tipo. Por exemplo, o valor 999 se encaixa em NUMBER(38,0), mas não em NUMBER(2,0).

Como a precisão é o número total de dígitos permitidos, você não poderá carregar um valor em uma coluna NUMBER se o número de dígitos à esquerda da vírgula decimal exceder a precisão da coluna menos a escala dela. Por exemplo, NUMBER(20, 2) permite 18 dígitos à esquerda da vírgula decimal e dois dígitos à direita, totalizando 20 dígitos.

A escala máxima, que é o número de dígitos à direita da vírgula decimal, é 37. Os números com menos de 38 dígitos significativos, mas cuja menor casa decimal está além da 37ª posição, como 0,0000000000000000000000000000000000000012 (1,2e-39), não podem ser representados sem perder alguns dígitos de precisão.

Nota

Se os dados forem convertidos para outro tipo de dados com menor precisão e, em seguida, convertidos de volta para o tipo de dados de maior precisão, os dados podem perder precisão. Por exemplo, a precisão é perdida se você converter um valor NUMBER(38,37) para um valor DOUBLE (que tem uma precisão de aproximadamente 15 dígitos decimais) e depois de volta para NUMBER.

O Snowflake também oferece suporte ao tipo de dados FLOAT, o que permite uma gama mais ampla de valores, embora com menos precisão.

DECIMAL , DEC , NUMERIC¶

Sinônimo de NUMBER.

INT , INTEGER , BIGINT , SMALLINT , TINYINT , BYTEINT¶

Sinônimo de NUMBER, exceto pelo fato de que a precisão e a escala não podem ser especificadas (ou seja, o padrão é sempre NUMBER(38, 0)). Portanto, para todos os tipos de dados INTEGER, o intervalo de valores abrange todos os valores inteiros a partir de -99999999999999999999999999999999999999 até +99999999999999999999999999999999999999 (inclusive).

Os vários nomes (por exemplo, TINYINT, BYTEINT e assim por diante) servem para simplificar a portabilidade de outros sistemas e sugerir o intervalo esperado de valores para uma coluna do tipo especificado.

Impacto da precisão e da escala no tamanho de armazenamento¶

A precisão (o número total de dígitos) não afeta o armazenamento. Os requisitos de armazenamento para o mesmo número em colunas com diferentes precisões, como NUMBER(2,0) e NUMBER(38,0), são os mesmos. Para cada micropartição, o Snowflake determina os valores mínimo e máximo para uma determinada coluna e usa essa informação para determinar o tamanho de armazenamento para todos os valores dessa coluna na partição. Por exemplo:

Se uma coluna contiver apenas valores entre -128 e +127, cada um dos valores consumirá 1 byte (sem compressão).
Se o maior valor na coluna for 10000000, cada um dos valores consumirá 4 bytes (sem compressão).

Entretanto, a escala (o número de dígitos após o ponto decimal) afeta o armazenamento. Por exemplo, o mesmo valor armazenado em uma coluna do tipo NUMBER(10,5) consome mais espaço do que NUMBER(5,0). Além disso, o processamento de valores com uma escala maior pode ser um pouco mais lento e consumir mais memória.

Para economizar espaço, o Snowflake comprime os valores antes de gravá-los no armazenamento. A quantidade de compressão depende dos valores dos dados e de outros fatores.

Exemplos de tipos de dados de ponto fixo em uma tabela¶

A instrução a seguir cria uma tabela com colunas de vários tipos de dados de ponto fixo:

CREATE OR REPLACE TABLE test_fixed(
  num0 NUMBER,
  num10 NUMBER(10,1),
  dec20 DECIMAL(20,2),
  numeric30 NUMERIC(30,3),
  int1 INT,
  int2 INTEGER);

DESC TABLE test_fixed;

Copy

+-----------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
| name      | type         | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
|-----------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
| NUM0      | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| NUM10     | NUMBER(10,1) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| DEC20     | NUMBER(20,2) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| NUMERIC30 | NUMBER(30,3) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| INT1      | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| INT2      | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+-----------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+

Tipos de dados para números de ponto flutuante¶

O Snowflake oferece suporte aos seguintes tipos de dados para números de ponto flutuante.

FLOAT , FLOAT4 , FLOAT8¶

Os nomes FLOAT, FLOAT4 e FLOAT8 são para fins de compatibilidade com outros sistemas. O Snowflake trata todos os três como números de ponto flutuante de 64 bits.

Precisão¶

O Snowflake utiliza números de ponto flutuante de precisão dupla (64 bits) IEEE 754.

A precisão é de aproximadamente 15 dígitos. Por exemplo, para números inteiros, o intervalo é de -9007199254740991 a +9007199254740991 (-2 ⁵³ + 1 a +2 ⁵³ – 1). Os valores de ponto flutuante podem variar de aproximadamente 10^-308 a 10⁺³⁰⁸. O Snowflake pode representar valores mais extremos aproximadamente entre 10^-324 e 10^-308 com menos precisão. Para obter mais detalhes, consulte o artigo da Wikipédia sobre números de precisão dupla.

O Snowflake oferece suporte ao tipo de dados de ponto fixo NUMBER, que permite maior precisão, embora uma gama menor de expoentes.

Valores especiais¶

O Snowflake oferece suporte aos seguintes valores especiais para FLOAT:

'NaN' (não é um número)
'inf' (infinito)
'-inf' (infinito negativo)

Os símbolos 'NaN', 'inf' e '-inf' devem estar entre aspas simples e fazem a distinção entre maiúsculas e minúsculas.

A semântica comparativa para 'NaN' difere do padrão IEEE 754 das seguintes maneiras:

Condição	Snowflake	IEEE 754	Comentário
`'NaN' = 'NaN'`	`TRUE`	`FALSE`	No Snowflake, os valores `'NaN'` são todos iguais.
`'NaN' > X` ., em que `X` é qualquer valor FLOAT, incluindo . infinito, diferente de `NaN` em si.	`TRUE`	`FALSE`	No Snowflake, `'NaN'` é maior . do que qualquer outro valor FLOAT, . incluindo infinito.

Erros de arredondamento¶

As operações de ponto flutuante podem apresentar pequenos erros de arredondamento nos dígitos menos significativos. Erros de arredondamento podem ocorrer em qualquer tipo de processamento de ponto flutuante, incluindo funções trigonométricas, estatísticas e geoespaciais.

A lista a seguir mostra considerações sobre erros de arredondamento:

Os erros podem variar a cada vez que a consulta é executada.
Os erros podem ser maiores quando os operandos têm precisão ou escala diferente.
Os erros podem se acumular, especialmente quando funções de agregação (por exemplo, SUM ou AVG) processam um grande número de linhas. Converter em um tipo de dados de ponto fixo antes de agregar pode reduzir ou eliminar esses erros.
Erros de arredondamento podem ocorrer não apenas ao trabalhar com SQL, mas também ao trabalhar com outro código (por exemplo, Java, JavaScript ou Python) executado dentro do Snowflake (por exemplo, em UDFs e procedimentos armazenados).
Ao comparar dois números de ponto flutuante, o Snowflake recomenda a comparação para uma igualdade aproximada, em vez de uma igualdade exata.

Pode ser possível evitar esses tipos de erros de aproximação usando o tipo de dados DECFLOAT exato.

DOUBLE , DOUBLE PRECISION , REAL¶

Sinônimo de FLOAT.

Exemplos de tipos de dados de ponto flutuante em uma tabela¶

A instrução a seguir cria uma tabela com colunas de vários tipos de dados de ponto flutuante:

CREATE OR REPLACE TABLE test_float(
  double1 DOUBLE,
  float1 FLOAT,
  dp1 DOUBLE PRECISION,
  real1 REAL);

DESC TABLE test_float;

Copy

+---------+-------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
| name    | type  | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
|---------+-------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
| DOUBLE1 | FLOAT | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| FLOAT1  | FLOAT | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| DP1     | FLOAT | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| REAL1   | FLOAT | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+---------+-------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+

Nota

A coluna DESC do comando TABLE type exibe o tipo de dados FLOAT não apenas para FLOAT, mas também para sinônimos de FLOAT (por exemplo, DOUBLE, DOUBLE PRECISION e REAL).

DECFLOAT¶

O tipo de dados do ponto flutuante decimal (DECFLOAT) armazena os números de maneira exata, com até 38 dígitos significativos de precisão, e usa um expoente dinâmico de base 10 para representar valores muito grandes ou muito pequenos. O intervalo do expoente é de -16383 a 16384, permitindo valores aproximadamente entre -10^(16384) e 10^(16384). O tipo de dados DECFLOAT é compatível com uma escala variável, de modo que a escala varia dependendo do valor específico que está sendo armazenado. Ao contrário do tipo de dados FLOAT, que representa valores como aproximações, o tipo de dados DECFLOAT representa valores exatos na precisão especificada.

O tipo de dados DECFLOAT não é compatível com os seguintes valores especiais que são compatíveis com o tipo de dados FLOAT: 'NaN' (não é um número), 'inf' (infinito) e '-inf' (infinito negativo).

Casos de uso para o tipo de dados DECFLOAT¶

Use o tipo de dados DECFLOAT quando precisar de resultados decimais exatos e uma escala ampla e variável na mesma coluna.

O tipo de dados DECFLOAT é apropriado para os seguintes casos de uso gerais:

Você está ingerindo dados e a escala dos valores numéricos recebidos é desconhecida ou altamente variável.
Você precisa de valores numéricos exatos; por exemplo, para livros contábeis, impostos ou conformidade.
Você está migrando de sistemas que dependem da representação decimal de 754 bits da IEEE ou decimais de 128 bits. Essas migrações podem ser bloqueadas pelas limitações de precisão ou intervalo de outros tipos de dados do Snowflake.
Você deseja evitar erros Number out of representable range ao somar, multiplicar ou dividir valores numéricos de alta precisão.

Por exemplo, você pode usar o tipo de dados DECFLOAT para os seguintes casos de uso específicos:

Você está ingerindo dados com escalas heterogêneas de colunas Oracle DECIMAL ou DB2 DECFLOAT.
Você está realizando uma modelagem financeira que envolve cálculos com escalas de resultados difíceis de prever.
Você está executando medições científicas que variam de nanounidades a unidades astronômicas.

Você pode continuar usando o tipo de dados NUMBER para colunas numéricas de escala fixa ou o tipo de dados FLOAT para análises de alto rendimento em que resultados imprecisos são aceitáveis.

Notas de uso para o tipo de dados DECFLOAT¶

Se uma operação produzir um resultado com mais de 38 dígitos, o valor DECFLOAT será arredondado para uma precisão de 38 dígitos, com os dígitos menos significativos arredondados de acordo com o modo de arredondamento atual. O Snowflake usa o modo de arredondamento “metade para cima” para valores DECFLOAT.
Quando você especificar um valor DECFLOAT ou converter para um valor DECFLOAT, evite usar literais numéricos em SQL. Se você usar literais numéricos em SQL, os valores serão interpretados como valores NUMBER ou FLOAT antes de serem convertidos para um valor DECFLOAT, o que pode resultar em erros de intervalo ou perda de exatidão. Em vez disso, use literais de cadeia de caracteres (como SELECT '<value>'::DECFLOAT) ou o literal DECFLOAT, como SELECT DECFLOAT '<value>'.
Quando as operações misturam valores DECFLOAT e valores de outros tipos numéricos, a coerção prefere os DECFLOAT. Por exemplo, quando você soma um valor do tipo NUMBER e um do tipo DECFLOAT, o resultado é um valor DECFLOAT.
O uso do tipo DECFLOAT pode aumentar o consumo de armazenamento.

Drivers e versões de drivers que são compatíveis com o tipo de dados DECFLOAT¶

Os seguintes drivers e versões de drivers do Snowflake são compatíveis com o tipo de dados DECFLOAT. Talvez você precise atualizar seus drivers para as versões que são compatíveis com DECFLOAT:

Driver	Versão mínima aceita	Notas
Conector Snowflake para Python	3.14.1	DataFrames do pandas não é compatível com o tipo DECFLOAT.
ODBC	3.12.0	Nenhum.
JDBC	3.27.0	Nenhum.
Driver Go Snowflake	1.17.0	Nenhum.
SQL API	2.0.0	Nenhum.

Drivers não compatíveis tratam valores DECFLOAT como valores TEXT. Para alguns drivers, um parâmetro do driver deve ser definido para mapear o tipo DECFLOAT para um tipo nativo da linguagem. Para obter mais informações, consulte Drivers.

Limitações do tipo de dados DECFLOAT¶

As seguintes limitações se aplicam ao tipo DECFLOAT:

Um valor DECFLOAT não pode ser armazenado como tipo de dados semiestruturados ou tipo de dados estruturados.

Para armazenar um valor DECFLOAT como uma cadeia de caracteres para um desses tipos, você pode converter o valor DECFLOAT em um valor VARCHAR.
Valores DECFLOAT não são compatíveis com os seguintes tipos de tabelas:
- Tabelas em formatos externos, como Iceberg
- Tabelas híbridas
O tipo de dados DECFLOAT não é compatível com procedimentos armazenados ou funções definidas pelo usuário (User-Defined Functions, UDFs) escritas em uma linguagem diferente de SQL, como Python ou Java.
O tipo de dados DECFLOAT não é compatível com o Snowpark.
O Snowsight tem compatibilidade limitada para o tipo de dados DECFLOAT.
Os seguintes recursos não são compatíveis com o tipo de dados DECFLOAT:
Os tipos NUMBER e FLOAT podem fornecer melhor desempenho do que o tipo DECFLOAT.

Exemplos para o tipo de dados DECFLOAT¶

Os exemplos a seguir usam o tipo de dados DECFLOAT:

Mostrar as diferenças entre DECFLOAT e FLOAT
Usar valores DECFLOAT com funções de agregação

Mostrar as diferenças entre DECFLOAT e FLOAT¶

O exemplo a seguir mostra as diferenças entre os tipos de dados DECFLOAT e FLOAT:

Crie uma tabela com uma coluna DECFLOAT e uma FLOAT e, em seguida, insira os mesmos valores para ambos os tipos na tabela:

CREATE OR REPLACE TABLE decfloat_sample (
  id INT,
  decfloat_val DECFLOAT,
  float_val FLOAT);

INSERT INTO decfloat_sample VALUES
  (
    1,
    DECFLOAT '123e7000',
    FLOAT '123e7000'
  ),
  (
    2,
    12345678901234567890123456789::DECFLOAT,
    12345678901234567890123456789::FLOAT
  ),
  (
    3,
    '-4.2e-5432'::DECFLOAT,
    '-4.2e-5432'::FLOAT
  ),
  (
    4,
    '1.00000000000000000000000000000000000014'::DECFLOAT,
    '1.00000000000000000000000000000000000014'::FLOAT
  ),
  (
    5,
    '1.00000000000000000000000000000000000015'::DECFLOAT,
    '1.00000000000000000000000000000000000015'::FLOAT
  );

Copy

A instrução insere valores DECFLOAT das seguintes maneiras:

O primeiro valor é inserido usando o literal DECFLOAT.
O segundo valor é inserido pela conversão de um valor INTEGER para um valor DECFLOAT.
O terceiro, quarto e quinto valores são inseridos pela conversão de um valor VARCHAR para um valor DECFLOAT.

Para mostrar os tipos, descreva a tabela usando o comando DESC TABLE.

A precisão não foi especificada na definição da tabela para nenhuma das colunas, mas a saída mostra que o tipo de dados DECFLOAT é compatível com até 38 dígitos significativos de precisão:

DESC TABLE decfloat_sample;

Copy

+--------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
| name         | type         | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
|--------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
| ID           | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| DECFLOAT_VAL | DECFLOAT(38) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| FLOAT_VAL    | FLOAT        | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+--------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+

Para mostrar as diferenças nos valores, consulte a tabela usando a instrução SELECT:
```
SELECT * FROM decfloat_sample;
```
Copy
```
+----+-----------------------------------------+------------------------+
| ID | DECFLOAT_VAL                            |              FLOAT_VAL |
|----+-----------------------------------------+------------------------|
|  1 | 1.23e7002                               | inf                    |
|  2 | 12345678901234567890123456789           |   1.23456789012346e+28 |
|  3 | -4.2e-5432                              |  -0                    |
|  4 | 1.0000000000000000000000000000000000001 |   1                    |
|  5 | 1.0000000000000000000000000000000000002 |   1                    |
+----+-----------------------------------------+------------------------+
```
A saída mostra as seguintes diferenças:
- A primeira linha mostra que o tipo DECFLOAT é compatível com uma gama maior de valores do que o tipo FLOAT. O valor DECFLOAT é muito grande (1.23e7002). O valor FLOAT é inf, o que significa que o valor é maior do que qualquer um que o tipo FLOAT possa representar.
- A segunda linha mostra que o tipo DECFLOAT retém o valor especificado exatamente. O valor FLOAT é uma aproximação que é armazenada em notação científica.
- A terceira linha mostra que o tipo DECFLOAT é compatível com valores muito pequenos (-4.2e-5432). O valor FLOAT é aproximado para -0.
- A quarta e a quinta linhas mostram que o tipo DECFLOAT é compatível com até 38 dígitos de precisão e usa regras de arredondamento para valores além do limite. O valor FLOAT é aproximado para 1 em ambas as linhas.

Usar valores DECFLOAT com funções de agregação¶

O exemplo a seguir usa valores DECFLOAT com funções de agregação:

Crie uma tabela e insira valores DECFLOAT na tabela:

CREATE OR REPLACE TABLE decfloat_agg_sample (decfloat_val DECFLOAT);

INSERT INTO decfloat_agg_sample VALUES
  (DECFLOAT '1e1000'),
  (DECFLOAT '-2.47e999'),
  (DECFLOAT '22e-75');

Copy

Consulte a tabela usando algumas funções de agregação:

SELECT SUM(decfloat_val),
       AVG(decfloat_val),
       MAX(decfloat_val),
       MIN(decfloat_val)
  FROM decfloat_agg_sample;

Copy

+-------------------+-------------------+-------------------+-------------------+
| SUM(DECFLOAT_VAL) | AVG(DECFLOAT_VAL) | MAX(DECFLOAT_VAL) | MIN(DECFLOAT_VAL) |
|-------------------+-------------------+-------------------+-------------------|
| 7.53e999          | 2.51e999          | 1e1000            | -2.47e999         |
+-------------------+-------------------+-------------------+-------------------+

Constantes numéricas¶

O termo constantes (também conhecido como literais) refere-se a valores de dados fixos. Os seguintes formatos são aceitos para constantes numéricas:

[+-][digits][.digits][e[+-]digits]

Onde:

+ ou - indica um valor positivo ou negativo. O padrão é positivo.
digits é um ou mais dígitos de 0 a 9.
e (ou E) indica um expoente em notação científica. Pelo menos um dígito deve seguir o marcador do expoente, se presente.

Os números a seguir são exemplos de constantes numéricas aceitas:

15
+1.34
0.2
15e-03
1.234E2
1.234E+2
-1