Types de données Chaîne et Binaire¶

VARCHAR¶

Les valeurs VARCHAR contiennent des caractères Unicode UTF-8.

Lorsque vous déclarez une colonne de type VARCHAR, vous pouvez spécifier un paramètre facultatif (N), qui est le nombre maximal de caractères à stocker. Par exemple :

CREATE TABLE t1 (v VARCHAR(16777216));

Si aucune longueur n’est spécifiée, la valeur par défaut est la longueur maximale autorisée (16 777 216).

Bien que la longueur maximale d’une valeur VARCHAR soit spécifiée en caractères, une valeur VARCHAR est également limitée à un maximum de 16 777 216 octets (16 MB). Le nombre maximum de caractères Unicode qui peuvent être stockés dans une colonne VARCHAR est indiqué ci-dessous :

Un octet:

16 777 216.

Multi-octets:

Entre 8 388 608 (2 octets par caractère) et 4 194 304 (4 octets par caractère).

Par exemple, si vous déclarez une colonne comme VARCHAR(16777216), la colonne peut contenir un maximum de 8 388 608 caractères Unicode à 2 octets, même si vous avez spécifié une longueur maximale de 16 777 216.

Lorsque vous choisissez la longueur maximale d’une colonne VARCHAR, tenez compte des éléments suivants :

• Stockage : une colonne ne consomme de l’espace de stockage que pour la quantité de données réellement stockées. Par exemple, une chaîne d’1 caractère dans une colonne VARCHAR(16777216) ne consomme qu’un seul caractère.

• Performances : il n’existe pas de différence de performances entre l’utilisation de l’instruction VARCHAR sur toute la longueur VARCHAR(16777216) et l’utilisation d’une longueur inférieure.

  Dans n’importe quelle base de données relationnelle, les instructions SELECT dans lesquelles une clause WHERE fait référence à des colonnes VARCHAR ou à des colonnes de chaînes ne sont pas aussi rapides que les instructions SELECT filtrées à l’aide d’une condition de date ou de colonne numérique.

• Outils pour travailler avec des donnés : certains outils BI/ETL définissent la taille maximale des données VARCHAR en stockage ou en mémoire. Si vous connaissez la taille maximale d’une colonne, vous pouvez limiter la taille lorsque vous ajoutez la colonne.

• Classement : lorsque vous spécifiez un classement pour une colonne VARCHAR, le nombre de caractères autorisés varie en fonction du nombre d’octets que prend chaque caractère et de la spécification de classement de la colonne.

  Lors de la comparaison de valeurs dans une colonne classée, Snowflake suit l’algorithme de classement Unicode (UCA). Cet algorithme affecte le nombre maximal de caractères autorisés. Actuellement, environ 1,5 à 8 millions de caractères sont autorisés dans une colonne VARCHAR définie par une taille maximale et une spécification de classement.

  À titre d’exemple, le tableau suivant montre comment le nombre maximal de caractères peut varier pour une colonne VARCHAR(16777216), suivant le nombre d’octets par caractère et la spécification de classement utilisée :

  Nombre d’octets par caractère	Spécification de classement	Nombre maximal de caractères autorisés (approximatif)
  1 octet	en-ci ou en-ci-pi-ai	Environ 7 millions de caractères
  1 octet	en	Environ 4 millions de caractères
  2 octets	en-ci-pi-ai	Environ 8 millions de caractères
  2 octets	en-ci ou en-ci-pi	Environ 2,7 millions de caractères
  2 octets	en	Environ 1,5 million de caractères

CHAR, CHARACTER, NCHAR¶

Synonyme de VARCHAR, à l’exception du fait que CHAR(1) est la valeur par défaut si la longueur n’est pas spécifiée.

STRING, TEXT, NVARCHAR, NVARCHAR2, CHAR VARYING, NCHAR VARYING¶

Synonyme de VARCHAR.

Exemples de chaîne dans des colonnes de table¶

CREATE OR REPLACE TABLE test_text(
  vd VARCHAR,
  v50 VARCHAR(50),
  cd CHAR,
  c10 CHAR(10),
  sd STRING,
  s20 STRING(20),
  td TEXT,
  t30 TEXT(30));

DESC TABLE test_text;

+------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
| name | type              | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
|------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
| VD   | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| V50  | VARCHAR(50)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| CD   | VARCHAR(1)        | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| C10  | VARCHAR(10)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| SD   | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| S20  | VARCHAR(20)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| TD   | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| T30  | VARCHAR(30)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+

BINARY¶

La longueur maximale est de 8 MB (8 388 608 octets). Contrairement à VARCHAR, le type de données BINARY n’a aucune notion de caractères Unicode, donc la longueur est toujours mesurée en termes d’octets.

