SQL CREATE TABLE pour les débutants

Cet article contient du SQL de base CREATE TABLE instructions que les débutants peuvent utiliser pour créer des tables de base pour leurs projets de base de données.

Syntaxe de base

La syntaxe de base pour créer des tables en SQL ressemble à ceci :

CREATE TABLE TableName (
    Column1 datatype optional_constraints,
    Column2 datatype optional_constraints,
    Column3 datatype optional_constraints,
    ...
);

Où :

TableName est le nom que vous voulez donner à la table
Column1 , etc sont les noms que vous donnez à vos colonnes
datatype est le type de données que vous affectez à chaque colonne. La plupart des SGBDR exigent que vous attribuiez un type de données à chaque colonne. Dans SQLite, c'est facultatif.
optional_constraints est une liste facultative de contraintes que vous appliquez à une colonne.

Notez que la plupart des SGBD utilisent une syntaxe plus complexe que celle-ci (c'est-à-dire qu'ils offrent plus d'options), mais c'est généralement la syntaxe de base requise pour créer une table. La plupart des débutants commencent avec cette syntaxe, puis apprennent des options plus avancées au fur et à mesure de leur progression.

Exemple de base

Voici un exemple de base :

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL,
    OwnerId     int NOT NULL,
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Voici quelques points à noter :

Les noms de table et de colonne peuvent être dans n'importe quelle casse. Par exemple, au lieu de PetId J'aurais pu l'appeler petid , PETID , ou pet_id . Certains SGBD (par exemple, Postgres) sont sensibles à la casse lorsque vous interrogez des tables et leurs noms de colonne, tandis que d'autres ne le sont pas (par exemple, SQL Server).
Certains SGBD utilisent des noms différents pour leurs types de données.
NOT NULL est une contrainte de table qui spécifie que cette colonne doit contenir une valeur (c'est-à-dire qu'elle ne peut pas contenir NULL valeurs).
NULL signifie que la colonne est autorisée à contenir NULL valeurs. Certains SGBD (tels que DB2) ne prennent pas en charge le NULL mot-clé, et vous devrez donc l'omettre lorsque vous travaillez avec de tels SGBD.
PRIMARY KEY ajoute une contrainte de clé primaire à la table. Il est recommandé de spécifier une clé primaire sur toutes vos tables.
Si une table du même nom existe déjà dans la base de données, vous obtiendrez une erreur. Vous devrez supprimer le tableau existant ou le modifier (ou changer le nom de celui que vous créez).

Créer une table avec des clés étrangères

L'exemple suivant crée une table avec deux clés étrangères. Les clés étrangères sont utilisées pour créer une relation entre deux tables.

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Les REFERENCES La clause est utilisée pour définir une clé étrangère sur deux colonnes. Dans notre cas, les clés étrangères appliquent les éléments suivants :

Le Pets.PetTypeId la colonne fait référence à PetTypes.PetTypeId colonne (toute valeur entrant dans la colonne Pets.PetTypeId la colonne doit avoir une valeur correspondante dans le PetTypes.PetTypeId colonne).
Le Pets.OwnerId la colonne fait référence à Owners.OwnerId colonne (toute valeur qui va dans le Pets.OwnerId la colonne doit avoir une valeur correspondante dans Owners.OwnerId colonne).

Les clés étrangères peuvent également être ajoutées ultérieurement, à l'aide de ALTER TABLE déclaration si nécessaire.

Créer une table avec la contrainte DEFAULT

L'exemple suivant crée une table avec un DEFAULT contrainte.

CREATE TABLE OrderItems
(
    OrderId     int NOT NULL PRIMARY KEY,
    OrderItem   int NOT NULL,
    ProductId   int NOT NULL,
    Quantity    int NOT NULL DEFAULT 1,
    ItemPrice   decimal(8,2) NOT NULL 
);

Créer un tableau avec une colonne d'horodatage

Vous pouvez utiliser DEFAULT contraintes pour insérer automatiquement la date et l'heure actuelles dans une colonne chaque fois qu'une nouvelle ligne est insérée. Ceci est souvent appelé insertion d'un horodatage.

Différents SGBD utilisent différentes fonctions pour renvoyer la date actuelle.

Voici un exemple de le faire dans SQL Server.

CREATE TABLE Users
(
    UserId         int NOT NULL PRIMARY KEY,
    FirstName      varchar(60) NOT NULL,
    LastName       varchar(60) NOT NULL,
    DateInserted   datetime DEFAULT CURRENT_TIMESTAMP
);

Dans SQL Server, CURRENT_TIMESTAMP est l'équivalent ANSI de GETDATE() fonction.

Vous pouvez également utiliser SYSDATETIME() pour un horodatage plus précis :

CREATE TABLE Users
(
    UserId         int NOT NULL PRIMARY KEY,
    FirstName      varchar(60) NOT NULL,
    LastName       varchar(60) NOT NULL,
    DateInserted   datetime2 DEFAULT SYSDATETIME()
);

Afin de prendre en charge la plus grande précision, le type de données de la colonne doit être datetime2 .

SQL Server a plusieurs types de données pour les valeurs de date/heure. Voir les fonctions de date et d'heure de SQL Server pour une liste.

Chaque SGBD a ses propres fonctions pour retourner la date et l'heure. Voici une liste des principaux :

DB2	`CURRENT_DATE`
MySQL	`CURRENT_DATE` ou `NOW()`
Oracle	`SYSDATE`
PostgreSQL	`CURRENT_DATE`
SQL Server	`CURRENT_TIMESTAMP` , `GETDATE()` ou `SYSDATETIME()`
SQLite	`datetime('now')`

Voir aussi :

Fonctions de date et d'heure SQL Server
Fonctions de date et d'heure SQLite

Créer une colonne avec une valeur qui s'incrémente automatiquement

Parfois, vous devez créer une colonne qui incrémente automatiquement une valeur chaque fois qu'une nouvelle ligne est insérée. Celles-ci sont généralement appelées colonnes "d'auto-incrémentation" ou "d'identité", selon le SGBD utilisé.

Dans SQL Server, utilisez le IDENTITY argument :

CREATE TABLE Users
(
    UserId         int NOT NULL IDENTITY(1,1) PRIMARY KEY,
    FirstName      varchar(60) NOT NULL,
    LastName       varchar(60) NOT NULL,
    DateInserted   datetime2 DEFAULT SYSDATETIME()
);

Dans ce cas, nous utilisons IDENTITY(1,1) .

Le premier 1 est la graine. Cela spécifie quelle valeur commencer le comptage (c'est-à-dire qu'il s'agit de la valeur de la toute première ligne insérée dans le tableau).
Le deuxième 1 est l'incrément. Il s'agit de la valeur incrémentielle ajoutée à la valeur d'identité de la ligne précédente chargée.

Chaque SGBD a son propre mot-clé pour créer une colonne auto-incrémentée.

Dans MySQL et MariaDb, utilisez AUTO_INCREMENT
Dans SQLite, vous avez plusieurs options (y compris le AUTOINCREMENT mot-clé)
Dans PostgreSQL, utilisez SERIAL
Depuis la base de données Oracle 12c , vous pouvez désormais utiliser le mot clé IDENTITY pour créer des colonnes à incrémentation automatique. Un exemple pourrait ressembler à :UserId NUMBER GENERATED BY DEFAULT ON NULL AS IDENTITY

Options avancées

La plupart des SGBD vous permettent de spécifier des options avancées lors de la création de tables. Les options disponibles dépendront en grande partie de votre SGBD.

Reportez-vous à la documentation de votre SGBD si vous avez besoin d'options qui ne sont pas spécifiées dans cet article.

De nombreuses options avancées peuvent être définies via l'interface graphique (selon l'outil que vous utilisez pour vous connecter à votre base de données). Vous pouvez toujours créer ou modifier une table via l'interface graphique, puis utiliser son option "Script as Create" (ou similaire) pour voir le code SQL que vous auriez besoin d'exécuter pour créer une telle table. Vous pouvez prendre ce code et modifier les noms de table, les noms de colonne, etc. pour créer une toute nouvelle table basée sur la définition de la précédente.