CREATE TABLE

Crée une nouvelle table dans le schéma actuel/spécifié, remplace une table existante ou modifie une table existante. Une table peut avoir plusieurs colonnes, chaque définition de colonne étant constituée d’un nom, d’un type de données et, éventuellement si la colonne :

  • Nécessite une valeur (NOT NULL).

  • A une valeur par défaut.

  • Possède des contraintes d’intégrité référentielle (clé primaire, clé étrangère, etc.).

En outre, cette commande prend en charge les variantes suivantes :

  • CREATE OR ALTER TABLE (crée une table si elle n’existe pas ou la modifie en fonction de la définition de la table)

  • CREATE TABLE … AS SELECT (crée une table remplie ; aussi appelée CTAS)

  • CREATE TABLE … USING TEMPLATE (crée une table avec les définitions de colonnes dérivées d’un ensemble de fichiers en zone de préparation)

  • CREATE TABLE … LIKE (crée une copie vide d’une table existante)

  • CREATE TABLE … CLONE (crée un clone d’une table existante)

Voir aussi :

ALTER TABLE , DROP TABLE , SHOW TABLES , DESCRIBE TABLE

Syntaxe

CREATE [ OR REPLACE ]
    [ { [ { LOCAL | GLOBAL } ] TEMP | TEMPORARY | VOLATILE | TRANSIENT } ]
  TABLE [ IF NOT EXISTS ] <table_name> (
    -- Column definition
    <col_name> <col_type>
      [ inlineConstraint ]
      [ NOT NULL ]
      [ COLLATE '<collation_specification>' ]
      [
        {
          DEFAULT <expr>
          | { AUTOINCREMENT | IDENTITY }
            [
              {
                ( <start_num> , <step_num> )
                | START <num> INCREMENT <num>
              }
            ]
            [ { ORDER | NOORDER } ]
        }
      ]
      [ [ WITH ] MASKING POLICY <policy_name> [ USING ( <col_name> , <cond_col1> , ... ) ] ]
      [ [ WITH ] PROJECTION POLICY <policy_name> ]
      [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
      [ COMMENT '<string_literal>' ]

    -- Additional column definitions
    [ , <col_name> <col_type> [ ... ] ]

    -- Out-of-line constraints
    [ , outoflineConstraint [ ... ] ]
  )
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ ENABLE_SCHEMA_EVOLUTION = { TRUE | FALSE } ]
  [ DATA_RETENTION_TIME_IN_DAYS = <integer> ]
  [ MAX_DATA_EXTENSION_TIME_IN_DAYS = <integer> ]
  [ CHANGE_TRACKING = { TRUE | FALSE } ]
  [ DEFAULT_DDL_COLLATION = '<collation_specification>' ]
  [ COPY GRANTS ]
  [ COMMENT = '<string_literal>' ]
  [ [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col_name> [ , <col_name> ... ] ) ]
  [ [ WITH ] AGGREGATION POLICY <policy_name> [ ENTITY KEY ( <col_name> [ , <col_name> ... ] ) ] ]
  [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
Copy

Où :

inlineConstraint ::=
  [ CONSTRAINT <constraint_name> ]
  { UNIQUE
    | PRIMARY KEY
    | [ FOREIGN KEY ] REFERENCES <ref_table_name> [ ( <ref_col_name> ) ]
  }
  [ <constraint_properties> ]
Copy

Pour plus de détails sur les contraintes en ligne, voir CREATE | ALTER TABLE … CONSTRAINT.

outoflineConstraint ::=
  [ CONSTRAINT <constraint_name> ]
  { UNIQUE [ ( <col_name> [ , <col_name> , ... ] ) ]
    | PRIMARY KEY [ ( <col_name> [ , <col_name> , ... ] ) ]
    | [ FOREIGN KEY ] [ ( <col_name> [ , <col_name> , ... ] ) ]
      REFERENCES <ref_table_name> [ ( <ref_col_name> [ , <ref_col_name> , ... ] ) ]
  }
  [ <constraint_properties> ]
  [ COMMENT '<string_literal>' ]
Copy

Pour plus de détails sur les contraintes hors ligne, voir CREATE | ALTER TABLE … CONSTRAINT.

Note

Ne spécifiez pas d’options de copie à l’aide des commandes CREATE STAGE, ALTER STAGE, CREATE TABLE ou ALTER TABLE. Nous vous recommandons d’utiliser la commande COPY INTO <table> pour spécifier les options de copie.

Syntaxe des variantes

CREATE OR ALTER TABLE

Crée une table si elle n’existe pas ou la modifie en fonction de la définition de la table. La syntaxe CREATE OR ALTER TABLE suit les règles d’une instruction CREATE TABLE et présente les mêmes limitations qu’une instruction ALTER TABLE. Si la table est transformée, les données existantes de la table sont préservées dans la mesure du possible. Si une colonne doit être supprimée, cela peut entraîner une perte de données.

Les modifications suivantes sont prises en charge lors de la modification d’une table :

  • Modification des propriétés et des paramètres de la table. Par exemple, ENABLE_SCHEMA_EVOLUTION, DATA_RETENTION_TIME_IN_DAYS ou CLUSTER BY.

  • Modification du type de données de la colonne, de la valeur par défaut, de la nullabilité, du commentaire ou de l’incrémentation automatique.

  • Ajout de nouvelles colonnes à la fin de la liste de colonnes.

  • Suppression de colonnes.

  • Ajout, suppression ou modification de contraintes en ligne ou hors ligne.

  • Ajout, suppression ou modification de clés de clustering.

Pour plus d’informations, voir Notes sur l’utilisation de CREATE OR ALTER TABLE.

CREATE OR ALTER
    [ { [ { LOCAL | GLOBAL } ] TEMP | TEMPORARY | TRANSIENT } ]
  TABLE <table_name> (
    -- Column definition
    <col_name> <col_type>
      [ inlineConstraint ]
      [ NOT NULL ]
      [ COLLATE '<collation_specification>' ]
      [
        {
          DEFAULT <expr>
          | { AUTOINCREMENT | IDENTITY }
            [
              {
                ( <start_num> , <step_num> )
                | START <num> INCREMENT <num>
              }
            ]
            [ { ORDER | NOORDER } ]
        }
      ]
      [ COMMENT '<string_literal>' ]

    -- Additional column definitions
    [ , <col_name> <col_type> [ ... ] ]

    -- Out-of-line constraints
    [ , outoflineConstraint [ ... ] ]
  )
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ ENABLE_SCHEMA_EVOLUTION = { TRUE | FALSE } ]
  [ DATA_RETENTION_TIME_IN_DAYS = <integer> ]
  [ MAX_DATA_EXTENSION_TIME_IN_DAYS = <integer> ]
  [ CHANGE_TRACKING = { TRUE | FALSE } ]
  [ DEFAULT_DDL_COLLATION = '<collation_specification>' ]
  [ COMMENT = '<string_literal>' ]
Copy

CREATE TABLE … AS SELECT (également appelé CTAS)

Crée une nouvelle table remplie avec les données renvoyées par une requête :

