Conversion de type de données¶

Conversion explicite vs conversion implicite¶

Les utilisateurs peuvent convertir explicitement une valeur d’un type de données à un autre. C’est ce qu’on appelle le casting explicite.

Dans certaines situations, Snowflake convertit automatiquement une valeur en un autre type de données. C’est ce qu’on appelle le casting implicite ou la coercition.

Conversion et préséance¶

Lors d’un casting à l’intérieur d’une expression, le code doit tenir compte de la précédence de l’opérateur cast par rapport aux autres opérateurs de l’expression.

Prenons l’exemple suivant :

SELECT height * width::VARCHAR || ' square meters'
  FROM dimensions;

The cast operator has higher precedence than the arithmetic operator * (multiply), so the statement is interpreted as shown in the following example:

... height * (width::VARCHAR) ...

To cast the result of the expression height * width, use parentheses, as shown in the following example:

SELECT (height * width)::VARCHAR || ' square meters'
  FROM dimensions;

Par exemple également, considérons l’instruction suivante :

SELECT -0.0::FLOAT::BOOLEAN;

You might expect this to be interpreted as shown in the following example:

SELECT (-0.0::FLOAT)::BOOLEAN;

On s’attend donc à ce que FALSE soit renvoyé (0 = FALSE, 1 = TRUE).

However, the cast operator has higher precedence than the unary minus (negation) operator, so the statement is interpreted as shown in the following example:

SELECT -(0.0::FLOAT::BOOLEAN);

Par conséquent, la requête donne lieu à un message d’erreur car le moins unaire ne peut pas être appliqué à un BOOLEAN.

Types de données pouvant être convertis¶

La table suivante indique les conversions de types de données valides dans Snowflake. La table indique également les coercitions que Snowflake peut effectuer automatiquement.

For more information about conversions between semi-structured types and structured types, see Conversion de types structurés et semi-structurés.

Notes sur l’utilisation¶

Sauf indication contraire, les règles suivantes s’appliquent à la fois à la conversion explicite et à la conversion implicite :

• Conversion depends not only on the data type, but also the value, of the source; for example:

  • La valeur VARCHAR '123' peut être convertie en valeur numérique, mais la valeur VARCHAR 'xyz' ne peut pas être convertie en valeur numérique.

  • The ability to cast a specific value of type VARIANT depends on the type of the data inside the VARIANT. For example, if the VARIANT contains a value of type TIME, then you can’t cast the VARIANT value to a TIMESTAMP value, because you can’t cast a TIME value to a TIMESTAMP value.

• Snowflake performs implicit conversion of arguments to make them compatible. For example, if one of the input expressions is a numeric type, the return type is also a numeric type. That is, SELECT COALESCE('17', 1); first converts the VARCHAR value '17' to the NUMBER value 17, and then returns the first non-NULL value.

  When conversion isn’t possible, implicit conversion fails. For example, SELECT COALESCE('foo', 1); returns an error because the VARCHAR value 'foo' can’t be converted to a NUMBER value.

  We recommend passing in arguments of the same type or explicitly converting arguments if needed.

• When implicit conversion converts a non-numeric value to a numeric value, the result is a value of type NUMBER(18,5).

  Pour les arguments numériques de type chaîne qui ne sont pas des constantes, si NUMBER(18,5) n’est pas suffisant pour représenter la valeur numérique, vous devez convertir l’argument en un type qui peut représenter la valeur.

• For some pairs of data types, conversion can result in loss of precision; for example:

  • La conversion d’une valeur FLOAT en valeur INTEGER arrondit la valeur.

  • Converting a value from fixed-point numeric — for example, NUMBER(38, 0) — to floating point — for example, FLOAT — can result in rounding or truncation if the fixed-point number can’t be precisely represented in a floating point number.

  • La conversion d’une valeur TIMESTAMP en valeur DATE supprime les informations relatives à l’heure de la journée.

• Although Snowflake converts values in some situations where loss of precision can occur, Snowflake doesn’t allow conversion in other situations where a loss of precision would occur. For example, Snowflake doesn’t allow conversion when conversion would cause the following situations to happen:

  • Tronquer une valeur VARCHAR. Par exemple, Snowflake ne convertit pas VARCHAR(10) en VARCHAR(5), que ce soit de façon implicite ou explicite.

  • Result in the loss of digits other than the least significant digits. For example, the following loss of digits fails:

    SELECT 12.3::FLOAT::NUMBER(3,2);
    

    Copy

    Dans cet exemple, le nombre 12.3 comporte deux chiffres avant la virgule, mais le type de données NUMBER(3,2) ne peut contenir qu’un seul chiffre avant la virgule.

• Lors de la conversion d’un type avec moins de précision vers un type avec plus de précision, la conversion utilise des valeurs par défaut. Par exemple, la conversion d’une valeur DATE en valeur TIMESTAMP_NTZ fait en sorte que l’heure, la minute, la seconde et les fractions de seconde soient définies sur 0.

• Lorsqu’une valeur FLOAT est convertie en valeur VARCHAR, les zéros de fin sont omis.

  For example, the following statements create a table and insert a row that contains a VARCHAR value, a FLOAT value, and a VARIANT value. The VARIANT value is constructed from JSON that contains a floating-point value represented with trailing zeros:

  CREATE OR REPLACE TABLE convert_test_zeros (
    varchar1 VARCHAR,
    float1 FLOAT,
    variant1 VARIANT);
  
  INSERT INTO convert_test_zeros SELECT
    '5.000',
    5.000,
    PARSE_JSON('{"Loan Number": 5.000}');
  

  Copy

  L’instruction SELECT suivante remplace explicitement la colonne FLOAT et la valeur FLOAT de la colonne VARIANT par VARCHAR. Dans chaque cas, le VARCHAR ne contient pas de zéros de fin :

  SELECT varchar1,
         float1::VARCHAR,
         variant1:"Loan Number"::VARCHAR
    FROM convert_test_zeros;
  

  Copy

  +----------+-----------------+---------------------------------+
  | VARCHAR1 | FLOAT1::VARCHAR | VARIANT1:"LOAN NUMBER"::VARCHAR |
  |----------+-----------------+---------------------------------|
  | 5.000    | 5               | 5                               |
  +----------+-----------------+---------------------------------+
  

• Some operations can return different data types, depending on a conditional expression. For example, the following IFNULL calls return slightly different data types depending on the input values:

  SELECT SYSTEM$TYPEOF(IFNULL(12.3, 0)),
         SYSTEM$TYPEOF(IFNULL(NULL, 0));
  

  Copy

  +--------------------------------+--------------------------------+
  | SYSTEM$TYPEOF(IFNULL(12.3, 0)) | SYSTEM$TYPEOF(IFNULL(NULL, 0)) |
  |--------------------------------+--------------------------------|
  | NUMBER(3,1)[SB1]               | NUMBER(1,0)[SB1]               |
  +--------------------------------+--------------------------------+
  

  If the expression has more than one possible data type, Snowflake chooses the data type based on the actual result. For more information about precision and scale in calculations, see Échelle et précision dans les opérations arithmétiques. If the query generates more than one result — for example, multiple rows of results — Snowflake chooses a data type that is capable of holding each of the individual results.

• Some applications, such as SnowSQL, and some graphical user interfaces, such as the Classic Console, apply their own conversion and formatting rules when they display data. For example, SnowSQL displays BINARY values as a string that contains only hexadecimal digits; that string is generated by implicitly calling a conversion function. Therefore, the data that SnowSQL displays might not unambiguously indicate which data conversions that Snowflake coerced.