Types de données numériques¶

Cette rubrique décrit les types de données numériques pris en charge dans Snowflake, ainsi que les formats pris en charge pour les constantes et les littéraux numériques.

Types de données pour les numéros à virgule fixe¶

Snowflake prend en charge les types de données suivants pour les nombres à virgule fixe.

NUMBER¶

Nombres jusqu’à 38 chiffres, avec une précision et une échelle facultatives :

Précision:: Nombre total de chiffres permis.
Échelle:: Nombre de chiffres autorisés à droite de la virgule décimale.

Par défaut, la précision est 38 et l’échelle est 0, c’est-à-dire NUMBER(38,0). La précision limite la plage des valeurs qui peuvent être insérées ou converties dans les colonnes d’un type donné. Par exemple, la valeur 999 correspond à NUMBER(38,0) mais pas à NUMBER(2,0).

Étant donné que la précision correspond au nombre total de chiffres autorisés, vous ne pouvez pas charger une valeur dans une colonne NUMBER si le nombre de chiffres à gauche de la virgule décimale dépasse la précision de la colonne moins son échelle. Par exemple, NUMBER(20, 2) autorise 18 chiffres à gauche de la virgule décimale et 2 chiffres à droite de la virgule décimale, pour un total de 20 chiffres.

L’échelle maximale, qui correspond au nombre de chiffres à droite de la virgule décimale, est 37. Les nombres qui présentent moins de 38 chiffres significatifs, mais dont le chiffre le moins significatif se trouve au-delà de la 37e décimale (par exemple, 0,0000000000000000000000000000000000000012 (1,2e -39)), ne peuvent pas être représentés sans perdre quelques chiffres de précision.

Note

Si les données sont converties dans un autre type de données avec une précision moindre, puis reconverties dans le type de données de précision plus élevée, les données peuvent perdre en précision. Par exemple, vous perdez en précision si vous convertissez une valeur NUMBER(38,37) en valeur DOUBLE (qui possède une précision d’environ 15 chiffres décimaux), avant de reconvertir celle-ci en NUMBER.

Snowflake prend également en charge le type de données FLOAT , qui permet une plus grande plage de valeurs, mais avec moins de précision.

DECIMAL , DEC , NUMERIC¶

Synonyme de NUMBER.

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

Synonymes de NUMBER, sauf que la précision et l’échelle ne peuvent pas être spécifiées (c’est-à-dire que la valeur par défaut est toujours NUMBER(38,0)). Par conséquent, pour tous les types de données INTEGER, la plage de valeurs comprend toutes les valeurs entières de -99999999999999999999999999999999999999 à +99999999999999999999999999999999999999 (inclus).

Les différents noms (par exemple, TINYINT, BYTEINT, et ainsi de suite) visent à simplifier le portage à partir d’autres systèmes et à suggérer la plage de valeurs attendue pour une colonne du type spécifié.

Impact de la précision et de l’échelle sur la taille de stockage¶

La précision (nombre total de chiffres) n’a pas d’incidence sur le stockage. Les exigences de stockage pour le même nombre de colonnes dans des colonnes de précision différente, telles que NUMBER(2,0) et NUMBER(38,0), sont identiques. Pour chaque micro-partition, Snowflake détermine les valeurs minimales et maximales pour une colonne donnée et utilise ces informations pour déterminer la taille de stockage de toutes les valeurs pour cette colonne dans la partition. Par exemple :

Si une colonne ne contient que des valeurs comprises entre -128 et +127, chacune de ces valeurs consomme 1 octet (non compressé).
Si la plus grande valeur de la colonne est 10000000, chacune des valeurs consomme 4 octets (non compressés).

Cependant, l’échelle, c’est-à-dire le nombre de chiffres après la virgule décimale, a une incidence sur le stockage. Par exemple, la même valeur stockée dans une colonne de type NUMBER(10,5) consomme plus d’espace que NUMBER(5,0). De plus, le traitement de valeurs ayant une plus grande échelle pourrait être légèrement plus lent et consommer plus de mémoire.

Pour économiser de l’espace, Snowflake compresse les valeurs avant de les écrire dans le stockage. Le degré de compression dépend de la valeur des données et d’autres facteurs.

Exemples de types de données à point fixe dans une table¶

L’instruction suivante crée une table avec des colonnes de différents types de données à point fixe :

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