CREATE [ OR REPLACE ] TABLE <table_name> [ ( <col_name> [ <col_type> ] , <col_name> [ <col_type> ] , ... ) ]
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ COPY GRANTS ]
  AS <query>
  [ ... ]
Copy

Une politique de masquage peut être appliquée à une colonne dans une instruction CTAS. Spécifiez la politique de masquage après le type de données de la colonne. De même, une politique d’accès aux lignes peut être appliquée à la table. Par exemple :

CREATE TABLE <table_name> ( <col1> <data_type> [ WITH ] MASKING POLICY <policy_name> [ , ... ] )
  ...
  [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col1> [ , ... ] )
  AS <query>
  [ ... ]
Copy

Note

Dans un CTAS, la clause COPY GRANTS n’est valide que lorsqu’elle est combinée avec la clause OR REPLACE. COPY GRANTS copie les autorisations de la table remplacée par CREATE OR REPLACE (si elle existe déjà), et non des tables sources interrogées dans l’instruction SELECT. CTAS avec COPY GRANTS vous permet d’écraser une table avec un nouvel ensemble de données tout en conservant les autorisations existantes sur cette table.

Pour plus d’informations sur COPY GRANTS, voir COPY GRANTS dans ce document.

CREATE TABLE … USING TEMPLATE

Crée une nouvelle table avec les définitions de colonnes dérivées d’un ensemble de fichiers en zone de préparation, à l’aide de la fonction INFER_SCHEMA. Cette fonction prend en charge les fichiers Apache Parquet, Apache Avro, ORC, JSON et CSV.

CREATE [ OR REPLACE ] TABLE <table_name>
  [ COPY GRANTS ]
  USING TEMPLATE <query>
  [ ... ]
Copy

Note

Si l’instruction remplace une table existante du même nom, les autorisations sont copiées à partir de la table à remplacer. S’il n’existe aucune table de ce nom, les autorisations sont copiées à partir de la table source en cours de clonage.

Pour plus d’informations sur COPY GRANTS, voir COPY GRANTS dans ce document.

CREATE TABLE … LIKE

Crée une nouvelle table avec les mêmes définitions de colonnes qu’une table existante, mais sans copier les données de la table existante. Les noms de colonnes, les types, les valeurs par défaut et les contraintes sont copiés dans la nouvelle table :

CREATE [ OR REPLACE ] TABLE <table_name> LIKE <source_table>
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ COPY GRANTS ]
  [ ... ]
Copy

Pour plus d’informations sur COPY GRANTS, voir COPY GRANTS dans ce document.

Note

CREATE TABLE … LIKE pour une table avec une séquence d’auto-incrémentation à laquelle on accède par un partage de données est actuellement non pris en charge.

CREATE TABLE … CLONE

Crée une nouvelle table avec les mêmes définitions de colonnes et contenant toutes les données existantes de la table source, sans réellement copier les données. Cette variante peut également être utilisée pour cloner une table à un moment précis dans le passé (à l’aide de la commande Time Travel) :

CREATE [ OR REPLACE ]
    [ {
          [ { LOCAL | GLOBAL } ] TEMP [ READ ONLY ] |
          TEMPORARY [ READ ONLY ] |
          VOLATILE |
          TRANSIENT
    } ]
  TABLE <name> CLONE <source_table>
    [ { AT | BEFORE } ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]
    [ COPY GRANTS ]
    [ ... ]
Copy

Note

Si l’instruction remplace une table existante du même nom, les autorisations sont copiées à partir de la table à remplacer. S’il n’existe aucune table de ce nom, les autorisations sont copiées à partir de la table source en cours de clonage.

Pour plus d’informations sur COPY GRANTS, voir COPY GRANTS dans ce document.

Pour plus de détails sur le clonage, voir CREATE <objet> … CLONE.

Paramètres requis

name

Indique l’identificateur (c’est-à-dire le nom) de la table ; doit être unique pour le schéma dans lequel la table est créée.

De plus, l’identificateur doit commencer par un caractère alphabétique et ne peut pas contenir d’espaces ou de caractères spéciaux à moins que toute la chaîne d’identificateur soit délimitée par des guillemets doubles (p. ex. "My object"). Les identificateurs entre guillemets doubles sont également sensibles à la casse.

Pour plus de détails, voir Exigences relatives à l’identificateur.

col_name

Indique l’identificateur de colonne (c’est-à-dire le nom). Toutes les exigences relatives aux identificateurs de table s’appliquent également aux identificateurs de colonne.

Pour plus de détails, voir Exigences relatives à l’identificateur et Mots clés réservés et limités.

Note

En plus des mots clés réservés standard, les mots clés suivants ne peuvent pas être utilisés comme identificateurs de colonnes, car ils sont réservés aux fonctions de contexte standard ANSI :

  • CURRENT_DATE

  • CURRENT_ROLE

  • CURRENT_TIME

  • CURRENT_TIMESTAMP

  • CURRENT_USER

Pour la liste des mots clés réservés, voir Mots clés réservés et limités.

col_type

Spécifie le type de données pour la colonne.

Pour plus de détails sur les types de données qui peuvent être spécifiés pour les colonnes de la table, voir Référence de types de données SQL.

query

Obligatoire pour CTAS et pour USING TEMPLATE.

  • Pour CTAS, spécifie l”instruction SELECT qui renseigne la table.

  • Pour CREATE TABLE … USING TEMPLATE, spécifie la sous-requête qui appelle la fonction INFER_SCHEMA et formate la sortie sous forme de tableau. Alternativement, USING TEMPLATE accepte la sortie INFER_SCHEMA comme une chaîne littérale ou une variable.

source_table

Obligatoire pour LIKE et pour CLONE.

  • Pour CREATE TABLE … LIKE, spécifie la table à partir de laquelle les propriétés et les définitions de colonne sont copiées.

  • Pour CREATE TABLE … CLONE, spécifie la table à utiliser comme source pour le clone.

Paramètres facultatifs

{ [ { LOCAL | GLOBAL } ] TEMP [ READ ONLY] | ` :newline:.` TEMPORARY [ READ ONLY] | . VOLATILE | ` :newline:.` TRANSIENT }

Spécifie que la table ne persiste que pendant la durée de la session dans laquelle vous l’avez créée. Une table temporaire et tout son contenu sont détruits à la fin de la session.

Les synonymes et abréviations de TEMPORARY (comme GLOBAL TEMPORARY) sont fournis pour assurer la compatibilité avec d’autres bases de données (par exemple, pour éviter les erreurs lors de la migration des instructions CREATE TABLE). Les une table créées avec l’un de ces mots clés apparaissent et se comportent de la même manière que la table créée à l’aide du mot clé TEMPORARY.

Par défaut : aucune valeur. Si une table n’est pas déclarée comme TEMPORARY ou TRANSIENT, la table est permanente.

Si vous voulez éviter des conflits inattendus, évitez de nommer les tables temporaires d’après des tables qui existent déjà dans le schéma.

Si vous avez créé une table temporaire portant le même nom qu’une autre table du schéma, toutes les requêtes et opérations utilisées sur la table n’affectent que la table temporaire dans la session, jusqu’à ce que vous supprimiez la table temporaire. Si vous supprimez la table, vous supprimez la table temporaire, et non la table qui existe déjà dans le schéma.

