Types de données numériques¶

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 :

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.

Les considérations suivantes concernent les 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.

It might be possible to avoid these types of approximation errors by using the exact DECFLOAT data type.

Use cases for the DECFLOAT data type¶

Use the DECFLOAT data type when you need exact decimal results and a wide, variable scale in the same column.

The DECFLOAT data type is appropriate for the following general use cases:

• You are ingesting data, and the scale of incoming numeric values is unknown or highly variable.

• You require exact numeric values; for example, ledgers, taxes, or compliance.

• You are migrating from systems that rely on the IEEE 754-decimal representation or 128-bit decimals. These migrations might be blocked by the precision or range limitations of other Snowflake data types.

• You want to avoid Number out of representable range errors when you sum, multiply, or divide high-precision numeric values.

For example, you can use the DECFLOAT data type for the following specific use cases:

• You are ingesting heterogeneously-scaled data from Oracle DECIMAL or DB2 DECFLOAT columns.

• You are performing financial modeling involving computations with scales of results that are hard to predict.

• You are running scientific measurements that swing from nano units to astronomical units.

You can continue to use the NUMBER data type for fixed-scale numeric columns or the FLOAT data type for high-throughput analytics where imprecise results are acceptable.

Usage notes for the DECFLOAT data type¶

• If an operation produces a result with more than 38 digits, the DECFLOAT value is rounded to 38-digit precision, with the least-significant digits rounded off according to the current rounding mode. Snowflake uses the half up rounding mode for DECFLOAT values.

• When specifying a DECFLOAT value or casting to a DECFLOAT value, avoid using numeric literals in SQL. If you do this, the values are interpreted as NUMBER or FLOAT values before being cast to a DECFLOAT value, which can result in range errors or loss of exactness. Use either string literals — such as SELECT '<value>'::DECFLOAT — or the DECFLOAT literal — such as SELECT DECFLOAT '<value>'.

• When operations mix DECFLOAT values and values of other numeric types, coercion prefers the DECFLOAT values. For example, when adding a value of NUMBER type and DECFLOAT type, the result is a DECFLOAT value.

• Use of the DECFLOAT type might cause storage consumption to increase.

Drivers and driver versions that support the DECFLOAT data type¶

The following Snowflake drivers and driver versions support the DECFLOAT data type. You might need to update your drivers to the versions that support DECFLOAT:

Unsupported drivers treat DECFLOAT values as TEXT values. For some drivers, a driver parameter must be set to map the DECFLOAT type to a language-native type. For more information, see Pilotes.

Limitations for the DECFLOAT data type¶

The following limitations apply to the DECFLOAT type:

• DECFLOAT values can’t be stored in VARIANT, OBJECT, or ARRAY values. To cast a DECFLOAT value to a VARIANT value, you can first cast it to a VARCHAR value and then to a VARIANT value.

• DECFLOAT values aren’t supported in the following types of tables:

  • Tables in external formats, such as Iceberg

  • Hybrid tables

• The DECFLOAT data type isn’t supported in Snowflake Scripting stored procedures. However, it is supported in Snowflake Scripting user-defined functions (UDFs).

• The DECFLOAT data type isn’t supported in stored procedures or UDFs written in a language other than SQL (such as Python or Java).

• The DECFLOAT data type isn’t supported in Snowpark.

• Snowsight has limited support for the DECFLOAT data type.

• The following features don’t support the DECFLOAT data type:

  • Clustering keys

  • Differential privacy

  • Sensitive data classification

  • Service d’optimisation de la recherche

• The NUMBER and FLOAT types might provide better performance than the DECFLOAT type.

Examples for the DECFLOAT data type¶

The following examples use the DECFLOAT data type:

• Show the differences between DECFLOAT and FLOAT

• Use DECFLOAT values with aggregate functions

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
  );

DESC TABLE decfloat_sample;

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

SELECT * FROM decfloat_sample;

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

CREATE OR REPLACE TABLE decfloat_agg_sample (decfloat_val DECFLOAT);

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

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

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