Types de données Chaîne & Binaire¶

Cette rubrique décrit les types de données de chaîne/texte, y compris les chaînes binaires, pris en charge dans Snowflake, ainsi que les formats pris en charge pour les constantes/littéraux de chaîne.

Dans ce chapitre :

Types de données pour les chaînes de texte
Types de données pour les chaînes binaires
Constantes de chaîne
- Constantes de chaîne simple entre guillemets simples
- Constantes de chaînes de caractères comprises entre des dollars

Types de données pour les chaînes de texte¶

Snowflake prend en charge les types de données suivants pour les chaînes de texte (c.-à-d. de caractères).

VARCHAR¶

VARCHAR contient 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’un VARCHAR soit spécifiée en caractères, un VARCHAR est également limité à un nombre maximal d”octets (16 777 216 (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 16777216.

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.

Notez que dans certains systèmes, les types de données tels que CHAR et VARCHAR stockent des caractères ASCII alors que les types de données tels que NCHAR et NVARCHAR stockent des caractères Unicode. Dans Snowflake, VARCHAR et tous les autres types de données de chaîne stockent des caractères Unicode UTF-8. Il n’y a aucune différence entre les types de données CHAR et NCHAR en ce qui concerne la gestion de l’Unicode. Les synonymes tels que NCHAR sont principalement destinés à assurer la compatibilité syntaxique lors du portage des commandes DDL vers Snowflake.

Il n’y a pas de différence de performance entre l’utilisation de l’instruction VARCHAR sur toute la longueur VARCHAR(16777216) ou l’utilisation d’une taille inférieure. Notez que 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 colonnes de chaînes ne sont pas aussi rapides que les instructions SELECT filtrées en utilisant une condition de date ou de colonne numérique.

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.

CHAR , CHARACTER , NCHAR¶

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

Note

Snowflake s’écarte actuellement de la sémantique courante CHAR en ce sens que les chaînes plus courtes que la longueur maximale ne sont pas espacées à la fin.

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

Synonyme de VARCHAR.

Exemples de chaînes de caractères dans les colonnes de tables¶

CREATE OR REPLACE TABLE test_text(v VARCHAR,
                                  v50 VARCHAR(50),
                                  c CHAR,
                                  c10 CHAR(10),
                                  s STRING,
                                  s20 STRING(20),
                                  t TEXT,
                                  t30 TEXT(30)
                                  );

DESC TABLE test_text;

+------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type              | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| V    | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| V50  | VARCHAR(50)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| C    | VARCHAR(1)        | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| C10  | VARCHAR(10)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| S    | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| S20  | VARCHAR(20)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| T    | VARCHAR(16777216) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| T30  | VARCHAR(30)       | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+-------------------+--------+-------+---------+-------------+------------+-------+------------+---------+

Types de données pour les chaînes binaires¶

Snowflake prend en charge les types de données suivants pour les chaînes binaires.

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 via 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 2 caractères hexadécimaux. Par exemple, le mot « 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 », etc.

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

Exemples binaires dans les colonnes de tables¶

CREATE OR REPLACE TABLE test_binary(b BINARY,
                                    b100 BINARY(100),
                                    vb VARBINARY
                                    );

DESC TABLE test_binary;

+------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type            | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| B    | BINARY(8388608) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| B100 | BINARY(100)     | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| VB   | BINARY(8388608) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+-----------------+--------+-------+---------+-------------+------------+-------+------------+---------+

Constantes de chaîne¶

Les constantes (aussi connues sous le nom de littéraux) font référence à des valeurs de données fixes. Les constantes de chaîne dans Snowflake doivent toujours être entourées entre des caractères de délimitation. Snowflake prend en charge l’utilisation de l’un des éléments suivants pour délimiter les constantes de chaînes :

Guillemets simples.
Paires de signes de dollar.

Constantes de chaîne simple entre guillemets simples¶

Une constante de chaîne peut être placée entre des délimiteurs de guillemets simples (par ex. '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 ex. '').

Par exemple :

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

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

Note

Deux guillemets simples ne sont pas équivalents à un guillemet double ("), qui est utilisé (si nécessaire) pour délimiter les identificateurs d’objet. Pour plus d’informations, voir Exigences relatives à l’identificateur.

Séquences d’échappement dans les constantes de chaînes entre guillemets simples¶

Pour inclure un guillemet simple ou d’autres caractères spéciaux (par exemple, un retour à la ligne) dans une constante de chaîne entre guillemets simples, vous devez échapper ces caractères en utilisant des séquences d’échappement avec barre oblique inverse. Une séquence d’échappement avec barre oblique inverse est une séquence de caractères qui commence par une barre oblique inverse (\).

Note

Si la chaîne de caractères contient beaucoup de guillemets simples, de barres obliques inverses ou d’autres caractères spéciaux, vous pouvez utiliser une constante de chaîne comprise entre des dollars à la place pour éviter l’échappement de ces caractères.

Vous pouvez également utiliser des séquences d’échappement pour insérer des caractères ASCII en spécifiant leurs points de code (les valeurs numériques qui correspondent à ces caractères) en octal ou en hexadécimal. Par exemple, en ASCII, le point de code pour le caractère espace est 32, et 20 en hexadécimal. Pour spécifier un espace, vous pouvez utiliser la séquence d’échappement hexadécimale \x20.

Vous pouvez également utiliser des séquences d’échappement pour insérer des caractères Unicode, par exemple \u26c4.

Le tableau suivant répertorie les séquences d’échappement prises en charge dans quatre catégories : simple, octal, hexadécimal et Unicode :

Séquence d’échappement

Caractère représenté

Séquences d’échappement simples

\'

Un guillemet simple (')

\"

Un guillemet double (")

\\

Une barre oblique inverse (\)

\b

Un retour arrière

\f

Un saut de page

\n

Un saut de ligne (nouvelle ligne)

\r

Un retour chariot

\t

Une tabulation

\0

Un caractère ASCII NUL

Séquences d’échappement octal

\ooo

Caractère ASCII en notation octale (c’est-à-dire où chaque o représente un chiffre octal).

Séquences d’échappement hexadécimales

\xhh

Caractère ASCII en notation hexadécimale (c’est-à-dire où chaque h représente un chiffre hexadécimal).

Séquences d’échappement Unicode

\uhhhh

Caractère Unicode en notation hexadécimale (c’est-à-dire où chaque h représente un chiffre hexadécimal). Le nombre de chiffres hexadécimaux peut être 2, 4, 6 ou 8 (c’est-à-dire 1, 2, 3 ou 4 octets).

Comme le montre le tableau ci-dessus, si une constante de chaîne doit inclure une barre oblique inverse (par exemple C:\ dans un chemin d’accès Windows ou \d dans une expression régulière), vous devez échapper la barre oblique inverse avec une deuxième barre oblique inverse. Par exemple, pour inclure \d au sein d’une expression régulière dans une constante de chaîne, vous devez utiliser \\d.

Notez que si une barre oblique inverse est utilisée dans des séquences autres que celles énumérées ci-dessus, la barre oblique inverse est ignorée. Par exemple, la séquence de caractères '\z' est interprétée comme 'z'.

L’exemple suivant montre comment utiliser les séquences d’échappement avec barre oblique inverse. Vous y trouverez des exemples de spécification :

une tabulation
une nouvelle ligne
une barre oblique inverse
les séquences d’échappement octales et hexadécimales pour un point d’exclamation (point de code 33, qui est \041 en octal et \x21 en hexadécimal)
la séquence d’échappement Unicode pour une petite image d’un bonhomme de neige

quelque chose qui n’est pas une séquence d’échappement valide

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înes de caractères comprises entre des 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 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 :

Exemple d’utilisation des délimiteurs avec guillemets simples

Exemple d’utilisation des délimiteurs avec les signes double dollar

'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, notez comment les séquences d’échappement sont interprétées comme leurs caractères individuels (par exemple, une barre oblique inversée suivie d’un « t »), plutôt que comme des séquences d’échappement.