Types de données pour les numéros en virgule flottante¶

Snowflake prend en charge les types de données suivants pour les nombres à virgule flottante.

FLOAT , FLOAT4 , FLOAT8¶

Les noms FLOAT, FLOAT4 et FLOAT8 sont utilisés à des fins de compatibilité avec d’autres systèmes. Snowflake les traite tous les trois comme des nombres à virgule flottante de 64 bits.

Précision¶

Snowflake utilise des nombres à virgule flottante de double précision (bit64) IEEE 754.

La précision est d’environ 15 chiffres. Par exemple, pour les entiers, la plage est de -9007199254740991 à +9007199254740991 (-2⁵³ + 1 à +2⁵³ - 1). Les valeurs à virgule flottante peuvent aller d’environ 10^-308 à 10⁺³⁰⁸. Snowflake peut représenter des valeurs plus extrêmes comprises approximativement entre 10^-324 et 10^-308 avec moins de précision. Pour plus de détails, voir l’article de Wikipédia sur les numéros à double précision.

Snowflake prend en charge le type de données à point fixe NUMBER, qui permet une plus grande précision, bien que la gamme des exposants soit plus petite.

Valeurs spéciales¶

Snowflake prend en charge les valeurs spéciales suivantes pour FLOAT :

'NaN' (Pas un nombre)
'inf' (infini)
'-inf' (infini négatif)

Les symboles 'NaN', 'inf' et '-inf' doivent être entre guillemets simples et sont sensibles à la casse.

La sémantique de comparaison pour 'NaN' diffère de la norme IEEE 754 des manières suivantes :

Condition	Snowflake	IEEE 754	Commentaire
`'NaN' = 'NaN'`	`TRUE`	`FALSE`	Dans Snowflake, les valeurs `'NaN'` sont toutes égales.
`'NaN' > X` . où `X` est une valeur FLOAT, y compris un infini ., autre que `NaN` lui-même.	`TRUE`	`FALSE`	Dans Snowflake, `'NaN'` est considéré comme un . supérieur à toute autre valeur FLOAT, . y compris l’infini.

Erreurs d’arrondi¶

Les opérations en virgule flottante peuvent présenter de petites erreurs d’arrondi dans les chiffres les moins significatifs. Les erreurs d’arrondi peuvent se produire dans tout type de traitement à virgule flottante, y compris les trigonométriques, statistiques et géospatiales.

La liste suivante présente les considérations relatives aux erreurs d’arrondi :

Les erreurs peuvent varier à chaque exécution de la requête.
Les erreurs peuvent être plus importantes lorsque les opérandes ont une précision ou une échelle différente.
Les erreurs peuvent s’accumuler, en particulier lorsque des fonctions agrégées (par exemple, SUM ou AVG) traitent un grand nombre de lignes. Le fait d’utiliser un type de données à point fixe avant l’agrégation peut réduire ou éliminer ces erreurs.
Les erreurs d’arrondi peuvent se produire non seulement lors de l’utilisation de SQL, mais aussi lors de l’utilisation d’un autre code (par exemple, Java, JavaScript ou Python) qui s’exécute dans Snowflake (par exemple, dans les UDFs et les procédures stockées).
Lorsque vous comparez deux nombres à virgule flottante, Snowflake recommande d’effectuer une comparaison pour une égalité approximative plutôt qu’une égalité exacte.

Il pourrait être possible d’éviter ce type d’erreurs d’approximation en utilisant le type de données DECFLOAT exact.

DOUBLE , DOUBLE PRECISION , REAL¶

Synonyme de FLOAT.

Exemples de types de données à point flottant dans une table¶

L’instruction suivante crée une table avec des colonnes de divers types de données à virgule flottante :

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

Note

La colonne type de la commande DESC TABLE affiche le type de données FLOAT non seulement pour FLOAT, mais aussi pour les synonymes de FLOAT ; par exemple, DOUBLE, DOUBLE PRECISION et REAL.

DECFLOAT¶

Le type de données décimale à virgule flottante (DECFLOAT) stocke les nombres exactement, avec jusqu’à 38 chiffres significatifs de précision, et utilise un exposant dynamique de base -10 pour représenter les valeurs très grandes ou très petites. La plage de l’exposant est comprise entre -16383 et 16384, en permettant des valeurs approximativement comprises entre -10^(16384) et 10^(16384). Le type de données DECFLOAT prend en charge une échelle variable, de sorte que l’échelle varie en fonction de la valeur spécifique stockée. Contrairement au type de données FLOAT, qui représente les valeurs sous forme d’approximations, le type de données DECFLOAT représente des valeurs exactes dans la précision spécifiée.