Pour obtenir des informations sur les tables temporaires ou transitoires et sur la manière dont elles peuvent affecter le stockage et les coûts, reportez-vous aux ressources suivantes :

READ ONLY

Spécifie que la table est en lecture seule. READ ONLY est valide uniquement pour une table temporaire créée avec la variante CREATE TABLE … CLONE de la commande CREATE TABLE.

Une table en lecture seule n’autorise pas les opérations DML et n’autorise que le sous-ensemble suivant d’opérations DDL :

  • ALTER TABLE … { ALTER | MODIFY } COLUMN … { SET | UNSET } COMMENT

  • ALTER TABLE … { ALTER | MODIFY } COLUMN … { SET | UNSET } MASKING POLICY

  • ALTER TABLE … { ALTER | MODIFY } COLUMN … { SET | UNSET } TAG

  • ALTER TABLE … RENAME COLUMN … TO

  • ALTER TABLE … RENAME TO

  • ALTER TABLE … { SET | UNSET } COMMENT

  • ALTER TABLE … { SET | UNSET } TAG

  • COMMENT

  • DESCRIBE

  • DROP

  • SHOW

  • UNDROP

Les tables en lecture seule ont une colonne METADATA$ROW_POSITION. Cette colonne de métadonnées attribue à chaque ligne de la table un numéro de ligne continu qui commence à 0. Le numéro de ligne attribué à chaque ligne reste inchangé jusqu’à la suppression de la table en lecture seule.

TRANSIENT

Indique que la table est transitoire.

Comme une table permanente, une table transitoire existe jusqu’à ce qu’elle soit explicitement détruite et est visible pour tout utilisateur disposant des privilèges appropriés. Toutefois, les tables transitoires ont un niveau de protection des données inférieur à celui des tables permanentes, ce qui signifie que les données d’une table transitoire peuvent être perdues en cas de défaillance du système. Par conséquent, les tables transitoires ne devraient être utilisées que pour les données qui peuvent être recréées à l’extérieur de Snowflake.

Par défaut : aucune valeur. Si une table n’est pas déclarée comme TRANSIENT ou TEMPORARY, la table est permanente.

Note

Les tables transitoires ont toutes deux des conditions de stockage.

Pour plus d’informations sur ces considérations et d’autres considérations lors de la décision de créer des tables temporaires ou transitoires, voir Utilisation de tables temporaires et transitoires et Coûts de stockage pour Time Travel et Fail-safe.

CONSTRAINT ...

Définit une contrainte en ligne ou hors ligne pour la ou les colonnes spécifiées dans la table.

Pour plus d’informations sur la syntaxe, voir CREATE | ALTER TABLE … CONSTRAINT. Pour plus d’informations sur les contraintes, voir Contraintes.

COLLATE 'collation_specification'

Spécifie le classement à utiliser pour des opérations de colonne telles que la comparaison de chaînes. Cette option s’applique uniquement aux colonnes de texte (VARCHAR, STRING, TEXT, etc.). Pour plus de détails, voir Spécifications de classement.

DEFAULT ... ou . AUTOINCREMENT ...

Indique si une valeur par défaut est automatiquement insérée dans la colonne lorsqu’une valeur n’est pas spécifiée explicitement via une instruction INSERT ou CREATE TABLE AS SELECT :

DEFAULT expr

La valeur par défaut de la colonne est définie par l’expression spécifiée, qui peut être l’une des suivantes :

  • Valeur constante.

  • Référence à la séquence (seq_name.NEXTVAL).

  • Expression simple qui renvoie une valeur scalaire.

    L’expression simple peut inclure une UDF (fonction définie par l’utilisateur) SQL si l’UDF n’est pas une UDF sécurisée.

    Note

    Si une expression par défaut fait référence à une UDF SQL, la fonction est remplacée par sa définition au moment de la création de la table. Si la fonction définie par l’utilisateur est redéfinie à l’avenir, cela ne mettra pas à jour l’expression par défaut de la colonne.

    L’expression simple ne peut pas contenir des références à :

    • Sous-requêtes.

    • Agrégats.

    • Des fonctions de fenêtre.

    • Des UDFs sécurisées.

    • Des UDFs écrites dans des langages autres que SQL (par exemple, Java, JavaScript).

    • Fonctions externes.

{ AUTOINCREMENT | IDENTITY } . [ { ( start_num , step_num ) | START num INCREMENT num } ] . [ { ORDER | NOORDER } ]

Quand vous spécifiez AUTOINCREMENT ou IDENTITY, la valeur par défaut de la colonne commence par un nombre spécifié et chaque valeur successive augmente automatiquement de la somme spécifiée.

AUTOINCREMENT et IDENTITY sont des synonymes et ne peuvent être utilisés que pour les colonnes dont le type de données est numérique, comme NUMBER, INT, FLOAT.

Prudence

Snowflake utilise une séquence pour générer les valeurs d’une colonne auto-incrémentée. Les séquences ont des limites ; voir Sémantique de séquence.

La valeur par défaut de la valeur de départ et de la valeur de pas/incrément est 1.

Note

L’insertion manuelle de valeurs dans une colonne AUTOINCREMENT ou IDENTITY peut entraîner des valeurs en double. Si vous insérez manuellement la valeur 5 dans une colonne AUTOINCREMENT ou IDENTITY, une ligne insérée ultérieurement risque d’utiliser la même valeur 5 comme valeur par défaut de la colonne.

Utilisez ORDER ou NOORDER pour spécifier si les valeurs sont générées pour la colonne à incrémentation automatique dans l’ordre croissant ou décroissant.

  • ORDER spécifie que les valeurs générées pour une séquence ou une colonne auto-incrémentée sont dans l’ordre croissant sont en ordre croissant (ou, si l’intervalle est une valeur négative, en ordre décroissant).

    Par exemple, si une séquence ou une colonne auto-incrémentée comporte START 1 INCREMENT 2, les valeurs générées peuvent être 1, 3, 5, 7, 9, etc.

  • NOORDER précise que l’ordre croissant des valeurs n’est pas garanti.

    Par exemple, si une séquence comporte START 1 INCREMENT 2, les valeurs générées peuvent être 1, 3, 101, 5, 103, etc.

    NOORDER peut améliorer les performances lorsque plusieurs opérations INSERT doivent être effectuées simultanément (par exemple, lorsque plusieurs clients exécutent plusieurs instructions INSERT).

Si vous ne spécifiez pas ORDER ou NOORDER, le paramètre NOORDER_SEQUENCE_AS_DEFAULT détermine la propriété à définir.

Note

DEFAULT et AUTOINCREMENT s’excluent mutuellement ; une seule des deux peut être spécifiée pour une colonne.

MASKING POLICY = policy_name

Spécifie la politique de masquage à définir sur une colonne.

Ce paramètre n’est pas pris en charge par la syntaxe de variante CREATE OR ALTER.

PROJECTION POLICY policy_name

Spécifie la politique de projection à définir sur une colonne.