Les valeurs BINARY sont limitées à 8 MB afin qu’elles tiennent dans 16 MB lorsqu’elles sont converties en chaînes hexadécimales, par exemple en utilisant une TO_CHAR(<expression_binaire>, 'HEX').

Si aucune longueur n’est spécifiée, la valeur par défaut est la longueur maximale.

VARBINARY¶

VARBINARY est synonyme de BINARY.

Représentation interne¶

Le type de données BINARY contient une séquence d’octets de 8 bits.

Lorsque Snowflake affiche des valeurs de données BINARY, Snowflake représente souvent chaque octet comme deux caractères hexadécimaux. Par exemple, le terme HELP peut être affiché comme 48454C50, où 48 est l’équivalent hexadécimal de la lettre ASCII (Unicode) H, 45 est la représentation hexadécimale de la lettre E, et ainsi de suite.

Pour plus d’informations sur la saisie et l’affichage de données BINARY, voir Entrée et sortie binaires.

Exemples binaires dans des colonnes de table¶

CREATE OR REPLACE TABLE test_binary(
  bd BINARY,
  b100 BINARY(100),
  vbd VARBINARY);

DESC TABLE test_binary;

+------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
| name | type            | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
|------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
| BD   | BINARY(8388608) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| B100 | BINARY(100)     | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
| VBD  | BINARY(8388608) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+

Constantes de chaîne entre guillemets simples¶

Une constante de chaîne peut être placée entre des délimiteurs de guillemets simples (par exemple, 'This is a string'). Pour inclure un caractère entre guillemets simples dans une constante de chaîne, tapez deux guillemets simples avant et après le caractère (par exemple, '').

Par exemple :

SELECT 'Today''s sales projections', '-''''-';

+------------------------------+----------+
| 'TODAY''S SALES PROJECTIONS' | '-''''-' |
|------------------------------+----------|
| Today's sales projections    | -''-     |
+------------------------------+----------+

SELECT $1, $2 FROM
  VALUES
    ('Tab','Hello\tWorld'),
    ('Newline','Hello\nWorld'),
    ('Backslash','C:\\user'),
    ('Octal','-\041-'),
    ('Hexadecimal','-\x21-'),
    ('Unicode','-\u26c4-'),
    ('Not an escape sequence', '\z');

+------------------------+---------------+
| $1                     | $2            |
|------------------------+---------------|
| Tab                    | Hello   World |
| Newline                | Hello         |
|                        | World         |
| Backslash              | C:\user       |
| Octal                  | -!-           |
| Hexadecimal            | -!-           |
| Unicode                | -⛄-          |
| Not an escape sequence | z             |
+------------------------+---------------+

Constantes de chaîne encadrées de dollars¶

Dans certains cas, vous pouvez avoir besoin de spécifier une constante de type chaîne qui contient :

• Des guillemets simples.

• Des barres obliques inverses (par exemple, dans, dans une expression régulière).

• Des sauts de ligne (par exemple,, dans le corps d’une procédure stockée ou d’une fonction que vous spécifiez dans CREATE PROCEDURE ou CREATE FUNCTION).

Dans ces cas, vous pouvez éviter l’échappement de ces caractères en utilisant une paire de signes dollar ($$) plutôt qu’un guillemet simple (') pour délimiter le début et la fin de la chaîne.

Dans une constante de chaîne de caractères comprise entre des dollars, vous pouvez inclure des guillemets, des barres obliques inverses, des retours à la ligne et tout autre caractère spécial (à l’exception des signes de double dollar) sans échapper ces caractères. Le contenu d’une constante de chaîne comprise entre des dollars est toujours interprété littéralement.

Les exemples suivants sont des manières équivalentes de spécifier des constantes de chaîne :

'string with a \' character'

$$string with a ' character$$

'regular expression with \\ characters: \\d{2}-\\d{3}-\\d{4}'

$$regular expression with \ characters: \d{2}-\d{3}-\d{4}$$

'string with a newline\ncharacter'

$$string with a newline
character$$

L’exemple suivant utilise une constante de chaîne comprise entre des dollars qui contient des sauts de ligne et plusieurs séquences d’échappement :

SELECT $1, $2 FROM VALUES (
  'row1',
  $$a
                                  ' \ \t
                                  \x21 z $ $$);

+------+---------------------------------------------+
| $1   | $2                                          |
|------+---------------------------------------------|
| row1 | a                                           |
|      |                                   ' \ \t    |
|      |                                   \x21 z $  |
+------+---------------------------------------------+

Dans cet exemple, les séquences d’échappement sont interprétées comme leurs caractères individuels (par ex., une barre oblique inverse suivie d’un t), plutôt que comme des séquences d’échappement.