Le type de données DECFLOAT ne prend pas en charge les valeurs spéciales suivantes qui sont prises en charge par le type de données FLOAT : 'NaN' (pas un nombre), 'inf' (infini) et '-inf' (infini négatif).

Cas d’utilisation pour le type de données DECFLOAT¶

Utilisez le type de données DECFLOAT lorsque vous avez besoin de résultats décimaux exacts et d’une échelle variable large dans la même colonne.

Le type de données DECFLOAT convient aux cas d’utilisation généraux suivants :

Vous ingérez des données, et l’échelle des valeurs numériques entrantes est inconnue ou hautement variable.
Vous avez besoin de valeurs numériques exactes ; par exemple, pour les grands livres, les taxes ou la conformité.
Vous migrez depuis des systèmes qui reposent sur la représentation décimale IEEE 754 ou des décimales 128 bits. Ces migrations peuvent être bloquées par les limitations de précision ou de plage d’autres types de données Snowflake.
Vous voulez éviter des erreurs Number out of representable range lorsque vous additionnez, multipliez ou divisez des valeurs numériques de haute précision.

Par exemple, vous pouvez utiliser le type de données DECFLOAT pour les cas d’utilisation spécifiques suivants :

Vous ingérez des données à échelle hétérogène provenant de colonnes Oracle DECIMAL ou DB2 DECFLOAT.
Vous effectuez une modélisation financière qui implique des calculs dont les échelles de résultats sont difficiles à prévoir.
Vous effectuez des mesures scientifiques qui varient entre des nano-unités et des unités astronomiques.

Vous pouvez continuer à utiliser le type de données NUMBER pour les colonnes numériques à échelle fixe ou le type de données FLOAT pour les analyses à haut débit où des résultats imprécis sont acceptables.

Notes sur l’utilisation du type de données DECFLOAT¶

Si une opération produit un résultat avec plus de 38 chiffres, la valeur DECFLOAT est arrondie à une précision de 38 chiffres, les chiffres les moins significatifs étant arrondis selon le mode d’arrondi actuel. Snowflake utilise le mode d’arrondi à la moitié supérieure pour les valeurs DECFLOAT.
Lorsque vous spécifiez une valeur DECFLOAT ou que vous la convertissez en valeur DECFLOAT, évitez d’utiliser des littéraux numériques en SQL. Si vous utilisez des littéraux numériques en SQL, les valeurs sont interprétées comme des valeurs NUMBER ou FLOAT avant d’être converties en valeur DECFLOAT, ce qui peut entraîner des erreurs de plage ou une perte de précision. Au lieu de cela, utilisez des littéraux de chaîne (comme SELECT '<value>'::DECFLOAT) ou le littéral DECFLOAT (comme SELECT DECFLOAT '<value>').
Lorsque les opérations mélangent des valeurs DECFLOAT avec des valeurs d’autres types numériques, la conversion forcée préfère les valeurs DECFLOAT. Par exemple, lorsque vous ajoutez une valeur de type NUMBER et une valeur de type DECFLOAT, le résultat est une valeur DECFLOAT.
Utiliser le type DECFLOAT peut entraîner une augmentation de la consommation de stockage.

Pilotes et versions de pilotes qui prennent en charge le type de données DECFLOAT¶

Les pilotes et les versions de pilotes Snowflake suivants prennent en charge le type de données DECFLOAT. Vous devrez peut-être mettre à jour vos pilotes vers les versions qui prennent en charge DECFLOAT :

Pilote	Version minimale prise en charge	Remarques
Connecteur Snowflake pour Python	3.14.1	Les DataFrames pandas ne prennent pas en charge le type DECFLOAT.
ODBC	3.12.0	Aucun.
JDBC	3.27.0	Aucun.
Pilote Go Snowflake	1.17.0	Aucun.
SQL API	2.0.0	Aucun.

Les pilotes non pris en charge traitent les valeurs DECFLOAT en tant que valeurs TEXT. Pour certains pilotes, un paramètre de pilote doit être défini pour mapper le type DECFLOAT vers un type natif de langage. Pour plus d’informations, voir Pilotes.