Ce paramètre n’est pas pris en charge par la syntaxe de variante CREATE OR ALTER.

COMMENT 'string_literal'

Spécifie un commentaire pour la colonne.

(Notez que les commentaires peuvent être spécifiés au niveau de la colonne ou de la table. La syntaxe de chacun est légèrement différente).

USING ( col_name , cond_col_1 ... )

Spécifie les arguments à passer dans l’expression SQL de la politique de masquage conditionnelle.

La première colonne de la liste spécifie la colonne pour les conditions de la politique de masquage ou de tokenisation des données et doit correspondre à la colonne à laquelle la politique de masquage est définie.

Les colonnes supplémentaires spécifient les colonnes à évaluer pour déterminer s’il faut masquer ou tokeniser les données de chaque ligne du résultat de la requête lorsqu’une requête est effectuée sur la première colonne.

Si la clause USING est omise, Snowflake traite la politique de masquage conditionnelle comme une politique de masquage normale.

CLUSTER BY ( expr [ , expr , ... ] )

Spécifie une ou plusieurs colonnes ou expressions de colonne dans la table comme clés de clustering. Pour plus de détails, voir Clés de clustering et tables en cluster.

Par défaut : aucune valeur (aucune clé de clustering n’est définie pour la table)

Important

Les clés de clustering ne sont pas recommandées ni conçues pour toutes les tables. Elles sont généralement intéressantes pour les tables très importantes (de plusieurs téraoctets).

Avant de spécifier une clé de clustering pour une table, vous devez comprendre ce que sont les micro-partitions. Pour plus d’informations, voir Fonctionnement des structures de table dans Snowflake.

ENABLE_SCHEMA_EVOLUTION = { TRUE | FALSE }

Active ou désactive les modifications automatiques du schéma de table à partir des données chargées dans la table depuis les fichiers sources, notamment :

  • Colonnes ajoutées.

    Par défaut, l’évolution du schéma est limitée à un maximum de 10 colonnes ajoutées par opération de chargement. Pour demander plus de 10 colonnes ajoutées par opération de chargement, contactez le support Snowflake.

  • La contrainte NOT NULL peut être supprimée pour n’importe quel nombre de colonnes manquantes dans les nouveaux fichiers de données.

La valeur TRUE permet l’évolution automatique du schéma de table. La valeur par défaut FALSE désactive l’évolution automatique du schéma de table.

Note

Le chargement de données à partir de fichiers fait évoluer les colonnes des tables lorsque toutes les conditions suivantes sont réunies :

  • L’instruction COPY INTO <table> inclut l’option MATCH_BY_COLUMN_NAME.

  • Le rôle utilisé pour charger les données dispose du privilège EVOLVE SCHEMA ou OWNERSHIP sur la table.

En outre, pour l’évolution du schéma avec CSV, lorsqu’il est utilisé avec MATCH_BY_COLUMN_NAME et PARSE_HEADER, ERROR_ON_COLUMN_COUNT_MISMATCH doit être défini comme faux.

DATA_RETENTION_TIME_IN_DAYS = integer

Spécifie la période de conservation de la table pour que les actions Time Travel (SELECT, CLONE, UNDROP) puissent être effectuées sur les données historiques de la table. Pour plus de détails, voir Compréhension et utilisation de la fonction Time Travel et Utilisation de tables temporaires et transitoires.

Pour une description détaillée de ce paramètre de niveau objet, ainsi que plus d’informations sur les paramètres d’objet, voir Paramètres.

Valeurs :

  • Édition Standard : 0 ou 1

  • Édition Enterprise :

    • 0 à 90 pour les tables permanentes

    • 0 ou 1 pour les tables temporaires et transitoires

Par défaut :

  • Édition Standard : 1

  • Édition Enterprise (ou supérieure) : 1 (sauf si une valeur par défaut différente a été spécifiée au niveau du compte, du schéma ou de la base de données)

Note

Une valeur de 0 désactive effectivement Time Travel pour la table.

MAX_DATA_EXTENSION_TIME_IN_DAYS = integer

Paramètre d’objet qui spécifie le nombre maximum de jours pendant lesquels Snowflake peut prolonger la période de conservation des données de la table, afin d’éviter que les flux sur la table ne deviennent obsolètes.

Pour une description détaillée de ce paramètre, voir MAX_DATA_EXTENSION_TIME_IN_DAYS.

CHANGE_TRACKING = { TRUE | FALSE }

Spécifie s’il faut activer le suivi des modifications sur la table.

  • TRUE active le suivi des modifications sur la table. Ce paramètre ajoute une paire de colonnes masquées à la table source et commence à stocker les métadonnées de suivi des modifications dans les colonnes. Ces colonnes consomment une petite quantité de stockage.

    Les métadonnées de suivi des modifications peuvent être interrogées à l’aide de la clause CHANGES pour les instructions SELECT, ou en créant et en interrogeant un ou plusieurs flux sur la table.

  • FALSE n’active pas le suivi des modifications sur la table.

Par défaut : FALSE

DEFAULT_DDL_COLLATION = 'collation_specification'

Spécifie une spécification de classement par défaut pour les colonnes de la table, y compris les colonnes ajoutées à la table à l’avenir.

Pour plus de détails sur le paramètre, voir DEFAULT_DDL_COLLATION.

COPY GRANTS

Spécifie de conserver les privilèges d’accès de la table d’origine lorsqu’une nouvelle table est créée à l’aide de l’une des variables CREATE TABLE suivantes :

  • CREATE OR REPLACE TABLE

  • CREATE TABLE … LIKE

  • CREATE TABLE … CLONE

Ce paramètre copie tous les privilèges, excepté OWNERSHIP, de la table existante vers la nouvelle table. La nouvelle table n’hérite pas des attributions futures définies pour le type d’objet dans le schéma. Par défaut, le rôle qui exécute l’instruction CREATE TABLE possède la nouvelle table.

Si le paramètre n’est pas inclus dans l’instruction CREATE TABLE, la nouvelle table n’hérite pas des privilèges d’accès explicites accordés sur la table d’origine, mais des attributions futures définies pour le type d’objet dans le schéma.

Remarque :

  • Avec le partage des données :

    • Si la table existante a été partagée avec un autre compte, la table de remplacement est également partagée.

    • Si la table existante a été partagée avec votre compte en tant que consommateur de données et que l’accès a été accordé à d’autres rôles dans le compte (en utilisant GRANT IMPORTED PRIVILEGES sur la base de données mère), l’accès est également accordé à la table de remplacement.

  • La sortie SHOW GRANTS pour la table de remplacement liste le concessionnaire des privilèges copiés comme le rôle qui a exécuté l’instruction CREATE TABLE avec l’horodatage courant lorsque l’instruction a été exécutée.

  • L’opération de copie des accords s’effectue atomiquement dans la commande CREATE TABLE (c’est-à-dire dans la même transaction).

  • Ce paramètre n’est pas pris en charge par la syntaxe de variante CREATE OR ALTER.

COMMENT = 'string_literal'

Spécifie un commentaire pour la table.

Par défaut : aucune valeur

(Notez que les commentaires peuvent être spécifiés au niveau de la colonne, de la contrainte ou de la table. La syntaxe de chacun est légèrement différente).

