PostgreSQLLa base de données la plus sophistiquée au monde.

Version anglaise

CREATE TABLE

CREATE TABLE — Définir une nouvelle table

Synopsis

              CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] nom_table ( [
  { nom_colonne type_donnees [ COLLATE collation ] [ contrainte_colonne [ ... ] ]
    | contrainte_table
    | LIKE table_source [ option_like ... ] }
    [, ... ]
] )
[ INHERITS ( table_parent [, ... ] ) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { nom_colonne | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING methode ]
[ WITH ( parametre_stockage [= valeur] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE nom_tablespace ]

CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE nom_table
    OF nom_type [ (
  { nom_colonne [ WITH OPTIONS ] [ contrainte_colonne [ ... ] ]
    | contrainte_table }
    [, ... ]
) ]
[ PARTITION BY { RANGE | LIST | HASH } ( { nom_colonne | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING methode ]
[ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE nom_tablespace ]

CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
    PARTITION OF parent_table [ (
  { nom_colonne [ WITH OPTIONS ] [ contrainte_colonne [ ... ] ]
    | table_constraint }
    [, ... ]
) ] { FOR VALUES spec_limites_partition | DEFAULT }
[ PARTITION BY { RANGE | LIST } ( { nom_colonne | ( expression ) } [ COLLATE collation ] [ opclass ] [, ... ] ) ]
[ USING methode ]
[ WITH ( parametre_stockage [= valeur] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE nom_tablespace ]

contrainte_colonne
peut être :

[ CONSTRAINT nom_contrainte ]
{ NOT NULL | NULL |
  CHECK ( expression ) [ NO INHERIT ] |
  DEFAULT expression_par_défaut |
  GENERATED ALWAYS AS ( expr_generation ) STORED |
  GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( options_sequence ) ] |
  UNIQUE parametres_index |
  PRIMARY KEY parametres_index |
  EXCLUDE [ USING methode_index ] ( élément_exclude WITH opérateur [, ... ] ) paramètres_index [ WHERE ( prédicat ) ] |
  REFERENCES table_reference [ ( colonne_reference ) ] [ MATCH FULL
| MATCH PARTIAL | MATCH SIMPLE ]
    [ ON DELETE action_referentielle ] [ ON UPDATE action_referentielle ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

et option_like peut
valoir :

{ INCLUDING | EXCLUDING } { COMMENTS | CONSTRAINTS | DEFAULTS | GENERATED | IDENTITY | INDEXES | STATISTICS | STORAGE | ALL }

and spec_limites_partition is:

IN ( expr_limite_partition [, ...] ) |
FROM ( { expr_limite_partition | MINVALUE | MAXVALUE } [, ...] )
  TO ( { expr_limite_partition | MINVALUE | MAXVALUE } [, ...] ) |
WITH ( MODULUS littéral_numérique, REMAINDER littéral_numérique )

et contrainte_table :

[ CONSTRAINT nom_contrainte ]
{ UNIQUE ( nom_colonne [, ... ] ) parametres_index |
  PRIMARY KEY ( nom_colonne [, ... ] ) parametres_index |
  CHECK ( expression ) [ NO INHERIT ] |
  FOREIGN KEY ( nom_colonne [, ...
] ) REFERENCES table_reference [ (
colonne_reference [, ... ] ) ]
    [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action_referentielle ] [ ON UPDATE action_referentielle ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

Les paramètres_index dans les
contraintes UNIQUE, PRIMARY KEY et
EXCLUDE sont :

[ INCLUDE ( nom_colonne [, ... ] ) ]
[ WITH ( paramètre_stockage [= valeur] [, ... ] ) ]
[ USING INDEX TABLESPACE nom_tablespace ]

exclude_element dans une
contrainte EXCLUDE peut valoir :

{ nom_colonne | ( expression ) } [ opclass ] [ ASC | DESC ] [ NULLS { FIRST | LAST } ]
  

Description

CREATE TABLE crée une nouvelle table initialement vide dans la base de données courante. La table appartient à l'utilisateur qui exécute cette commande.

Si un nom de schéma est donné (par exemple, CREATE TABLE monschema.matable ...), alors la table est créée dans le schéma spécifié. Dans le cas contraire, elle est créée dans le schéma courant. Les tables temporaires existent dans un schéma spécial, il n'est donc pas nécessaire de fournir un nom de schéma lors de la création d'une table temporaire. Le nom de la table doit être distinct du nom des autres tables, séquences, index, vues ou tables distantes dans le même schéma.

CREATE TABLE crée aussi automatiquement un type de données qui représente le type composé correspondant à une ligne de la table. Ainsi, les tables doivent avoir un nom distinct de tout type de données du même schéma.

Les clauses de contrainte optionnelles précisent les contraintes (ou tests) que les nouvelles lignes ou les lignes mises à jour doivent satisfaire pour qu'une opération d'insertion ou de mise à jour réussisse. Une contrainte est un objet SQL qui aide à définir l'ensemble des valeurs valides de différentes façons.

Il existe deux façons de définir des contraintes : celles de table et celles de colonnes. Une contrainte de colonne fait partie de la définition de la colonne. Une définition de contrainte de tables n'est pas liée à une colonne particulière et peut englober plusieurs colonnes. Chaque contrainte de colonne peut être écrite comme une contrainte de table ; une contrainte de colonne n'est qu'un outil de notation utilisé lorsque la contrainte n'affecte qu'une colonne.

Pour pouvoir créer une table, vous devez avoir le droit USAGE sur les types de chaque colonne ou sur le type indiqué dans la clause OF.

Paramètres

TEMPORARY ou TEMP

La table est temporaire. Les tables temporaires sont automatiquement supprimées à la fin d'une session ou, optionnellement, à la fin de la transaction en cours (voir ON COMMIT ci-dessous). Les tables permanentes qui portent le même nom ne sont pas visibles dans la session courante tant que la table temporaire existe sauf s'il y est fait référence par leur nom qualifié du schéma. Tous les index créés sur une table temporaire sont automatiquement temporaires.

Le démon autovacuum ne peut pas accéder et, du coup, ne peut pas exécuter un VACUUM ou un ANALYZE sur les tables temporaires. Pour cette raison, les opérations VACUUM et ANALYZE doivent être traitées via des commandes SQL de session. Par exemple, si une table temporaire doit être utilisée dans des requêtes complexes, il est raisonnable d'exécuter ANALYZE sur la table temporaire après qu'elle ait été peuplée.

On peut éventuellement écrire GLOBAL ou LOCAL avant TEMPORARY ou TEMP. Cela ne fait pas de différence dans PostgreSQL™ (cf. Cela ne fait actuellement pas de différence dans PostgreSQL™ et est obsolète ; voir section intitulée « Compatibilité »).

UNLOGGED

Si spécifié, la table est créée en tant que table non tracée. Les données écrites dans ce type de table ne sont pas écrites dans les journaux de transactions (voir Chapitre 29, Fiabilité et journaux de transaction), ce qui les rend considérablement plus rapides que les tables ordinaires. Néanmoins, elles ne sont pas sûres en cas d'arrêt brutal : une table non tracée est automatiquement vidée après un arrêt brutal. Le contenu d'une table non tracée n'est pas répliqué vers les serveurs en attente. Tout index créé sur une table non tracée est aussi automatiquement non tracé.

IF NOT EXISTS

N'affiche pas d'erreur si une relation de même nom existe déjà. Un message de niveau notice est retourné dans ce cas. Notez qu'il n'existe aucune garantie que la relation existante ressemble à celle qui devait être créée..

nom_table

Le nom (éventuellement qualifié du nom du schéma) de la table à créer.

OF nom_type

Crée une table typée, qui prend sa structure à partir du type composite spécifié (son nom peut être qualifié du schéma). Une table typée est liée à son type ; par exemple, la table sera supprimée si le type est supprimé (avec DROP TYPE ... CASCADE).

Quand une table typée est créée, les types de données des colonnes sont déterminés par le type composite sous-jacent et ne sont pas indiqués par la commande CREATE TABLE. Mais la commande CREATE TABLE peut ajouter des valeurs par défaut et des contraintes à la table. Elle peut aussi indiquer des paramètres de stockage.

nom_colonne

Le nom d'une colonne de la nouvelle table.

type_données

Le type de données de la colonne. Cela peut inclure des spécificateurs de tableaux. Pour plus d'informations sur les types de données supportés par PostgreSQL™, on se référera à Chapitre 8, Types de données.

COLLATE collation

La clause COLLATE affecte un collationnement à une colonne (qui doit être d'un type de données collationnable). Sans information, le collationnement par défaut du type de données de la colonne est utilisé.

INHERITS ( table_parent [, ... ])

La clause optionnelle INHERITS indique une liste de tables dont les colonnes sont automatiquement héritées par la nouvelle table. Les tables parents peuvent être des tables standards ou des tables distantes.

L'utilisation d'INHERITS crée une relation persistante entre la nouvelle table enfant et sa table parent. Les modifications de schéma du(des) parent(s) se propagent normalement aux enfants et, par défaut, les données de la table enfant sont incluses dans les parcours de(s) parent(s).

Si un même nom de colonne existe dans plusieurs tables parentes, une erreur est rapportée, à moins que les types de données des colonnes ne correspondent dans toutes les tables parentes. S'il n'y a pas de conflit, alors les colonnes dupliquées sont assemblées pour former une seule colonne dans la nouvelle table. Si la liste des noms de colonnes de la nouvelle table contient un nom de colonne hérité, le type de données doit correspondre à celui des colonnes héritées et les définitions des colonnes sont fusionnées. Si la nouvelle table spécifie explicitement une valeur par défaut pour la colonne, cette valeur surcharge toute valeur par défaut héritée. Dans le cas contraire, les parents qui spécifient une valeur par défaut doivent tous spécifier la même, sans quoi une erreur est rapportée.

Les contraintes CHECK sont fusionnées, dans les grandes lignes, de la même façon que les colonnes : si des tables parentes multiples et/ou la nouvelle définition de table contient des contraintes CHECK de même nom, ces contraintes doivent toutes avoir la même expression de vérification, ou une erreur sera retournée. Les contraintes qui ont le même nom et la même expression seront fusionnées en une seule. Une contrainte marquée NO INHERIT dans une table parent ne sera pas prise en compte. Notez qu'une contrainte CHECK non nommée dans la nouvelle table ne sera jamais fusionnée puisqu'un nom unique lui sera toujours affecté.

Les paramètres STORAGE de la colonne sont aussi copiés des tables parents.

Si une colonne de la table parente est une colonne d'identité, cette propriété n'est pas héritée. Une colone dans la table enfant peut être déclarée comme colonne d'identité si l'on veut.

PARTITION BY { RANGE | LIST | HASH } ( { column_name | ( expression ) } [ opclass ] [, ...] )

La clause facultative PARTITION BY spécifie une statégie pour partitionner la table. La table ainsi crée est appelée table partitionnée. La liste de colonnes ou d'expressions entre parenthèses forme la clé de partitionnement de la table. Quand un partitionnement par intervalle ou hachage est utilisé, la clé de partitionnement peut inclure de multiples colonnes ou expressions (jusqu'à 32, mais cette limite peut être modifiée lors de la compilation de PostgreSQL™.), mais pour le partitionnement par liste, la clé de partitionnement doit être constituée d'une seule colonne ou expression.

Les partitionnements par intervalle ou par liste nécessitent une classe d'opérateur btree, alors que le partitionnement par hachage exige une classe d'opérateur hash. Si aucune classe d'opérateur n'est précisée explicitement, la classe d'opérateur par défaut du type approprié sera utilisée ; si aucune classe d'opérateur n'existe, une erreur sera levée. Si le partitionnement par hachage est utilisé, la classe d'opérateur utilisée doit implémenter la fonction de support 2 (voir Section 37.16.3, « Routines d'appui des méthodes d'indexation » pour les détails).

Une table partitionnée est divisée en sous tables (appelées partitions), qui sont créées en utilisant des commandes CREATE TABLE séparées. La table partitionnée est elle-même vide. Une ligne de données insérée dans la table est redirigée vers une partition en fonction de la valeur des colonnes ou expressions de la clé de partitionnement. S'il n'existe pas de partition correspondant aux valeurs de la nouvelle ligne, une erreur sera levée.

Les tables partitionnées ne supportent pas les contraintes EXCLUDE ; cependant vous pouvez définir ces contraintes sur des partitions individuelles.

Voir Section 5.11, « Partitionnement de tables » pour plus de détails sur le partitionnement des tables.

PARTITION OF table_parent { FOR VALUES spec_limites_partition | DEFAULT }

Crée la table comme une partition de la table parente spécifiée. La table peut être créée, soit comme une partition pour des valeurs spécifiques avec FOR VALUES, soit comme la partition par défaut avec DEFAULT. Cette option n'est pas disponible pour les tables partitionnées par hachage.

Le paramètre spec_limites_partition doit correspondre à la méthode et à la clé de partitionnement de la table parent, et ne doit pas déborder sur toute partition existante du parent. La forme avec IN est utilisée pour le partitionnement de liste, la forme avec FROM et TO est utilisée pour le partitionnement par intervalles, et la forme avec WITH est utilisée pour le partitionnement par hachage.

expr_limite_partition peut être n'importe quelle expression sans variable (les sous-requêtes, fonctions de fenêtrage, fonctions d'aggrégation ou toute fonction renvoyant une relation ne sont pas autorisées). Son type de donnée doit être le même que celui de la clé de partitionnement. L'expression étant évaluée une seule fois, au moment de la création de la table, il est possible d'utiliser des expressions volatiles comme CURRENT_TIMESTAMP .

Lors de la création d'une partition en liste, NULL peut être indiquer pour signifier que la partition permet à la colonne de clé de partitionnement d'être NULL. Néanmoins, il ne peut y avoir plus d'une partition de ce type pour une table parent donnée. NULL n'est pas accepté pour les partitions par intervalle.

Lorsqu'une partition de type intervalle est créée, la borne inférieure spécifiée avec FROM est une borne inclusive, alors que la borne supérieure spécifiée avec TO est une borne exclusive. C'est-à-dire que les valeurs spécifiées dans la liste FROM sont des valeurs valides des colonnes correspondantes de la clé de partitionnement pour cette partition, alors que celles dans la liste TO ne le sont pas. Notez que ceci doit être compris suivant les règles de la comparaison de lignes (Section 9.23.5, « Comparaison de constructeur de lignes »). Par exemple, étant donné PARTITION BY RANGE (x,y), une limite de partition FROM (1, 2) TO (3, 4) permet x=1 pour tout y>=2, x=2 avec tout y non NULL, et x=3 avec tout y<4.

Les valeurs spéciales MINVALUE et MAXVALUE peuvent être utilisées lors de la création d'une partition par intervalles pour indiquer qu'il n'y a pas de limite basse ou haute sur la valeur de la colonne. Par exemple, une partition définie comme utilisant FROM (MINVALUE) TO (10) accepte toutes les valeurs inférieures à 10, et une partition définie en utilisant FROM (10) TO (MAXVALUE) accepte toutes les valeurs supérieures ou égales à 10.

Lors de la création d'une partition par intervalles impliquant plus d'une colonne, il est aussi sensé d'utiliser MAXVALUE comme élément de la limite basse et MINVALUE comme élément de limite haute. Par exemple, une partition définie en utilisant FROM (0, MAXVALUE) TO (10, MAXVALUE) accepte toute ligne où la première colonne de la clé de partitionnement est supérieure à zéro et inférieure ou égale à dix. De la même façon, une partition définie en utilisant FROM ('a', MINVALUE) TO ('b', MINVALUE) accepte toute ligne où la première colonne de la clé de partitionnement commence avec la lettre a.

Notez que si MINVALUE ou MAXVALUE est utilisé pour une colonne d'une limite de partitionnement, la même valeur doit être utilisée pour toutes les colonnes suivantes. Par exemple, (10, MINVALUE, 0) n'est pas une limite valide. Vous devriez écrire (10, MINVALUE, MINVALUE).

De plus, notez que certains types d'éléments, tels que timestamp, ont une notion d'infinité, qui est simplement une autre valeur qui peut être enregistré. Ceci est différent de MINVALUE et MAXVALUE, qui ne sont pas de vraies valeurs pouvant être enregistrées, mais plutôt une façon de dire que la valeur est sans limite. MAXVALUE peut être vu comme étant supérieur à toute autre valeur, ceci includant infinity et MINVALUE comme étant inférieure à toute autre valeur, ceci incluant moins infinity. De ce fait, l'intervalle FROM ('infinity') TO (MAXVALUE) n'est pas un intervalle vide. Il autorise le stockage d'une seule valeur -- "infinity".

Quand une partition par liste de valeurs est créée, NULL peut être spécifié pour dire que la partition autorise la colonne de la clé de partitionnement à être NULL. Cepdnant, il ne peut pas y avoir plus d'une partition par liste de ce type pour une même table parente. NULL ne peut pas être utilisé pour les partitions par intervalles.

Si DEFAULT est spécifié, la table sera créée comme partition par défaut de la table parente. Celle-ci peut être une table partitionnée par liste ou par intervalles. Une clé de partition qui ne passe dans aucune autre partition de la table parente sera orientée vers la partition par défaut. Il ne peut y avoir qu'une partition par défaut pour une table parente donnée.

Si une table possède une partition DEFAULT et qu'on lui ajoute une nouvelle partition, la partition par défaut existante doit être parcourue pour vérifier qu'elle ne contient aucune ligne qui appartient normalement à la nouvelle partition. Si la partition par défaut contient un grand nombre de lignes, cela peut être long. Ce parcours peut être évité si la partition par défaut est une table étrangère ou possède une contrainte prouvant qu'elle ne peut contenir des lignes qui devraient appartenir à la nouvelle partition.

À la création d'une partition par hachage, un diviseur et un reste doivent être spécifiés. Le diviseur doit être un entier positif, et le reste un entier non négatif inférieur au diviseur. Typiquement, au début de la mise en place d'un partitionnement par hachage, vous devrez choisir un diviseur égal au nombre de partitions et assigner à chaque table le même diviseur et un reste différent (voir les exemples plus bas). Cependant, il n'est pas obligatoire que chaque partition ait le même diviseur, juste que chaque diviseur apparaissant dans une table partitionnée par hachage soit un facteur du diviseur immédiatement supérieur. Cela permet d'augmenter le nombre de partitions de manière incrémentale sans avoir besoin de déplacer toutes les données d'un coup. Par exemple, supposons que vous ayez une table partitionnée par hachage avec 8 partitions, toutes de diviseur 8, mais que vous trouvez qu'il faille augmenter le nombre de partitions à 16. Vous pouvez détacher une des partitions de diviseur 8, créer deux nouvelles partitions de diviseur 16 couvrant la même partie de l'espace des clés (une avec un reste égal au reste de la partition détachée, l'autre avec un reste de cette valeur plus 8), et les peupler avec les données. Vous pouvez répéter ceci -- peut-être plus tard -- pour chaque partition de diviseur 8 jusqu'à ce qu'il n'y en ait plus. Bien que cela implique de grands mouvements de données à chaque étape, c'est toujours mieux qu'avoir à créer toute une nouvelle table et d'avoir à déplacer toutes les données en une seule fois.

Une partition doit avoir les mêmes noms de colonne et types de données que la table partitionnée à laquelle elle appartient. Toute modification du type ou du nom d'une colonne d'une table partitionnée sera automatiquement propagée à toutes les partitions. Les contraintes de type CHECK seront automatiquement héritées pour chaque partition, mais il est possible de définir des contraintes de type CHECK supplémentaires sur certaines partitions. Si une contrainte sur une partition porte le même nom qu'une contrainte ajoutée sur la table mère, elle sera fusionnée avec la contrainte de la table parent. Il est possible de définir des valeurs par défaut différentes pour chaque partition.

Les lignes insérées dans une table partitionnées seront automatiquement redirigées vers la bonne partition. Si aucune des partitions existantes ne convient, une erreur sera levée.

Les opérations telles que TRUNCATE qui n'affectent normalement une table ainsi que tous ses enfants hérités seront cascadées sur toutes les partitions, mais peuvent aussi être effectuées sur une partition individuelle. Veuillez noter que supprimer une partition avec DROP TABLE nécessite de prendre un verrou de type ACCESS EXCLUSIVE sur la table parente.

LIKE table_source [ option_like ... ]

La clause LIKE spécifie une table à partir de laquelle la nouvelle table copie automatiquement tous les noms de colonnes, leur types de données et les contraintes non NULL.

Contrairement à INHERITS, la nouvelle table et la table originale sont complètement découplées à la fin de la création. Les modifications sur la table originale ne sont pas appliquées à la nouvelle table et les données de la nouvelle table sont pas prises en compte lors du parcours de l'ancienne table.

De plus, contrairement à INHERITS, les colonnes et les contraintes copiées par LIKE ne sont pas assemblées avec des colonnes et des contraintes nommées de façon similaire. Si le même nom est indiqué explicitement ou dans une autre clause LIKE, une erreur est rapportée.

La clause facultative like_option permet de spécifier quelle propriété supplémentaire de la table originale doit être copiée. Spécifier INCLUDING copie la propriété, spécifier EXCLUDING ne copie pas la propriété. EXCLUDING est la valeur par défaut. Si plusieurs clauses INCLUDING et EXCLUDING sont indiquées pour le même type d'objet, la dernière clause est utilisée. Les options disponibles sont :

INCLUDING COMMENTS

Les commentaires sur les colonnes, contraintes et index seront copiés. Le comportement par défaut exclue les commentaires, ce qui fait que les colonnes, les contraintes et les index de la nouvelle table n'ont pas de commentaire.

INCLUDING CONSTRAINTS

Les contraintes de type CHECK seront copiées. Aucune distinction ne sera faite entre les contraintes de colonnes et les contraintes de table. Tout contrainte de non nullité est systématiquement recopiée sur la nouvelle table.

INCLUDING DEFAULTS

Les valeurs par défaut sur les colonnes seront recopiées dans la nouvelle table. Si cette clause n'est pas ajoutée, les valeurs par défaut ne sont pas recopiées, ce qui fait que les colonnes de la nouvelle table n'ont pas de valeur par défaut. Il est important de noter que copier une valeur par défaut qui fait appel à une fonction qui peut modifier la base de données, comme la fonction nextval, peut créer un lien entre la table originale et les nouvelles tables.

INCLUDING GENERATED

Toute définition d'une colonne générée sera copiée. Par défaut, les nouvelles colonnes copiées à partir de colonnes générées sont de simples colonnes normales.

INCLUDING IDENTITY

Toute spécification d'une colonne d'identité sera copiée. Une nouvelle séquence est créée pour chaque colonne d'identité de la nouvelle table, séparément des séquences associées à la table d'origine.

INCLUDING INDEXES

Les index, les contraintes de type PRIMARY KEY, UNIQUE et EXCLUDE de la table d'origine seront créés sur la nouvelle table. Les noms pour les nouveaux index et les nouvelles contraintes sont choisis automatiquement suivant des règles fixes, quel que soit leur nom sur la table d'origine. (Ce comportement permet d'éviter d'essayer de créer un index portant un nom déjà utilisé.)

INCLUDING STATISTICS

Les statistiques étendues sont copiées sur la nouvelle table.

INCLUDING STORAGE

Les spécifications de STORAGE sont copiées sur la nouvelle colonne. Le comportement par défaut exclue la clause de STORAGE, ce qui fait que, par défaut, les colonnes de la nouvelle table n'ont pas de définition particulière pour le stockage. Pour plus d'informations sur la clause STORAGE, voir Section 68.2, « TOAST ».

INCLUDING ALL

INCLUDING ALL permet de sélectionner toutes les options individuelles ci-dessus d'un seul coup. (Il peut être utile d'ajouter des options individuelles EXCLUDING après une clause INCLUDING ALL pour sélectionner toutes les options sauf certaines.)

La clause LIKE peut aussi être utilisée pour copier les définitions de colonne des vues, tables distantes et types composites. Les options inapplicables (comme INCLUDING INDEXES à partir d'une vue) sont ignorées.

CONSTRAINT nom_contrainte

Le nom optionnel d'une contrainte de colonne ou de table. Si la contrainte est violée, le nom de la contrainte est présente dans les messages d'erreur. Donc les noms de contraintes comme col doit être positive peut être utilisés pour communiquer des informations utiles aux applications clients. (Des doubles guillemets sont nécessaires pour indiquer les noms des contraintes qui contiennent des espaces.) Si un nom de contrainte n'est pas donné, le système en crée un.

NOT NULL

Interdiction des valeurs NULL dans la colonne.

NULL

Les valeurs NULL sont autorisées pour la colonne. Comportement par défaut.

Cette clause n'est fournie que pour des raisons de compatibilité avec les bases de données SQL non standard. Son utilisation n'est pas encouragée dans les nouvelles applications.

CHECK ( expression ) [ NO INHERIT ]

La clause CHECK spécifie une expression de résultat booléen que les nouvelles lignes ou celles mises à jour doivent satisfaire pour qu'une opération d'insertion ou de mise à jour réussisse. Les expressions de résultat TRUE ou UNKNOWN réussissent. Si une des lignes de l'opération d'insertion ou de mise à jour produit un résultat FALSE, une exception est levée et la base de données n'est pas modifiée. Une contrainte de vérification sur une colonne ne fait référence qu'à la valeur de la colonne tandis qu'une contrainte sur la table fait référence à plusieurs colonnes.

Actuellement, les expressions CHECK ne peuvent ni contenir des sous-requêtes ni faire référence à des variables autres que les colonnes de la ligne courante (voir Section 5.4.1, « Contraintes de vérification »). La colonne système tableoid peut être référencé contrairement aux autres colonnes systèmes.

Une contrainte marquée NO INHERIT ne sera pas propagée aux tables filles.

Quand une table a plusieurs contraintes CHECK, elles seront testées pour chaque ligne dans l'ordre alphabétique de leur nom, après la vérification des contraintes NOT NULL. (Les versions de PostgreSQL™ antérieures à la 9.5 ne respectaient pas d'ordre de déclenchement particulier pour les contraintes CHECK.)

DEFAULT expression_par_défaut

La clause DEFAULT, apparaissant dans la définition d'une colonne, permet de lui affecter une valeur par défaut. La valeur est une expression libre de variable (en particulier, les références croisées aux autres colonnes de la table courante ne sont pas autorisées). Subqueries are not allowed either. Le type de données de l'expression par défaut doit correspondre au type de données de la colonne.

L'expression par défaut est utilisée dans les opérations d'insertion qui ne spécifient pas de valeur pour la colonne. S'il n'y a pas de valeur par défaut pour une colonne, elle est NULL.

GENERATED ALWAYS AS ( generation_expr ) STORED

Cette clause crée la colonne comme une colonne générée. La colonne n'est pas accessible en écriture. À la lecture de cette colonne, l'expression spécifiée calculée sera renvoyée.

Le mot-clé STORED est nécessaire pour indiquer que la colonne sera calculée lors de l'écriture et sera stockée sur le disque.

L'expression de génération peut faire référence à d'autres colonnes de la table, mais pas à une autre colonne générée. Toute fonction ou opérateur utilisé dans l'expression de génération devra être IMMUTABLE. Toute référence à d'autres tables est interdite.

GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY [ ( options_sequence ) ]

Cette clause crée la colonne comme une colonne d'identité. Elle aura une séquence implicite attachée à elle et la colonne dans les nouvelles lignes auront automatiquement des valeurs récupérées de la séquence qui lui est assignée.

Les clauses ALWAYS et BY DEFAULT déterminent comment la valeur de la séquence est prioritaire par rapport à une valeur définie par l'utilisateur dans un ordre INSERT. Si ALWAYS est spécifié, une valeur définie par l'utilisateur ne sera acceptée que si l'ordre INSERT spécifie OVERRIDING SYSTEM VALUE. Si BY DEFAULT est spécifié, alors la valeur spécifiée par l'utilisateur est prioritaire. Voir INSERT(7) pour plus de détails. (Avec une commande COPY, les valeurs spécifiées par l'utilisateur sont toujours utilisée quelque soit ce paramètre.)

La clause facultative options_sequence peut être utilisée pour surcharger les options d'une séquence. Voir CREATE SEQUENCE(7) pour plus de détails.

UNIQUE (contrainte de colonne), UNIQUE ( nom_colonne [, ... ] ) [ INCLUDE ( nom_colonne [, ...]) ] (contrainte de table)

La contrainte UNIQUE indique qu'un groupe d'une ou plusieurs colonnes d'une table ne peut contenir que des valeurs uniques. Le comportement de la contrainte de table unique est le même que celui des contraintes de colonnes avec la capacité supplémentaire de traiter plusieurs colonnes.

Pour une contrainte unique, les valeurs NULL ne sont pas considérées comme égales.

Chaque contrainte unique de table doit nommer un ensemble de colonnes qui est différent de l'ensemble de colonnes nommées par toute autre contrainte unique ou de clé primaire définie pour la table. (Sinon elle ne ferait que lister la même contrainte deux fois.)

Lors de la mise en place d'une contrainte unique sur une hiérarchie de partitions à plusieurs niveaux, toutes les colonnes de la clé de partitionnement de la table partitionnée cible, ainsi que celles des tables partitionnées filles, doivent être incluses dans la définition de la contrainte.

Ajouter une contrainte unique va automatiquement créer un index btree unique sur la colonne ou le groupe de colonnes utilisée(s) dans la contrainte. La clause optionnelle INCLUDE ajoute à cet index une ou plusieurs colonnes, qui ne sont pas concernée par l'unicité. Notez cependant que si la contrainte n'est pas appliquée sur ces colonnes incluses, elle en dépend tout de même. En conséquence, certaines opérations sur ces colonnes (par exemple DROP COLUMN) peuvent causer une suppression en cascade de la contrainte et de l'index.

PRIMARY KEY (contrainte de colonne), PRIMARY KEY ( nom_colonne [, ... ] ) [ INCLUDE ( nom_colonne [, ...]) ] (contrainte de table)

La contrainte PRIMARY KEY indique qu'une ou plusieurs colonnes d'une table peuvent uniquement contenir des valeurs uniques (pas de valeurs dupliquées) et non NULL. Une table ne peut avoir qu'une seule clé primaire, que ce soit une contrainte au niveau de la colonne ou au niveau de la table.

La contrainte clé primaire doit nommer un ensemble de colonnes différent de l'ensemble de colonnes nommé par toute contrainte unique définie sur la même table. (Sinon, la contrainte unique est redondante et sera ignorée.)

PRIMARY KEY force les mêmes contraintes sur les données que la combinaison UNIQUE et NOT NULL mais identifier un ensemble de colonnes comme une clé primaire fournit aussi des métadonnées sur la conception du schéma car une clé primaire implique que les autres tables peuvent s'appuyer sur cet ensemble de colonnes comme un identifiant unique des lignes de la table.

Les contraintes PRIMARY KEY partagent les restrictions des contraintes UNIQUE placées sur des tables partitionnées. tables.

Ajouter une contrainte PRIMARY KEY va automatiquement créer un index btree unique sur la colonne ou le groupe de colonnes utilisée(s) dans la contrainte. La clause optionnelle INCLUDE permet de spécifier une liste de colonnes qui seront incluses dans l'index, hors des clés. Bien que l'unicité ne soit pas appliquée sur ces colonnes, la contrainte en dépend. En conséquence, certaines opérations sur les colonnes incluses (par exemple DROP COLUMN) peuvent causer par cascade la suppression de contraintes et d'index.

EXCLUDE [ USING méthode_index ] ( élément_exclusion WITH opérateur [, ... ] ) paramètres_index [ WHERE ( prédicat ) ]

La clause EXCLUDE définit une contrainte d'exclusion qui garantit que si deux lignes sont comparées sur la ou les colonnes spécifiées ou des expressions utilisant le ou les opérateurs spécifiés, seulement certaines de ces comparaisons, mais pas toutes, renverront TRUE. Si tous les opérateurs spécifiés testent une égalité, ceci est équivalent à une contrainte UNIQUE bien qu'une contrainte unique ordinaire sera plus rapide. Néanmoins, ces contraintes d'exclusion peuvent spécifier des contraintes qui sont plus générales qu'une simple égalité. Par exemple, vous pouvez spécifier qu'il n'y a pas deux lignes dans la table contenant des cercles de surcharge (voir Section 8.8, « Types géométriques ») en utilisant l'opérateur &&.

Des contraintes d'exclusion sont implantées en utilisant un index, donc chaque opérateur précisé doit être associé avec une classe d'opérateurs appropriée (voir Section 11.10, « Classes et familles d'opérateurs ») pour la méthode d'accès par index, nommée méthode_index. Les opérateurs doivent être commutatifs. Chaque élément_exclusion peut spécifier en option une classe d'opérateur et/ou des options de tri ; ils sont décrits complètement sous CREATE INDEX(7).

La méthode d'accès doit supporter amgettuple (voir Chapitre 61, Définition de l'interface des méthodes d'accès aux index) ; dès à présent, cela signifie que GIN ne peut pas être utilisé. Bien que cela soit autorisé, il existe peu de raison pour utiliser des index B-tree ou hash avec une contrainte d'exclusion parce que cela ne fait rien de mieux que ce que peut faire une contrainte unique ordinaire. Donc, en pratique, la méthode d'accès sera toujours GiST ou SP-GiST.

Le prédicat vous permet de spécifier une contrainte d'exclusion sur un sous-ensemble de la table ; en interne, un index partiel est créé. Notez que ces parenthèses sont requis autour du prédicat.

REFERENCES table_reference [ ( colonne_reference ) ] [ MATCH type_correspondance ] [ ON DELETE action_referentielle ] [ ON UPDATE action_referentielle ] (contrainte de colonne), FOREIGN KEY ( nom_colonne [, ... ] ) REFERENCES table_reference [ ( colonne_reference [, ... ] ) ] [ MATCH matchtype ] [ ON DELETE action ] [ ON UPDATE action ] (contrainte de colonne)

Ces clauses spécifient une contrainte de clé étrangère. Cela signifie qu'un groupe de colonnes de la nouvelle table ne peut contenir que des valeurs correspondant à celles des colonnes de référence de la table de référence. Si la liste colonne_reference est omise, la clé primaire de la table_reference est utilisée. Les colonnes référencées doivent être celles d'une contrainte d'unicité ou de clé primaire, non déferrable, dans la table référencée. L'utilisateur doit avoir la permission REFERENCES sur la table référencée (soit toute la table, ou la colonne référencée spécifiquement). L'ajout d'une contrainte de type clé étrangère requiert un verrou SHARE ROW EXCLUSIVE sur la table référencée. Les contraintes de type clé étrangère ne peuvent pas être définies entre des tables temporaires et des tables permanentes.

Une valeur insérée dans les colonnes de la nouvelle table est comparée aux valeurs des colonnes de référence dans la table de référence à l'aide du type de concordance fourni. Il existe trois types de correspondance : MATCH FULL (NDT : correspondance totale), MATCH PARTIAL (NDT : correspondance partielle) et MATCH SIMPLE (NDT : correspondance simple), qui est aussi la valeur par défaut. MATCH FULL n'autorise une colonne d'une clé étrangère composite à être NULL que si l'ensemble des colonnes de la clé étrangère sont NULL. Si elles sont NULL, la ligne n'a pas besoin d'avoir une correspondance dans la table référencée. MATCH SIMPLE permet à n'importe quel colonne d'une clé étrangère d'être NULL ; si l'une d'entre elles est NULL, la ligne n'a pas besoin d'avoir une correspondance dans la table référencée. MATCH PARTIAL n'est pas encore implémentée. Bien sûr, les contraintes NOT NULL peuvent être appliquées sur la (ou les) colonne(s) référençantes pour empêcher ces cas de survenir.

Lorsque les données des colonnes référencées sont modifiées, des actions sont réalisées sur les données de la table référençant. La clause ON DELETE spécifie l'action à réaliser lorsqu'une ligne référencée de la table de référence est supprimée. De la même façon, la clause ON UPDATE spécifie l'action à réaliser lorsqu'une colonne référencée est mise à jour. Si la ligne est mise à jour sans que la valeur de la colonne référencée ne soit modifiée, aucune action n'est réalisée. Les actions référentielles autres que la vérification NO ACTION ne peuvent pas être différées même si la contrainte est déclarée retardable. Les actions suivantes sont possibles pour chaque clause :

NO ACTION

Une erreur est produite pour indiquer que la suppression ou la mise à jour entraîne une violation de la contrainte de clé étrangère. Si la contrainte est différée, cette erreur est produite au moment de la vérification, si toutefois il existe encore des lignes de référence. C'est le comportement par défaut.

RESTRICT

Une erreur est produite pour indiquer que la suppression ou la mise à jour entraîne une violation de la contrainte de clé étrangère. Ce comportement est identique à NO ACTION, si ce n'est que la vérification n'est pas décalable dans le temps.

CASCADE

La mise à jour ou la suppression de la ligne de référence est propagée à l'ensemble des lignes qui la référencent, qui sont, respectivement, mises à jour ou supprimées.

SET NULL

La valeur de la colonne qui référence est positionnée à NULL.

SET DEFAULT

(Il doit existe une ligne dans la table référencée correspondant aux valeurs par défaut, si elles ne sont pas NULL. Dans le cas contraire, l'opération échouera.)

Si les colonnes référencées sont modifiées fréquemment, il est conseillé d'ajouter un index sur les colonnes référençantes pour que les actions associées à la contrainte de clé étrangère soient plus performantes.

DEFERRABLE, NOT DEFERRABLE

Ces clauses contrôlent la possibilité de différer la contrainte. Une contrainte qui n'est pas décalable dans le temps est vérifiée immédiatement après chaque commande. La vérification des contraintes décalables est repoussée à la fin de la transaction (à l'aide de la commande SET CONSTRAINTS(7)). NOT DEFERRABLE est la valeur par défaut. Actuellement, seules les contraintes UNIQUE, PRIMARY KEY, EXCLUDE et REFERENCES (clé étrangère) acceptent cette clause. Les contraintes NOT NULL et CHECK ne sont pas diferrables. Notez que les contraintes différables ne peuvent pas être utilisées comme arbitres d'un conflit dans une commande INSERT qui inclut une clause ON CONFLICT DO UPDATE.

INITIALLY IMMEDIATE, INITIALLY DEFERRED

Si une contrainte est décalable dans le temps, cette clause précise le moment de la vérification. Si la contrainte est INITIALLY IMMEDIATE, elle est vérifiée après chaque instruction. Si la contrainte est INITIALLY DEFERRED, elle n'est vérifiée qu'à la fin de la transaction. Le moment de vérification de la contrainte peut être modifié avec la commande SET CONSTRAINTS(7).

USING method

Cette clause facultative permet de spécifier la méthode d'accès utilisée pour stocker le contenu de la nouvelle table. La méthode doit être une méthode d'accès de type TABLE. Voir Chapitre 60, Table Access Method Interface Definition pour plus d'informations. Si cette option n'est pas indiquée, la méthode d'accès par défaut est choisie pour la nouvelle table. Voir default_table_access_method pour plus d'informations.

WITH ( paramètre_stockage [= valeur] [, ... ] )

Cette clause spécifie les paramètres de stockage optionnels pour une table ou un index ; voir section intitulée « Paramètres de stockage » pour plus d'informations. Pour la rétro-compatibilité de la clause WITH d'une table, il est possible de spécifier OIDS=FALSE pour indiquer que les lignes de la nouvelle table ne doivent pas contenir d'OID (identifiants d'objets). OIDS=TRUE n'est plus supporté.

WITHOUT OIDS

Il s'agit de la syntaxe rétro-compatible pour déclarer une table sans utiliser d'OID (identifiants d'objets), il n'est plus possible de créer une table avec l'option WITH OIDS.

ON COMMIT

Le comportement des tables temporaires à la fin d'un bloc de transactions est contrôlé à l'aide de la clause ON COMMIT. Les trois options sont :

PRESERVE ROWS

Aucune action n'est entreprise à la fin des transactions. Comportement par défaut.

DELETE ROWS

Toutes les lignes de la table temporaire sont détruites à la fin de chaque bloc de transactions. En fait, un TRUNCATE(7) automatique est réalisé à chaque validation. Lorsque cette clause est utilisée sur une table partitionnée, elle n'est pas exécutée en cascade sur ses partitions.

DROP

La table temporaire est supprimée à la fin du bloc de transaction. Lorsque cette clause est utilisée sur une table partitionnée, cette action supprime les partitions et. Quand elle est utilisée sur une table ayant des tables filles, ces dernières sont aussi supprimées.

TABLESPACE nom_tablespace

nom_tablespace est le nom du tablespace dans lequel est créée la nouvelle table. S'il n'est pas spécifié, default_tablespace est consulté, sauf si la table est temporaire auquel cas temp_tablespaces est utilisé. Pour les tables partitionnées, comme la clause de stockage n'a pas de sens pour la table en elle-même, le tablespace indiqué écrase le default_tablespace comme tablespace par défaut à utiliser pour toute nouvelle partition à moins qu'un autre tablespace soit explicitement indiqué.

USING INDEX TABLESPACE nom_tablespace

Les index associés à une contrainte UNIQUE, PRIMARY KEY, ou EXCLUDE sont créés dans le tablespace nommé nom_tablespace. S'il n'est pas précisé, default_tablespace est consulté, sauf si la table est temporaire auquel cas temp_tablespaces est utilisé.

Paramètres de stockage

La clause WITH spécifie des paramètres de stockage pour les tables ainsi que pour les index associés avec une contrainte UNIQUE, PRIMARY KEY, ou EXCLUDE. Les paramètres de stockage des index sont documentés dans CREATE INDEX(7). Les paramètres de stockage actuellement disponibles pour les tables sont listés ci-dessous. Pour beaucoup de ces paramètres, comme indiqué, il y a un paramètre additionnel, de même nom mais préfixé par toast., qui contrôle le le comportement de la table TOAST (stockage supplémentaire), si elle existe (voir Section 68.2, « TOAST » pour plus d'informations sur TOAST). Si une valeur de paramètre d'une table est configuré et que le paramètre équivalent toast. ne l'est pas, la partie TOAST utilisera la valeur du paramètre de la table. Spécifier ces paramètres pour les tables partitionnées n'est pas supporté, mais vous pouvez les spécifier pour chaque partition n'ayant pas de sous partition.

fillfactor (integer)

Le facteur de remplissage d'une table est un pourcentage entre 10 et 100. 100 (paquet complet) est la valeur par défaut. Quand un facteur de remplissage plus petit est indiqué, les opérations INSERT remplissent les pages de table d'au maximum ce pourcentage ; l'espace restant sur chaque page est réservé à la mise à jour des lignes sur cette page. Cela donne à UPDATE une chance de placer la copie d'une ligne mise à jour sur la même page que l'original, ce qui est plus efficace que de la placer sur une page différente. Pour une table dont les entrées ne sont jamais mises à jour, la valeur par défaut est le meilleur choix, mais pour des tables mises à jour fréquemment, des facteurs de remplissage plus petits sont mieux appropriés. Ce paramètre n'est pas disponible pour la table TOAST.

toast_tuple_target (integer)

toast_tuple_target spécifie la taille de tuple minimale requise avant de tenter de déplacer les champs de grande taille vers des tables TOAST, et est aussi la taille cible à laquelle l'on tente de réduire la taille une fois cette opération démarrée. Cela n'affecte que les colonnes marquées External ou Extended et ne s'applique qu'aux nouveaux enregistrements -- cela n'a pas d'effet sur les lignes existantes. Par défaut ce paramètre est configuré pour permettre au moins 4 lignes par bloc, ce qui donnera 2040 octets avec la taille de bloc par défaut. Les valeurs valides sont entre 128 octets et (taille des blocs - entête), par défaut 8160 octets. Changer cette valeur n'est pas très utile pour les lignes très courtes ou très longues. Notez que la valeur par défaut est souvent proche de la valeur optimale, et qu'il est possible que modifier ce paramètre ait des effets négatifs dans certains cas. Ce paramètre ne peut être positionné pour les tables TOAST.

parallel_workers (integer)

Ce paramètre configure le nombre de processus pouvant être utilisés pour aider lors d'un parcours parallélisé de cette table. Si ce paramètre n'est pas configuré, le système déterminera une valeur en se basant sur la taille de la relation. Le nombre réel de processus choisis par le planificateur ou par des instructions utilitaires qui utilisent des parcours séquentiels pourrait être moindre, par exemple suite à la configuration de max_worker_processes.

autovacuum_enabled, toast.autovacuum_enabled (boolean)

Active ou désactive le démon autovacuum pour une table particulière. Si elle vaut true, le démon autovacuum réalise des VACUUM et/ou ANALYZE automatiques sur cette table en suivant les règles discutées dans Section 24.1.6, « Le démon auto-vacuum ». À false, cette table ne sera pas traitée par le démon autovacuum, sauf s'il y a un risque de réutilisation des identifiants de transaction. Voir Section 24.1.5, « Éviter les cycles des identifiants de transactions » pour plus d'informations sur la prévention de ce problème. Notez que le démon autovacuum n'est pas lancé (sauf pour prévenir la réutilisation des identifiants de transaction) si le paramètre autovacuum vaut false ; configurer les paramètres de stockage d'une table ne surcharge pas cela. De ce fait, il y a peu d'intérêt de configurer ce paramètre à true.

vacuum_index_cleanup, toast.vacuum_index_cleanup (boolean)

Permet d'activer ou de désactiver le nettoyage des index quand un VACUUM est lancé sur cette table. La valeur par défaut est true. Désactiver le nettoyage des index peut accélérer considérablement la commande VACUUM, mais cela peut aussi entraîner une fragmentation importante des index si les modifications de la table sont fréquentes. Le paramètre INDEX_CLEANUP de VACUUM(7), s'il est indiqué, écrase cette valeur.

vacuum_truncate, toast.vacuum_truncate (boolean)

Active ou désactive la suppression par le vacuum des pages vides en fin de table. La valeur par défaut est true. Si true, la commande VACUUM et l'autovacuum supprimen ces pages et l'espace libéré est redonné au système d'exploitation. La suppression de ces pages vides nécessite un verrou de type ACCESS EXCLUSIVE sur la table. Le paramètre TRUNCATE de la commande VACUUM(7), si indiqué, écrase cette valeur.

autovacuum_vacuum_threshold, toast.autovacuum_vacuum_threshold (integer)

Valeur spécifique à la table pour le paramètre autovacuum_vacuum_threshold.

autovacuum_vacuum_scale_factor, toast.autovacuum_vacuum_scale_factor (float4)

Valeur spécifique à la table pour le paramètre autovacuum_vacuum_scale_factor.

autovacuum_analyze_threshold (integer)

Valeur spécifique à la table pour le paramètre autovacuum_analyze_threshold.

autovacuum_analyze_scale_factor (float4)

Valeur spécifique à la table pour le paramètre autovacuum_analyze_scale_factor.

autovacuum_vacuum_cost_delay, toast.autovacuum_vacuum_cost_delay (floating point)

Valeur spécifique à la table pour le paramètre autovacuum_vacuum_cost_delay.

autovacuum_vacuum_cost_limit, toast.autovacuum_vacuum_cost_limit (integer)

Valeur spécifique à la table pour le paramètre autovacuum_vacuum_cost_limit.

autovacuum_freeze_min_age, toast.autovacuum_freeze_min_age (integer)

Valeur spécifique à la table pour le paramètre vacuum_freeze_min_age. Notez que l'autovacuum ignorera les paramètres autovacuum_freeze_min_age spécifiques à la table qui sont plus importants que la moitié du paramètre autovacuum_freeze_max_age.

autovacuum_freeze_max_age, toast.autovacuum_freeze_max_age (integer)

Valeur spécifique à la table pour le paramètre autovacuum_freeze_max_age. Notez que l'autovacuum ignorera les paramètres autovacuum_freeze_max_age spécifiques à la table qui sont plus importants que la configuration globale (elle ne peut être que plus petite).

autovacuum_freeze_table_age, toast.autovacuum_freeze_table_age (integer)

Valeur spécifique à la table pour le paramètre vacuum_freeze_table_age.

autovacuum_multixact_freeze_min_age, toast.autovacuum_multixact_freeze_min_age (integer)

Valeur spécifique à la table pour le paramètre vacuum_multixact_freeze_min_age. Notez que l'autovacuum ignorera les paramètres autovacuum_multixact_freeze_min_age spécifiques à la table si leur configuration est supérieure à la moitié de la valeur du paramètre global autovacuum_multixact_freeze_max_age.

autovacuum_multixact_freeze_max_age, toast.autovacuum_multixact_freeze_max_age (integer)

Valeur spécifique à la table pour le paramètre autovacuum_multixact_freeze_max_age. Notez que l'autovacuum ignorera les paramètres autovacuum_multixact_freeze_max_age spécifiques à la table si leur configuration est supérieure à la valeur du paramètre global (elle peut seulement être inférieure).

autovacuum_multixact_freeze_table_age, toast.autovacuum_multixact_freeze_table_age (integer)

Valeur spécifique à la table pour le paramètre vacuum_multixact_freeze_table_age.

log_autovacuum_min_duration, toast.log_autovacuum_min_duration (integer)

Valeur spécifique à la table pour le paramètre log_autovacuum_min_duration.

user_catalog_table (boolean)

Déclare la table comme une autre table du catalogue dans le cadre de la réplication logique. Voir Section 48.6.2, « Capacités » pour les détails. Ce paramètre ne peut pas être configuré pour les tables TOAST.

Notes

PostgreSQL™ crée automatiquement un index pour chaque contrainte d'unicité ou clé primaire afin d'assurer l'unicité. Il n'est donc pas nécessaire de créer un index spécifiqueme pour les colonnes de clés primaires. Voir CREATE INDEX(7) pour plus d'informations.

Les contraintes d'unicité et les clés primaires ne sont pas héritées dans l'implantation actuelle. Cela diminue la fonctionnalité des combinaisons d'héritage et de contraintes d'unicité.

Une table ne peut pas avoir plus de 1600 colonnes (en pratique, la limite réelle est habituellement plus basse du fait de contraintes sur la longueur des lignes).

Exemples

Créer une table films et une table distributeurs :

CREATE TABLE films (
    code        char(5) CONSTRAINT premierecle PRIMARY KEY,
    titre       varchar(40) NOT NULL,
    did         integer NOT NULL,
    date_prod   date,
    genre       varchar(10),
    duree       interval hour to minute
);

CREATE TABLE distributeurs (
     did    integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
     nom    varchar(40) NOT NULL CHECK (nom <> '')
);
   

Créer une table contenant un tableau à deux dimensions :

CREATE TABLE array_int (
    vecteur  int[][]
);
   

Définir une contrainte d'unicité pour la table films. Les contraintes d'unicité de table peuvent être définies sur une ou plusieurs colonnes de la table :

CREATE TABLE films (
    code        char(5),
    titre       varchar(40),
    did         integer,
    date_prod   date,
    genre       varchar(10),
    duree       interval hour to minute,
    CONSTRAINT production UNIQUE(date_prod)
);
   

Définir une contrainte de vérification sur une colonne :

CREATE TABLE distributeurs (
    did     integer CHECK (did > 100),
    nom    varchar(40)
);
   

Définir une contrainte de vérification sur la table :

CREATE TABLE distributeurs (
    did     integer,
    nom     varchar(40),
    CONSTRAINT con1 CHECK (did > 100 AND nom <> '')
);
   

Définir une contrainte de clé primaire sur la table films.

CREATE TABLE films (
    code        char(5),
    titre       varchar(40),
    did         integer,
    date_prod   date,
    genre       varchar(10),
    duree       interval hour to minute,
    CONSTRAINT code_titre PRIMARY KEY(code,titre)
);
   

Définir une contrainte de clé primaire pour la table distributeurs. Les deux exemples suivants sont équivalents, le premier utilise la syntaxe de contrainte de table, le second la syntaxe de contrainte de colonne :

CREATE TABLE distributeurs (
    did     integer,
    nom     varchar(40),
    PRIMARY KEY(did)
);

CREATE TABLE distributeurs (
    did     integer PRIMARY KEY,
    nom     varchar(40)
);
   

Affecter une valeur par défaut à la colonne nom, une valeur par défaut à la colonne did, engendrée à l'aide d'une séquence, et une valeur par défaut à la colonne modtime, équivalente au moment où la ligne est insérée :

CREATE TABLE distributeurs (
    name      varchar(40) DEFAULT 'Luso Films',
    did       integer DEFAULT nextval('distributeurs_serial'),
    modtime   timestamp DEFAULT current_timestamp
);
   

Définir deux contraintes de colonnes NOT NULL sur la table distributeurs, dont l'une est explicitement nommée :

CREATE TABLE distributeurs (
    did     integer CONSTRAINT no_null NOT NULL,
    nom     varchar(40) NOT NULL
);
   

Définir une contrainte d'unicité sur la colonne nom :

CREATE TABLE distributeurs (
    did     integer,
    nom     varchar(40) UNIQUE
);
   

La même chose en utilisant une contrainte de table :

CREATE TABLE distributeurs (
    did     integer,
    nom     varchar(40),
    UNIQUE(nom)
);
   

Créer la même table en spécifiant un facteur de remplissage de 70% pour la table et les index uniques :

CREATE TABLE distributeurs (
    did     integer,
    nom     varchar(40),
    UNIQUE(nom) WITH (fillfactor=70)
)
WITH (fillfactor=70);
   

Créer une table cercles avec une contrainte d'exclusion qui empêche le croisement de deux cercles :

CREATE TABLE cercles (
    c circle,
    EXCLUDE USING gist (c WITH &&)
);
   

Créer une table cinemas dans le tablespace diskvol1 :

CREATE TABLE cinemas (
    id serial,
    nom text,
    emplacement text
) TABLESPACE diskvol1;
   

Créer un type composite et une table typée :

CREATE TYPE type_employe AS (nom text, salaire numeric);

CREATE TABLE employes OF type_employe (
    PRIMARY KEY (nom),
    salaire WITH OPTIONS DEFAULT 1000
);
   

Créer une table partitionée par intervalles :

CREATE TABLE measurement (
    logdate         date not null,
    peaktemp        int,
    unitsales       int
) PARTITION BY RANGE (logdate);

Créer une table partitionnée par intervalles avec plusieurs colonnes dans la clé de partitionnement :

CREATE TABLE measurement_year_month (
    logdate         date not null,
    peaktemp        int,
    unitsales       int
) PARTITION BY RANGE (EXTRACT(YEAR FROM logdate), EXTRACT(MONTH FROM logdate));

Créer une table partitionnée par liste de valeurs :

CREATE TABLE cities (
    city_id      bigserial not null,
    name         text not null,
    population   bigint
) PARTITION BY LIST (left(lower(name), 1));

Créer une table partitionnée par hachage :

CREATE TABLE orders (
    order_id     bigint not null,
    cust_id      bigint not null,
    status       text
) PARTITION BY HASH (order_id);

Créer une partition d'une table partitionnée par intervalles :

CREATE TABLE measurement_y2016m07
    PARTITION OF measurement (
    unitsales DEFAULT 0
) FOR VALUES FROM ('2016-07-01') TO ('2016-08-01');

Créer quelques partitions d'une table partitionnée par intervalles avec plusieurs colonnes dans la clé de partitionnement :

CREATE TABLE measurement_ym_older
    PARTITION OF measurement_year_month
    FOR VALUES FROM (MINVALUE, MINVALUE) TO (2016, 11);

CREATE TABLE measurement_ym_y2016m11
    PARTITION OF measurement_year_month
    FOR VALUES FROM (2016, 11) TO (2016, 12);

CREATE TABLE measurement_ym_y2016m12
    PARTITION OF measurement_year_month
    FOR VALUES FROM (2016, 12) TO (2017, 01);

CREATE TABLE measurement_ym_y2017m01
    PARTITION OF measurement_year_month
    FOR VALUES FROM (2017, 01) TO (2017, 02);

Créer une partition d'une table partitionnée par liste de valeur :

CREATE TABLE cities_ab
    PARTITION OF cities (
    CONSTRAINT city_id_nonzero CHECK (city_id != 0)
) FOR VALUES IN ('a', 'b');

Créer une partition d'une table partitionnée par liste e valeur qui est elle-même partitionnée, puis y ajouter une partition :

CREATE TABLE cities_ab
    PARTITION OF cities (
    CONSTRAINT city_id_nonzero CHECK (city_id != 0)
) FOR VALUES IN ('a', 'b') PARTITION BY RANGE (population);

CREATE TABLE cities_ab_10000_to_100000
    PARTITION OF cities_ab FOR VALUES FROM (10000) TO (100000);

Créer des partitions d'une table partitionnée par hachage :

CREATE TABLE orders_p1 PARTITION OF orders
    FOR VALUES WITH (MODULUS 4, REMAINDER 0);
CREATE TABLE orders_p2 PARTITION OF orders
    FOR VALUES WITH (MODULUS 4, REMAINDER 1);
CREATE TABLE orders_p3 PARTITION OF orders
    FOR VALUES WITH (MODULUS 4, REMAINDER 2);
CREATE TABLE orders_p4 PARTITION OF orders
    FOR VALUES WITH (MODULUS 4, REMAINDER 3);

Créer une partition par défaut :

CREATE TABLE cities_partdef
    PARTITION OF cities DEFAULT;

Compatibilité

La commande CREATE TABLE est conforme au standard SQL, aux exceptions indiquées ci-dessous.

Tables temporaires

Bien que la syntaxe de CREATE TEMPORARY TABLE ressemble à celle du SQL standard, l'effet n'est pas le même. Dans le standard, les tables temporaires sont définies une seule fois et existent automatiquement (vide de tout contenu au démarrage) dans toute session les utilisant. PostgreSQL™, au contraire, impose à chaque session de lancer une commande CREATE TEMPORARY TABLE pour chaque table temporaire utilisée. Cela permet à des sessions différentes d'utiliser le même nom de table temporaire dans des buts différents (le standard contraint toutes les instances d'une table temporaire donnée à pointer sur la même structure de table).

Le comportement des tables temporaires tel que défini par le standard est largement ignorée. Le comportement de PostgreSQL™ sur ce point est similaire à celui de nombreuses autres bases de données SQL.

Le standard SQL distingue aussi les tables temporaires globales et locales. Une table temporaire local a un contenu séparé pour chaque module SQL à l'intérieur de chaque session bien que sa définition est toujours partagée entre les sessions. Comme PostgreSQL™ ne supporte pas les modules SQL, la distinction n'a pas de raison d'être avec PostgreSQL™.

Pour des raisons de compatibilité, PostgreSQL™ accepte néanmoins les mots-clés GLOBAL et LOCAL dans la définition d'une table temporaire, mais ils n'ont actuellement aucun effet. L'utilisation de ces mots clés n'est pas conseillée car les versions futures de PostgreSQL™ pourrait adopter une interprétation plus standard de leur signification.

La clause ON COMMIT sur les tables temporaires diffère quelque peu du standard SQL. Si la clause ON COMMIT est omise, SQL spécifie ON COMMIT DELETE ROWS comme comportemant par défaut. PostgreSQL™ utilise ON COMMIT PRESERVE ROWS par défaut. De plus, l'option ON COMMIT DROP n'existe pas en SQL.

Contraintes d'unicité non déferrées

Quand une contrainte UNIQUE ou PRIMARY KEY est non déferrable, PostgreSQL™ vérifie l'unicité immédiatement après qu'une ligne soit insérée ou modifiée. Le standard SQL indique que l'unicité doit être forcée seulement à la fin de l'instruction ; ceci fait une différence quand, par exemple, une seule commande met à jour plusieurs valeurs de clés. Pour obtenir un comportement compatible au standard, déclarez la contrainte comme DEFERRABLE mais non déferrée (c'est-à-dire que INITIALLY IMMEDIATE). Faites attention que cela peut être beaucoup plus lent qu'une vérification d'unicité immédiate.

Contraintes de vérification de colonnes

Dans le standard, les contraintes de vérification CHECK de colonne ne peuvent faire référence qu'à la colonne à laquelle elles s'appliquent ; seules les contraintes CHECK de table peuvent faire référence à plusieurs colonnes. PostgreSQL™ n'impose pas cette restriction ; les contraintes de vérifications de colonnes et de table ont un traitement identique.

EXCLUDE Constraint

Le type de contrainte EXCLUDE est une extension PostgreSQL™.

Contrainte NULL

La « contrainte » NULL (en fait, une non-contrainte) est une extension PostgreSQL™ au standard SQL, incluse pour des raisons de compatibilité avec d'autres systèmes de bases de données (et par symétrie avec la contrainte NOT NULL). Comme c'est la valeur par défaut de toute colonne, sa présence est un simple bruit.

Nommage de contrainte

Le standard SQL stipule que les contraintes de table et de domaine doivent avoir des noms uniques sur le schéma contenant la table ou le domaine. PostgreSQL™ est laxiste : il requiert seulement que le nom des contraintes soit unique parmi les contraintes attachées à une table ou un domaine particulier. Néanmoins, cette liberté supplémentaire n'existe pas pour les contraintes basées sur des index (contraintes UNIQUE, PRIMARY KEY et EXCLUDE) parce que l'index associé est nommé de la même façon que la contrainte, et les noms d'index doivent être uniques parmi toutes les relations du même schéma.

Actuellement, PostgreSQL™ n'enregistre pas de noms pour les contraintes NOT NULL, donc elles ne sont pas sujettes aux restrictions d'unicité. Ceci pourrait changer dans une prochaine version.

Héritage

L'héritage multiple via la clause INHERITS est une extension du langage PostgreSQL™. SQL:1999 et les versions ultérieures définissent un héritage simple en utilisant une syntaxe et des sémantiques différentes. L'héritage style SQL:1999 n'est pas encore supporté par PostgreSQL™.

Tables sans colonne

PostgreSQL™ autorise la création de tables sans colonne (par exemple, CREATE TABLE foo();). C'est une extension du standard SQL, qui ne le permet pas. Les tables sans colonne ne sont pas très utiles mais les interdire conduit à un comportement étrange de ALTER TABLE DROP COLUMN. Il est donc plus sage d'ignorer simplement cette restriction.

Colonnes d'identités multiples

PostgreSQL™ autorise une table à avoir plus d'une colonne d'identité. le standard spécifie qu'une table peut avoir au plus une colonne d'identité. Cette règle est assouplie principalement pour donner plus de flexibilité pour effectuer des changements de schéma ou des migrations. Veuillez noter que la commande INSERT supporte uniquement une seule clause de surcharge qui s'appliquent à la comande entière, et donc avoir de multiples colonnes d'identités avec des comportements différents n'est pas bien supporté.

Generated Columns

L'option STORED n'est pas standard mais est également utilisée dans d'autres implémentations SQL. le standard SQL ne spécifie pas de clause de stockage pour les colonnes générées.

Clause LIKE

Alors qu'une clause LIKE existe dans le standard SQL, beaucoup des options acceptées par PostgreSQL™ ne sont pas dans le standard, et certaines options du standard ne sont pas implémentées dans PostgreSQL™.

Clause WITH

La clause WITH est une extension PostgreSQL™ ; les paramètres de stockage ne sont pas dans le standard.

Tablespaces

Le concept PostgreSQL™ de tablespace n'est pas celui du standard. De ce fait, les clauses TABLESPACE et USING INDEX TABLESPACE sont des extensions.

Tables typées

Les tables typées implémentent un sous-ensemble du standard SQL. Suivant le standard, une table typée a des colonnes correspondant au type composite ainsi qu'une autre colonne qui est la « colonne auto-référente ». PostgreSQL ne supporte pas ces colonnes auto-référentes explicitement mais le même effet est disponible en utilisant la fonctionnalité OID.

Clause PARTITION BY

La clausePARTITION BY est une extension PostgreSQL™ de la norme SQL.

Clause PARTITION OF

La clause PARTITION OF est une extension PostgreSQL™ de la norme SQL.