Limitations pour le type de données DECFLOAT¶

Les limitations suivantes s’appliquent pour le type DECFLOAT :

Une valeur DECFLOAT ne peut pas être stockée en tant que type de données semi-structurées ou type de données structurées.

Pour stocker une valeur DECFLOAT en tant que chaîne pour l’un de ces types, vous pouvez convertir la valeur DECFLOAT en valeur VARCHAR.
Les valeurs DECFLOAT ne sont pas prises en charge dans les types de tables suivants :
- Tables dans des formats externes, comme Iceberg
- Tables hybrides
Le type de données DECFLOAT n’est pas pris en charge dans les procédures stockées ou les fonctions définies par l’utilisateur (UDFs) écrites dans un langage autre que SQL, comme Python ou Java.
Le type de données DECFLOAT n’est pas pris en charge dans Snowpark.
Snowsight offre une prise en charge limitée pour le type de données DECFLOAT.
Les fonctionnalités suivantes ne prennent pas en charge le type de données DECFLOAT :
Les types NUMBER et FLOAT peuvent fournir de meilleures performances que le type DECFLOAT.

Exemples pour le type de données DECFLOAT¶

Les exemples suivants utilisent le type de données DECFLOAT :

Afficher les différences entre DECFLOAT et FLOAT
Utiliser des valeurs DECFLOAT avec des fonctions d’agrégation

Afficher les différences entre DECFLOAT et FLOAT¶

L’exemple suivant montre les différences entre les types de données DECFLOAT et FLOAT :

Créez une table avec une colonne DECFLOAT et une colonne FLOAT, puis insérez les mêmes valeurs pour les deux types dans la table :

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

L’instruction insère les valeurs DECFLOAT de la manière suivante :

La première valeur est insérée en utilisant le littéral DECFLOAT.
La deuxième valeur est insérée en convertissant une valeur INTEGER en valeur DECFLOAT.
Les troisième, quatrième et cinquième valeurs sont insérées en convertissant une valeur VARCHAR en valeur DECFLOAT.

Pour afficher les types, décrivez la table en utilisant la commande DESC TABLE.

La précision n’a pas été spécifiée dans la définition de la table pour l’une ou l’autre des colonnes, mais la sortie montre que le type de données DECFLOAT prend en charge jusqu’à 38 chiffres significatifs de précision :

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

Pour afficher les différences entre les valeurs, interrogez la table à l’aide de l’instruction 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                    |
+----+-----------------------------------------+------------------------+
```
La sortie montre les différences suivantes :
- La première ligne montre que le type DECFLOAT prend en charge un plus grand éventail de valeurs que le type FLOAT. La valeur DECFLOAT est très grande (1.23e7002). La valeur FLOAT est inf, ce qui signifie que cette valeur est plus grande que n’importe quelle valeur que le type FLOAT peut représenter.
- La deuxième ligne montre que le type DECFLOAT conserve exactement la valeur spécifiée. La valeur FLOAT est une approximation enregistrée en notation scientifique.
- La troisième ligne montre que le type DECFLOAT prend en charge de très petites valeurs (-4.2e-5432). La valeur FLOAT est approximativement égale à -0.
- Les quatrième et cinquième lignes montrent que le type DECFLOAT prend en charge jusqu’à 38 chiffres de précision et utilise des règles d’arrondi pour les valeurs au-delà de la limite. La valeur FLOAT est approximativement égale à 1 dans les deux lignes.

Utiliser des valeurs DECFLOAT avec des fonctions d’agrégation¶

L’exemple suivant utilise des valeurs DECFLOAT avec des fonctions d’agrégation :

Créez une table, puis insérez des valeurs DECFLOAT dans cette table :

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

Interrogez la table en utilisant des fonctions d’agrégation :

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ériques¶

Le terme constantes (aussi connues sous le nom de littéraux) fait référence à des valeurs de données fixes. Les formats suivants sont pris en charge pour les constantes numériques :

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

Où :

+ ou - indique une valeur positive ou négative. La valeur par défaut est positive.
digits est un ou plusieurs chiffres de 0 à 9.
e (ou E) indique un exposant dans la notation scientifique. Au moins un chiffre doit suivre le marqueur de l’exposant, s’il est présent.

Les chiffres suivants sont tous des exemples de constantes numériques prises en charge :

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