ROW ACCESS POLICY policy_name ON ( col_name [ , col_name ... ] )

Spécifie la politique d’accès aux lignes à définir sur une table.

Ce paramètre n’est pas pris en charge par la syntaxe de variante CREATE OR ALTER.

AGGREGATION POLICY policy_name [ ENTITY KEY ( col_name [ , col_name ... ] ) ]

Spécifie la politique d’agrégation à définir sur une table.

Utilisez le paramètre ENTITY KEY facultatif pour définir les colonnes qui identifient de manière unique une entité dans la table. Pour plus d’informations, voir Mise en œuvre de la protection de la confidentialité au niveau de l’entité à l’aide de politiques d’agrégation.

Ce paramètre n’est pas pris en charge par la syntaxe de variante CREATE OR ALTER.

TAG ( tag_name = 'tag_value' [ , tag_name = 'tag_value' , ... ] )

Spécifie le nom de la balise et la valeur de la chaîne de la balise.

La valeur de la balise est toujours une chaîne de caractères et le nombre maximum de caractères pour la valeur de la balise est 256.

Pour plus d’informations sur la spécification des balises dans une instruction, voir Quotas de balises pour les objets et les colonnes.

Ce paramètre n’est pas pris en charge par la syntaxe de variante CREATE OR ALTER.

Exigences en matière de contrôle d’accès

Un rôle utilisé pour exécuter cette commande SQL doit avoir les privilèges suivants définis au minimum ainsi :

Privilège

Objet

Remarques

CREATE TABLE

Schéma

Notez que la création d’une table temporaire ne nécessite pas le privilège CREATE TABLE.

SELECT

Table, table externe, vue

Requis sur les tables et/ou vues interrogées uniquement lors du clonage d’une table ou de l’exécution d’instructions CTAS.

APPLY

Politique de masquage, politique d’accès aux lignes, balise

Requis uniquement lors de l’application d’une politique de masquage, d’une politique d’accès aux lignes, de balises d’objet ou de toute combinaison de ces fonctions de gouvernance lors de la création de tables.

USAGE (zone de préparation externe) ou READ (zone de préparation interne)

Zone de préparation

Nécessaire pour dériver les définitions de colonnes de tables à partir de fichiers en zone de préparation en utilisant les instructions CREATE TABLE … USING TEMPLATE.

OWNERSHIP

Table

  • Un rôle doit se voir accorder le privilège OWNERSHIP ou en hériter sur l’objet pour créer un objet temporaire portant le même nom que l’objet qui existe déjà dans le schéma.

  • Obligatoire pour exécuter une instruction CREATE OR ALTER TABLE pour une table existante.

OWNERSHIP is a special privilege on an object that is automatically granted to the role that created the object, but can also be transferred using the GRANT OWNERSHIP command to a different role by the owning role (or any role with the MANAGE GRANTS privilege).

Note that in a managed access schema, only the schema owner (i.e. the role with the OWNERSHIP privilege on the schema) or a role with the MANAGE GRANTS privilege can grant or revoke privileges on objects in the schema, including future grants.

Notez que l’exploitation d’un objet dans un schéma requiert également le privilège USAGE sur la base de données et le schéma parents.

Pour obtenir des instructions sur la création d’un rôle personnalisé avec un ensemble spécifique de privilèges, voir Création de rôles personnalisés.

Pour des informations générales sur les rôles et les privilèges accordés pour effectuer des actions SQL sur des objets sécurisables, voir Aperçu du contrôle d’accès.

Notes sur l’utilisation

  • Un schéma ne peut pas contenir de tables et/ou de vues portant le même nom. Lors de la création d’une table :

    • Si une vue portant le même nom existe déjà dans le schéma, une erreur est renvoyée et la table n’est pas créée.

    • Si une table portant le même nom existe déjà dans le schéma, une erreur est renvoyée et la table n’est pas créée, sauf si le mot clé facultatif OR REPLACE est inclus dans la commande.

      Important

      Utiliser OR REPLACE équivaut à utiliser DROP TABLE sur la table existante et créer ensuite une nouvelle table avec le même nom ; cependant, la table détruite n’est pas définitivement supprimée du système. En revanche, il est conservé dans Time Travel. Cela est important, car si les tables détruites dans Time Travel peuvent être récupérées, elles contribuent aussi au stockage des données pour votre compte. Pour plus d’informations, voir Coûts de stockage pour Time Travel et Fail-safe.

      Les instructions CREATE OR REPLACE <objet> sont atomiques. En d’autres termes, lorsqu’un objet est remplacé, l’ancien objet est supprimé et le nouvel objet est créé dans une seule transaction.

      Cela signifie que toutes les requêtes simultanées à l’opération CREATE OR REPLACE TABLE utilisent soit l’ancienne soit la nouvelle version de la table.

      La recréation ou le remplacement d’une table entraîne la destruction de ses données de modification. Tout flux sur la table devient obsolète. En outre, tout flux sur une vue qui a cette table comme table sous-jacente, devient obsolète. Un flux périmé est illisible.

  • Comme les mots clés réservés, les noms de fonctions réservés ANSI (CURRENT_DATE, CURRENT_TIMESTAMP, etc.) ne peuvent pas être utilisés comme noms de colonnes.

  • CREATE OR ALTER TABLE:

    Pour plus d’informations, voir Notes sur l’utilisation de CREATE OR ALTER TABLE.

  • CREATE TABLE … CLONE :

    Si la table source a des clés de clustering, alors la nouvelle table a des clés de clustering. Par défaut, le clustering automatique est suspendu pour la nouvelle table, même si le clustering automatique n’était pas suspendu pour la table source.

  • CREATE TABLE … CHANGE_TRACKING = TRUE :

    Lorsque le suivi des modifications est activé, la table est verrouillée pendant la durée de l’opération. Les verrous peuvent entraîner une latence avec certaines opérations DDL/DML associées. Pour plus d’informations, reportez-vous à Verrouillage des ressources.

  • CREATE TABLE … LIKE :

    Si la table source a des clés de clustering, alors la nouvelle table a des clés de clustering. Par défaut, le clustering automatique n’est pas suspendu pour la nouvelle table, même si le clustering automatique a été suspendu pour la table source.

  • CREATE TABLE … AS SELECT (CTAS):

    • Si les alias des noms de colonnes de la liste SELECT sont des colonnes valides, les définitions de colonnes ne sont pas requises dans l’instruction CTAS ; si elles sont omises, les noms et types de colonnes sont déduits de la requête sous-jacente :

      CREATE TABLE <table_name> AS SELECT ...
      Copy

      Alternativement, les noms peuvent être explicitement spécifiés à l’aide de la syntaxe suivante :

      CREATE TABLE <table_name> ( <col1_name> , <col2_name> , ... ) AS SELECT ...
      Copy

      Le nombre de noms de colonnes spécifiés doit correspondre au nombre d’éléments de la liste SELECT de la requête ; les types de colonnes sont déduits des types produits par la requête.

    • Lorsque les clés de clustering sont spécifiées dans une instruction CTAS :

      • Les définitions des colonnes sont obligatoires et doivent être explicitement spécifiées dans l’instruction.

      • Par défaut, le clustering automatique n’est pas suspendu pour la nouvelle table, même si le clustering automatique est suspendu pour la table source.

    • Si vous voulez que la table soit créée avec des lignes dans un ordre spécifique, utilisez une sous-clause ORDER BY dans la clause SELECT du CTAS. En spécifiant CLUSTER BY, les données ne sont pas regroupées au moment de la création de la table ; CLUSTER BY s’appuie sur le clustering automatique pour regrouper à nouveau les données au fil du temps.

      La sous-clause ORDER BY d’une instruction CREATE TABLE n’affecte pas l’ordre des lignes retournées par les futures instructions SELECT sur cette table. Pour spécifier l’ordre des lignes dans les futures instructions SELECT, utilisez une sous-clause ORDER BY dans ces instructions.

  • Dans une transaction, toute instruction DDL (y compris CREATE TEMPORARY/TRANSIENT TABLE) valide la transaction avant d’exécuter l’instruction DDL elle-même. L’instruction DDL s’exécute ensuite dans sa propre transaction. L’instruction suivante après l’instruction DDL démarre une nouvelle transaction. Par conséquent, vous ne pouvez pas créer, utiliser et supprimer une table temporaire ou transitoire dans une seule transaction. Si vous souhaitez utiliser une table temporaire ou transitoire dans une transaction, créez la table avant la transaction et supprimez la table après la transaction.

  • La recréation d’une table (en utilisant le mot clé OR REPLACE facultatif) détruit son historique, ce qui rend tout flux sur la table périmé. Un flux périmé est illisible.

  • Une seule politique de masquage qui utilise des colonnes conditionnelles peut être appliquée à plusieurs tables, à condition que la structure des colonnes de la table corresponde aux colonnes spécifiées dans la politique.

  • Lors de la création d’une table avec une politique de masquage sur une ou plusieurs colonnes de la table ou une politique d’accès aux lignes ajoutée à la table, utilisez la fonction POLICY_CONTEXT pour simuler une requête sur la ou les colonnes protégées par une politique de masquage et la table protégée par une politique d’accès aux lignes.

  • Concernant les métadonnées :

    Attention

    Les clients doivent s’assurer qu’aucune donnée personnelle (autre que pour un objet utilisateur), donnée sensible, donnée à exportation contrôlée ou autre donnée réglementée n’est saisie comme métadonnée lors de l’utilisation du service Snowflake. Pour plus d’informations, voir Champs de métadonnées dans Snowflake.

Notes sur l’utilisation de CREATE OR ALTER TABLE

  • Limitations

    • Actuellement, prend en charge uniquement les tables permanentes, temporaires et transitoires. Les tables en lecture seule, externes, dynamiques, Apache Iceberg™ et hybrides ne sont pas prises en charge.

    • Toutes les limitations de la commande ALTER TABLE s’appliquent.

    • Actuellement, ne prend pas en charge les éléments suivants :

      • La syntaxe de variante CREATE TABLE … AS SELECT (CTAS).

      • La syntaxe de variante CREATE TABLE … USING TEMPLATE.

      • La syntaxe de variante CREATE TABLE … LIKE.

      • La syntaxe de variante CREATE TABLE … CLONE.

  • Paramètres et propriétés de la table

    • L’absence d’une propriété ou d’un paramètre précédemment défini dans la définition de table modifiée entraîne sa désactivation.

    • La désactivation de la valeur explicite d’un paramètre entraîne sa définition sur la valeur par défaut du paramètre. Si le paramètre est défini sur le schéma ou la base de données qui contient la table, la table hérite de la valeur de paramètre définie sur le schéma ou la base de données.

  • Gouvernance des données

    • L’activation ou la désactivation d’une balise ou d’une politique sur une table ou une colonne à l’aide d’une instruction CREATE OR ALTER TABLE n’est pas prise en charge.

      Les politiques ou balises existantes ne sont pas modifiées par une instruction CREATE OR ALTER et restent inchangées.

  • Contraintes

    L’activation ou la désactivation d’une clé primaire en ligne modifie la nullabilité de la colonne en conséquence. Cela correspond au comportement de la commande CREATE TABLE, mais diffère du comportement de la commande ALTER TABLE.

  • Colonnes

    • Il est possible d’ajouter de nouvelles colonnes uniquement à la fin de la liste de colonnes.

    • Les colonnes ne peuvent pas être renommées. Si vous tentez de renommer une colonne, celle-ci est supprimée et une nouvelle colonne est ajoutée.

    • La valeur par défaut d’une colonne peut être modifiée uniquement de sorte à utiliser une séquence.

    • La séquence par défaut d’une colonne (par exemple, SET DEFAULT seq_name.NEXTVAL) ne peut être modifiée que si la colonne possède déjà une séquence.

    • Pour plus d’informations sur la modification de colonnes, voir ALTER TABLE … ALTER COLUMN.

  • Classement

    • Les spécifications de classement ne peuvent pas être modifiées.

    • La définition du paramètre DEFAULT_DDL_COLLATION dans la commande CREATE OR ALTER TABLE définit la spécification de classement par défaut des colonnes existantes, ce qui garantit que la commande CREATE OR ALTER TABLE donne les mêmes résultats que la commande CREATE TABLE. Par conséquent, vous ne pouvez pas utiliser la commande CREATE OR ALTER TABLE pour définir le paramètre DEFAULT_DDL_COLLATION sur une table comportant des colonnes de texte existantes. Vous pouvez toutefois rendre les classements explicites pour les colonnes existantes lors de la modification du paramètre DEFAULT_DDL_COLLATION d’une table.

      Par exemple, créez une nouvelle table my_table et définissez la spécification de classement par défaut de la table sur « fr » :

      CREATE OR ALTER TABLE my_table (
  a INT PRIMARY KEY,
  b VARCHAR(20)
)
DEFAULT_DDL_COLLATION = 'fr';
      Copy

      La spécification de classement de la colonne b est « fr » et elle ne peut pas être modifiée. Pour modifier la spécification de classement par défaut de la table my_table, vous devez définir explicitement le classement de la colonne de texte b dans l’instruction CREATE OR ALTER :

      CREATE OR ALTER TABLE my_table (
  a INT PRIMARY KEY,
  b VARCHAR(200) COLLATE 'fr'
)
DEFAULT_DDL_COLLATION = 'de';
      Copy

  • Atomicité

    Actuellement, la commande CREATE OR ALTER TABLE ne garantit pas l’atomicité. Cela signifie que si une instruction CREATE OR ALTER TABLE échoue lors de l’exécution, il est possible qu’un sous-ensemble de modifications ait été appliqué à la table. S’il existe une possibilité de modifications partielles, le message d’erreur, dans la plupart des cas, comprend le texte suivant :

    CREATE OR ALTER execution failed. Partial updates may have been applied.

    Par exemple, si l’instruction tente de supprimer la colonne A et d’ajouter une nouvelle colonne B à une table, et si l’instruction est interrompue, il est possible que la colonne A ait été abandonnée, mais que la colonne B n’ait pas été supprimée.

    Note

    Si les modifications sont partiellement appliquées, la table résultante est toujours à l’état valide et vous pouvez utiliser d’autres instructions ALTER TABLE pour compléter l’ensemble de modifications d’origine.

    Pour une récupération suite à des mises à jour partielles, Snowflake recommande les mécanismes de récupération suivants :

    • Fix forward (Correction vers l’avant)

      • Réexécutez l’instruction CREATEORALTERTABLE. Si l’instruction réussit lors de la deuxième tentative, l’état cible est atteint.

      • Analysez le message d’erreur. Si possible, corrigez l’erreur et réexécutez l’instruction CREATE OR ALTER TABLE.

    • Roll back (Retour en arrière)

      S’il n’est pas possible de corriger vers l’avant, Snowflake recommande d’annuler manuellement les modifications partielles :

      • Examinez l’état de la table à l’aide des commandes DESCRIBE TABLE et SHOW TABLES. Déterminez les modifications partielles qui ont été appliquées, le cas échéant.

      • Si des modifications partielles ont été appliquées, exécutez les instructions ALTER TABLE appropriées pour ramener la table à son état d’origine.

        Note

        Dans certains cas, il se peut que vous ne puissiez pas annuler des modifications partielles. Pour plus d’informations, voir les actions prises en charge et non prises en charge pour la modification des propriétés des colonnes dans la rubrique ALTER TABLE … ALTER COLUMN.

    • Si vous avez besoin d’aide pour rétablir l’état précédant une mise à jour partielle, contactez le support Snowflake.

Exemples

Exemples de base

Créer une table simple dans la base de données courante et insérer une ligne dans la table :

CREATE TABLE mytable (amount NUMBER);

+-------------------------------------+
| status                              |
|-------------------------------------|
| Table MYTABLE successfully created. |
+-------------------------------------+

INSERT INTO mytable VALUES(1);

SHOW TABLES like 'mytable';

+---------------------------------+---------+---------------+-------------+-------+---------+------------+------+-------+--------------+----------------+
| created_on                      | name    | database_name | schema_name | kind  | comment | cluster_by | rows | bytes | owner        | retention_time |
|---------------------------------+---------+---------------+-------------+-------+---------+------------+------+-------+--------------+----------------|
| Mon, 11 Sep 2017 16:32:28 -0700 | MYTABLE | TESTDB        | PUBLIC      | TABLE |         |            |    1 |  1024 | ACCOUNTADMIN | 1              |
+---------------------------------+---------+---------------+-------------+-------+---------+------------+------+-------+--------------+----------------+

DESC TABLE mytable;

+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name   | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| AMOUNT | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
Copy

Créer une table simple et spécifier des commentaires pour la table et la colonne de la table :

CREATE TABLE example (col1 NUMBER COMMENT 'a column comment') COMMENT='a table comment';

+-------------------------------------+
| status                              |
|-------------------------------------|
| Table EXAMPLE successfully created. |
+-------------------------------------+

SHOW TABLES LIKE 'example';

+---------------------------------+---------+---------------+-------------+-------+-----------------+------------+------+-------+--------------+----------------+
| created_on                      | name    | database_name | schema_name | kind  | comment         | cluster_by | rows | bytes | owner        | retention_time |
|---------------------------------+---------+---------------+-------------+-------+-----------------+------------+------+-------+--------------+----------------|
| Mon, 11 Sep 2017 16:35:59 -0700 | EXAMPLE | TESTDB        | PUBLIC      | TABLE | a table comment |            |    0 |     0 | ACCOUNTADMIN | 1              |
+---------------------------------+---------+---------------+-------------+-------+-----------------+------------+------+-------+--------------+----------------+

DESC TABLE example;

+------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment          |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------|
| COL1 | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | a column comment |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------+
Copy

Exemples CTAS

Créer une table via une sélection à partir d’une table existante :

CREATE TABLE mytable_copy (b) AS SELECT * FROM mytable;

DESC TABLE mytable_copy;

+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| B    | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

CREATE TABLE mytable_copy2 AS SELECT b+1 AS c FROM mytable_copy;

DESC TABLE mytable_copy2;

+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| C    | NUMBER(39,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

SELECT * FROM mytable_copy2;

+---+
| C |
|---|
| 2 |
+---+
Copy

Exemple plus avancé de création d’une table en effectuant une sélection à partir d’une table existante ; dans cet exemple, les valeurs de la colonne summary_amount de la nouvelle table sont obtenues à partir de deux colonnes de la table source :

CREATE TABLE testtable_summary (name, summary_amount) AS SELECT name, amount1 + amount2 FROM testtable;
Copy

Créer une table en sélectionnant des colonnes à partir d’un fichier de données Parquet préparé :

CREATE OR REPLACE TABLE parquet_col (
  custKey NUMBER DEFAULT NULL,
  orderDate DATE DEFAULT NULL,
  orderStatus VARCHAR(100) DEFAULT NULL,
  price VARCHAR(255)
)
AS SELECT
  $1:o_custkey::number,
  $1:o_orderdate::date,
  $1:o_orderstatus::text,
  $1:o_totalprice::text
FROM @my_stage;

+-----------------------------------------+
| status                                  |
|-----------------------------------------|
| Table PARQUET_COL successfully created. |
+-----------------------------------------+

DESC TABLE parquet_col;

+-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name        | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| CUSTKEY     | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| ORDERDATE   | DATE         | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| ORDERSTATUS | VARCHAR(100) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| PRICE       | VARCHAR(255) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
Copy

Exemples CREATE TABLE … LIKE

Créer une table avec les mêmes définitions de colonnes qu’une autre table, mais sans lignes :

CREATE TABLE mytable (amount NUMBER);

INSERT INTO mytable VALUES(1);

SELECT * FROM mytable;

+--------+
| AMOUNT |
|--------|
|      1 |
+--------+

CREATE TABLE mytable_2 LIKE mytable;

DESC TABLE mytable_2;

+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name   | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| AMOUNT | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

SELECT * FROM mytable_2;

+--------+
| AMOUNT |
|--------|
+--------+
Copy

Exemples CREATE TABLE définissant des paramètres et des propriétés

Créer une table avec une clé de clustering multi-colonnes :

CREATE TABLE mytable (date TIMESTAMP_NTZ, id NUMBER, content VARIANT) CLUSTER BY (date, id);

SHOW TABLES LIKE 'mytable';

+---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------+
| created_on                      | name    | database_name | schema_name | kind  | comment | cluster_by       | rows | bytes | owner        | retention_time |
|---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------|
| Mon, 11 Sep 2017 16:20:41 -0700 | MYTABLE | TESTDB        | PUBLIC      | TABLE |         | LINEAR(DATE, ID) |    0 |     0 | ACCOUNTADMIN | 1              |
+---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------+
Copy

Spécifier un classement des colonnes dans une table :

CREATE OR REPLACE TABLE collation_demo (
  uncollated_phrase VARCHAR, 
  utf8_phrase VARCHAR COLLATE 'utf8',
  english_phrase VARCHAR COLLATE 'en',
  spanish_phrase VARCHAR COLLATE 'es');

INSERT INTO collation_demo (
      uncollated_phrase, 
      utf8_phrase, 
      english_phrase, 
      spanish_phrase) 
   VALUES (
     'pinata', 
     'pinata', 
     'pinata', 
     'piñata');
Copy

Exemples CREATE TABLE … USING TEMPLATE

Créez une table dont les définitions de colonne sont dérivées d’un ensemble de fichiers en zone de préparation qui contiennent des données Avro, Parquet ou ORC.

Notez que la zone de préparation mystage et le format de fichier my_parquet_format référencés dans l’instruction doivent déjà exister. Un ensemble de fichiers doit déjà être en zone de préparation dans l’emplacement de stockage Cloud référencé dans la définition de la zone de préparation.

L’exemple suivant crée une table en utilisant le schéma détecté à partir de fichiers en zone de préparation et trie les colonnes par order_id. Cet exemple s’appuie sur un exemple de la rubrique INFER_SCHEMA :

CREATE TABLE mytable
  USING TEMPLATE (
    SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
    WITHIN GROUP (ORDER BY order_id)
      FROM TABLE(
        INFER_SCHEMA(
          LOCATION=>'@mystage',
          FILE_FORMAT=>'my_parquet_format'
        )
      ));
Copy

Notez que le tri des colonnes par order_id ne s’applique que si tous les fichiers en zone de préparation partagent un même schéma. Si l’ensemble des fichiers de données en zone de préparation comprend plusieurs schémas avec des noms de colonnes partagés, l’ordre représenté dans la colonne order_id peut ne pas correspondre à un seul fichier.

Note

L’utilisation de * pour ARRAY_AGG(OBJECT_CONSTRUCT()) peut entraîner une erreur si le résultat renvoyé est supérieur à 16MB. Il est recommandé d’éviter d’utiliser * pour les jeux de résultats plus importants et de n’utiliser que les colonnes nécessaires, COLUMN NAME, TYPE, et NULLABLE, pour la requête. La colonne facultative ORDER_ID peut être incluse lorsque vous utilisez WITHIN GROUP (ORDER BY order_id).

Exemples de table temporaire

Créez une table temporaire qui est automatiquement détruite à la fin de la session :

CREATE TEMPORARY TABLE demo_temporary (i INTEGER);
CREATE TEMP TABLE demo_temp (i INTEGER);
Copy

Pour des raisons de compatibilité avec d’autres fournisseurs, Snowflake prend également en charge l’utilisation des mots clés ci-dessous comme synonymes de TEMPORARY :

CREATE LOCAL TEMPORARY TABLE demo_local_temporary (i INTEGER);
CREATE LOCAL TEMP TABLE demo_local_temp (i INTEGER);

CREATE GLOBAL TEMPORARY TABLE demo_global_temporary (i INTEGER);
CREATE GLOBAL TEMP TABLE demo_global_temp (i INTEGER);

CREATE VOLATILE TABLE demo_volatile (i INTEGER);
Copy

Exemples CREATE OR ALTER TABLE

Créez une table my_table à l’aide de la commande CREATE OR ALTER TABLE :

CREATE OR ALTER TABLE my_table(a INT);
Copy

Note

Les instructions CREATE OR ALTER TABLE appliquées aux tables existantes ne peuvent être exécutées que par un rôle disposant du privilège OWNERSHIP sur la table my_table.

Modifiez la table my_table pour ajouter et modifier des colonnes et définir les paramètres DATA_RETENTION_TIME_IN_DAYS et DEFAULT_DDL_COLLATION :

CREATE OR ALTER TABLE my_table(
    a INT PRIMARY KEY,
    b VARCHAR(200)
  )
  DATA_RETENTION_TIME_IN_DAYS = 5
  DEFAULT_DDL_COLLATION = 'de';
Copy

Annulez la définition du paramètre DATA_RETENTION_TIME_IN_DAYS. L’absence d’un paramètre dans la définition de table modifiée entraîne sa désactivation. Dans ce cas, la désactivation du paramètre DATA_RETENTION_TIME_IN_DAYS de la table le rétablit à la valeur par défaut de 1 :

CREATE OR ALTER TABLE my_table(
    a INT PRIMARY KEY,
    c VARCHAR(200)
  )
  DEFAULT_DDL_COLLATION = 'de';
Copy

La commande CREATE OR ALTER TABLE permet d’ajouter des colonnes à la fin de la liste de colonnes. Si vous tentez de renommer une colonne existante, celle-ci est supprimée et une nouvelle colonne portant le nouveau nom est ajoutée. Cela peut entraîner une perte de données s’il existe des données dans la colonne d’origine.

L’exemple suivant illustre ce comportement.

  1. Créez une table :

    CREATE OR ALTER TABLE my_table(
    a INT PRIMARY KEY,
    b INT
  );
    Copy

  2. Insérez des données dans la table my_table :

    INSERT INTO my_table VALUES (1, 2), (2, 3);

SELECT * FROM my_table;
    Copy

    Renvoie :

    +---+---+
| A | B |
|---+---|
| 1 | 2 |
| 2 | 3 |
+---+---+

  3. Essayez de renommer la colonne b :

    CREATE OR ALTER TABLE my_table(
    a INT PRIMARY KEY,
    c INT
  );
    Copy

    La colonne b est supprimée et la colonne c est ajoutée :

    SELECT * FROM my_table;
    Copy

    Renvoie :

    +---+------+
| A | C    |
|---+------|
| 1 | NULL |
| 2 | NULL |
+---+------+

    Note

    Vous pouvez récupérer les colonnes supprimées à l’aide de Time Travel.

L’activation ou la désactivation d’une clé primaire en ligne modifie la nullabilité de la colonne d’une manière qui s’aligne sur le comportement de la commande CREATE TABLE, mais qui est différente du comportement de la commande ALTER TABLE. Par exemple, l’ajout d’une contrainte de clé primaire sur une colonne à l’aide d’une instruction ALTER TABLE ne modifie pas la nullabilité de la colonne.

L’exemple suivant illustre ce comportement.

  1. Créez une table :

    CREATE TABLE t(a INT);
    Copy

  2. Modifiez la table pour lui ajouter une contrainte PRIMARY KEY :

    CREATE OR ALTER TABLE t(a INT PRIMARY KEY);
    Copy

    La colonne a est désormais la clé primaire et a pour valeur NOT NULL :

    DESC TABLE t;
    Copy

    Renvoie :

    +------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
| A    | NUMBER(38,0) | COLUMN | N     | NULL    | Y           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+

  3. Remplacez la table t :

    CREATE OR REPLACE TABLE t(a INT);
    Copy

  4. Insérez une valeur NULL :

    INSERT INTO t VALUES (null);
    Copy

  5. Ajoutez une contrainte de clé primaire à la colonne a.

    La valeur NULL de la colonne a entraîne l’échec de l’instruction suivante :

    CREATE OR ALTER TABLE t(a INT PRIMARY KEY);
    Copy

    Renvoie :

    001471 (42601): SQL compilation error:
Column 'A' contains null values. Not null constraint cannot be added.
Langage: Français