Détermination des contraintes d'intégrité. Créer des clés primaires Clé primaire dans la table sql

Les types de données eux-mêmes limitent la quantité de données pouvant être stockées dans une table. Cependant, pour de nombreuses applications, ces limites sont trop sévères. Par exemple, une colonne contenant le prix d'un produit ne devrait probablement prendre que des valeurs positives. Mais ce type de données standard n'existe pas. Vous pouvez également vouloir restreindre les données de colonne par rapport à d'autres colonnes ou lignes. Par exemple, dans un tableau contenant des informations sur un produit, il ne doit y avoir qu'une seule ligne avec un code produit spécifique.

Pour ce faire, SQL vous permet de définir des contraintes sur les colonnes et les tables. Les contraintes vous permettent de manipuler les données de vos tables comme vous le souhaitez. Si l'utilisateur essaie de stocker une valeur dans la colonne qui viole les contraintes, une erreur est renvoyée. Les restrictions s'appliqueront même s'il s'agit de la valeur par défaut.

5.3.1. Vérifier les contraintes

La contrainte de vérification est la plus type général restrictions. Dans sa définition, vous pouvez spécifier que la valeur d'une colonne donnée doit satisfaire expression logique(vérifier la vérité). Par exemple, le prix d'un produit peut être limité à des valeurs positives comme celle-ci :

Texte du nom, prix numérique CHEQUE (prix> 0) );

Comme vous pouvez le voir, la contrainte est définie après le type de données, tout comme la valeur par défaut. Les valeurs par défaut et les limites peuvent être spécifiées dans n'importe quel ordre. La contrainte de vérification consiste en mot-clé CHECK suivi d'une expression entre parenthèses. Cette expression doit inclure la colonne pour laquelle la contrainte est spécifiée, sinon cela n'a pas beaucoup de sens.

Vous pouvez également donner à la restriction un nom distinct. Cela améliorera les messages d'erreur et vous permettra de référencer cette contrainte lorsque vous devrez la modifier. Vous pouvez le faire comme ceci :

CONTRAINTE prix_positif CHEQUE (prix> 0));

Autrement dit, pour créer une contrainte nommée, écrivez le mot-clé CONSTRAINT suivi d'un identifiant et de la définition de contrainte réelle. (Si vous ne définissez pas un nom de contrainte de cette manière, le système choisira un nom pour vous.)

Une contrainte de validation peut également référencer plusieurs colonnes. Par exemple, si vous enregistrez le prix régulier et le prix réduit, vous pouvez vous assurer que le prix réduit est toujours inférieur au prix régulier :

CREATE TABLE produits (product_no entier, nom texte, prix numérique CHECK (prix> 0), discounted_price numérique CHECK (discounted_price> 0), CHECK (prix> discounted_price) );

Les deux premières contraintes sont définies de manière similaire, mais la troisième utilise une nouvelle syntaxe. Il n'est pas associé à une colonne spécifique, mais est représenté comme un élément distinct dans la liste. Les définitions de colonnes et de telles définitions de contraintes peuvent être réorganisées dans n'importe quel ordre.

Les deux premières contraintes peuvent être considérées comme des contraintes de colonne, tandis que la troisième est une contrainte de table car elle est écrite séparément des définitions de colonne. Les contraintes de colonne peuvent également être écrites sous forme de contraintes de table, alors que l'inverse n'est pas toujours possible, car la contrainte de colonne est censée faire référence uniquement à une colonne liée. (Bien que PostgreSQL ne l'exige pas, il est préférable de suivre cette règle pour la compatibilité avec d'autres SGBD.) L'exemple ci-dessus peut être réécrit comme suit :

CREATE TABLE produits (product_no integer, name text, price numeric, CHECK (price> 0), discounted_price numeric, CHECK (discounted_price> 0), CHECK (price> discounted_price));

Ou même comme ça :

CREATE TABLE products (product_no integer, name text, price numérique CHECK (price> 0), discounted_price numérique, CHECK (discounted_price> 0 AND price> discounted_price));

C'est une question de goût.

Vous pouvez nommer les contraintes de table de la même manière que les contraintes de colonne :

CREATE TABLE produits (product_no integer, name text, price numeric, CHECK (price> 0), discounted_price numeric, CHECK (discounted_price> 0), CONTRAINTE valid_discount CHECK (prix> discounted_price));

Notez que la contrainte de test est satisfaite si l'expression est évaluée à true ou à NULL. Étant donné que de nombreuses expressions avec des opérandes NULL donneront NULL, de telles contraintes n'empêcheront pas les NULL d'être écrits dans les colonnes associées. Pour vous assurer qu'une colonne ne contient pas de valeurs NULL, vous pouvez utiliser la contrainte NOT NULL décrite dans la section suivante.

5.3.2. Contraintes NOT NULL

La contrainte NOT NULL indique simplement que la colonne ne peut pas se voir attribuer une valeur NULL. Exemple de syntaxe :

CREATE TABLE produits (product_no entier NON NULL, texte du nom NON NULL, prix numérique);

Une contrainte NOT NULL est toujours écrite comme une contrainte de colonne et est fonctionnellement équivalente à un CHECK ( nom de colonne IS NOT NULL), mais la contrainte explicite NOT NULL fonctionne plus efficacement dans PostgreSQL. Cependant, un tel enregistrement présente un inconvénient - vous ne pouvez pas attribuer de nom à de telles restrictions.

Naturellement, vous pouvez définir plusieurs contraintes pour une colonne. Pour ce faire, il vous suffit de les spécifier un par un :

CREATE TABLE products (product_no integer NOT NULL, name text NOT NULL, price numeric NOT NULL CHECK (price> 0));

L'ordre n'a pas d'importance ici, il ne correspond pas forcément à l'ordre dans lequel les contraintes sont vérifiées.

Il y a aussi l'inverse pour la contrainte NOT NULL : la contrainte NULL. Cela ne signifie pas que la colonne ne doit être que NULL, ce qui serait bien sûr inutile. Son essence est dans une simple indication que la colonne peut être NULL (c'est le comportement par défaut). Il n'y a pas de contrainte NULL dans le standard SQL et ne doit pas être utilisé dans des applications portables. (Il a été ajouté à Postgres Pro uniquement pour la compatibilité avec d'autres SGBD.) Cependant, certains utilisateurs aiment l'utiliser car il vous permet de changer facilement de contraintes dans un script. Par exemple, vous pouvez commencer par :

CREATE TABLE products (product_no integer NULL, name text NULL, price numeric NULL);

puis insérez le mot-clé NOT si nécessaire.

rapide

Dans la conception de bases de données, la plupart du temps, la plupart des colonnes doivent être marquées NON NULL.

5.3.3. Contraintes d'unicité

Des contraintes uniques garantissent que les données dans une colonne spécifique ou un groupe de colonnes sont uniques parmi toutes les lignes du tableau. La restriction s'écrit comme ceci :

CREATE TABLE produits (product_no entier UNIQUE

comme contrainte de colonne et donc :

CREATE TABLE produits (product_no entier, nom texte, prix numérique, UNIQUE (product_no) );

comme contrainte de table.

Pour définir une contrainte d'unicité pour un groupe de colonnes, écrivez-la sous forme de contrainte de table, en séparant les noms de colonnes, séparés par des virgules :

UNIQUE (a, c) );

Cette restriction indique que la combinaison des valeurs des colonnes répertoriées doit être unique dans l'ensemble du tableau, alors que les valeurs de chaque colonne individuellement ne devraient pas (et ne le seront généralement pas) uniques.

Vous pouvez nommer la contrainte d'unicité de la manière habituelle :

CREATE TABLE produits (product_no entier CONTRAINTE doit_être_différent UNIQUE, texte du nom, prix numérique);

L'ajout d'une contrainte unique créera automatiquement un index B-tree unique pour la colonne ou le groupe de colonnes répertorié dans la contrainte. Une condition unique qui s'applique uniquement à certaines lignes ne peut pas être écrite en tant que contrainte unique, mais elle peut être définie en créant un index partiel unique.

De manière générale, la contrainte d'unicité est violée si le tableau contient plusieurs lignes qui ont les mêmes valeurs pour toutes les colonnes incluses dans la contrainte. Cependant, deux valeurs NULL ne sont jamais considérées comme égales lorsqu'elles sont comparées. Cela signifie que même s'il existe une contrainte unique dans la table, vous pouvez conserver des lignes avec des valeurs en double si elles contiennent des valeurs NULL dans une ou plusieurs des colonnes de contrainte. Ce comportement suit la norme SQL, mais nous avons entendu parler de SGBD qui se comportent différemment. Gardez cela à l'esprit lorsque vous développez des applications portables.

5.3.4. Clés primaires

Une contrainte de clé primaire signifie que la colonne ou le groupe de colonnes constituant peut être un identifiant unique pour les lignes d'une table. Cela nécessite que les valeurs soient à la fois uniques et non NULL. Ainsi, les tables avec les deux définitions suivantes accepteront les mêmes données :

CREATE TABLE products (product_no integer UNIQUE NOT NULL, name text, price numeric); CREATE TABLE produits (product_no entier CLÉ PRIMAIRE, texte du nom, prix numérique);

Les clés primaires peuvent inclure plusieurs colonnes ; la syntaxe est similaire à l'écriture de contraintes d'unicité :

Exemple CREATE TABLE (un entier, b entier, c entier, CLÉ PRIMAIRE (a, c) );

Lorsqu'une clé primaire est ajoutée, un index B-tree unique est automatiquement créé pour la colonne ou le groupe de colonnes répertorié dans la clé primaire, et ces colonnes sont marquées NON NULL.

Une table peut avoir au maximum une clé primaire. (Il peut y avoir n'importe quel nombre de contraintes d'unicité et de contraintes NOT NULL, qui sont fonctionnellement presque équivalentes aux clés primaires, mais vous ne pouvez en attribuer qu'une comme contrainte de clé primaire.) La théorie des bases de données relationnelles dit que chaque table doit avoir une clé primaire. Postgres Pro n'a pas d'exigence aussi stricte, mais il est généralement préférable de la suivre.

Les clés primaires sont utiles à la fois pour la documentation et les applications clientes. Par exemple, application graphique avec la possibilité de modifier le contenu d'une table, vous avez probablement besoin de connaître la clé primaire d'une table afin d'identifier de manière unique ses lignes. Les clés primaires trouvent également d'autres utilisations dans les SGBD ; en particulier, la clé primaire dans une table définit les colonnes cibles par défaut pour les clés étrangères référençant cette table.

5.3.5. Clés étrangères

Une contrainte de clé étrangère spécifie que les valeurs d'une colonne (ou d'un groupe de colonnes) doivent correspondre aux valeurs d'une ligne d'une autre table. On l'appelle intégrité référentielle deux tableaux liés.

Supposons que vous ayez déjà un tableau de produits que nous avons utilisé plusieurs fois auparavant :

CREATE TABLE products (product_no integer PRIMARY KEY, nom texte, prix numérique);

Supposons que vous ayez un tableau avec les commandes de ces produits. Nous voulons que la table des commandes ne contienne que les commandes de produits réellement existants. Par conséquent, nous allons y définir une contrainte de clé étrangère qui fait référence à la table des produits :

RÉFÉRENCES produits (product_no) , nombre entier);

Avec cette restriction, il sera impossible de créer une commande avec une valeur product_no qui ne figure pas dans la table products (et qui n'est pas égale à NULL).

Dans un tel schéma, la table des commandes est appelée subalterne table et produits - le principal... En conséquence, les colonnes sont également appelées subordonnée et maître (ou référencement et cible).

La commande précédente peut être raccourcie comme ceci :

CREATE TABLE commandes (order_id entier PRIMARY KEY, product_no entier RÉFÉRENCES produits, nombre entier);

c'est-à-dire que si vous omettez la liste des colonnes, la clé étrangère est implicitement liée à la clé primaire de la table principale.

Une clé étrangère peut également faire référence à un groupe de colonnes. Dans ce cas, il doit être écrit comme une contrainte de table régulière. Par exemple:

CREER TABLE t1 (un entier PRIMARY KEY, b entier, c entier, CLÉ ÉTRANGÈRE (b, c) RÉFÉRENCES other_table (c1, c2) );

Naturellement, le nombre et les types de colonnes de la contrainte doivent correspondre au nombre et aux types des colonnes cibles.

Vous pouvez nommer une contrainte de clé étrangère de manière standard.

Une table peut contenir plusieurs contraintes de clé étrangère. Ceci est utile pour les relations plusieurs-à-plusieurs entre les tables. Supposons que vous ayez des tableaux de produits et de commandes, mais que vous souhaitiez qu'une commande puisse contenir plusieurs produits (ce qui n'est pas possible dans le schéma précédent). Pour ce faire, vous pouvez utiliser le schéma suivant :

CREATE TABLE products (product_no integer PRIMARY KEY, nom texte, prix numérique); CREATE TABLE commandes (order_id entier PRIMARY KEY, shipping_address text, ...); CREATE TABLE order_items (product_no entier RÉFÉRENCE produits, order_id entier RÉFÉRENCE commandes, quantité entier, PRIMARY KEY (product_no, order_id));

Notez que dans le dernier tableau, la clé primaire couvre les clés étrangères.

Nous savons que les clés étrangères empêchent la création de commandes qui ne sont liées à aucun produit. Mais que se passe-t-il si, après avoir créé des commandes avec un certain produit, nous voulons le supprimer ? SQL gérera cette situation. L'intuition suggère les comportements suivants :

Empêcher le retrait du produit

Supprimer également les commandes associées

Autre chose?

Pour illustrer, implémentons le comportement suivant dans l'exemple ci-dessus : lorsque nous essayons de supprimer un produit référencé par des commandes (via la table order_items), nous désactivons cette opération. Si quelqu'un essaie de supprimer la commande, son contenu sera également supprimé :

CREATE TABLE products (product_no integer PRIMARY KEY, nom texte, prix numérique); CREATE TABLE commandes (order_id entier PRIMARY KEY, shipping_address text, ...); CREATE TABLE order_items (product_no entier REFERENCES produits SUR SUPPRESSION LIMITER, order_id entier RÉFÉRENCES commandes SUR SUPPRIMER CASCADE, quantité entière, PRIMARY KEY (product_no, order_id));

Les suppressions contraignantes et en cascade sont les deux options les plus courantes. RESTRICT empêche la suppression de la ligne associée. PAS D'ACTION signifie que si lignes dépendantes continuent d'exister lorsque la contrainte est vérifiée, une erreur est renvoyée (c'est le comportement par défaut). (La principale différence entre ces deux options est que NO ACTION vous permet de reporter la validation pendant une transaction, alors que RESTRICT ne le fait pas.) CASCADE spécifie que la suppression des lignes liées supprimera également automatiquement celles qui en dépendent. Il existe deux autres options : SET NULL et SET DEFAULT. Lors de la suppression de lignes associées, ils attribuent respectivement des valeurs NULL ou par défaut aux colonnes dépendantes de la table subordonnée. Notez que ce ne sera pas une raison pour une violation de contrainte. Par exemple, si SET DEFAULT est spécifié comme action, mais que la valeur par défaut ne satisfait pas la contrainte de clé étrangère, l'opération échouera.

Semblable à l'instruction ON DELETE, il y a une ON UPDATE qui est déclenchée lorsque la colonne spécifiée change. Dans ce cas, les actions possibles sont les mêmes, mais CASCADE dans ce cas signifie que les valeurs modifiées des colonnes associées seront copiées dans les lignes dépendantes.

En règle générale, la ligne dépendante n'a pas à satisfaire la contrainte de clé étrangère si l'une des colonnes associées est NULL. Si MATCH FULL est ajouté à la déclaration de clé étrangère, la chaîne ne satisfera à la contrainte que si toutes les colonnes associées sont NULL (c'est-à-dire lorsque significations différentes(NULL et non NULL) garantira l'échec de la contrainte MATCH FULL). Si vous ne souhaitez pas que les lignes dépendantes échappent à cette limitation, déclarez les colonnes associées NON NULL.

La clé étrangère doit faire référence aux colonnes qui forment la clé primaire ou la contrainte d'unicité. Ainsi, il y aura toujours un index (défini par la clé primaire ou la contrainte correspondante) pour les colonnes associées, ce qui signifie que les vérifications de correspondance sur la ligne associée seront effectuées efficacement. Étant donné que les commandes DELETE pour les lignes de la table principale ou les commandes UPDATE pour les colonnes dépendantes nécessitent l'analyse de la table subordonnée et la recherche de lignes référençant les anciennes valeurs, il est également utile d'avoir un index pour les colonnes subordonnées. Mais ce n'est pas toujours nécessaire, et il existe différentes manières de créer l'index correspondant, donc une déclaration de clé étrangère ne crée pas automatiquement un index sur les colonnes liées.

Dernière mise à jour : 27.04.2019

Les clés étrangères vous permettent d'établir des relations entre les tables. La clé étrangère est définie pour les colonnes de la table dépendante et subordonnée et pointe vers l'une des colonnes de la table principale. En règle générale, une clé étrangère pointe vers une clé primaire d'une table maître associée.

La syntaxe générale pour définir une clé étrangère au niveau de la table est :

FOREIGN KEY (column1, column2, ... columnN) RÉFÉRENCES master_table (column_main_table1, column_main_table2, ... column_main_tableN)

Pour créer une contrainte de clé étrangère, après FOREIGN KEY, vous spécifiez la colonne de table qui représentera la clé étrangère. Le mot clé REFERENCES est suivi du nom de la table associée, suivi du nom de la colonne associée entre parenthèses vers laquelle la clé étrangère pointera. L'expression REFERENCES est suivie des instructions ON DELETE et ON UPDATE, qui spécifient l'action à entreprendre lorsqu'une ligne est supprimée et mise à jour de la table principale, respectivement.

Par exemple, définissons deux tables et lions-les à l'aide d'une clé étrangère :

CREATE TABLE Clients (Id INT PRIMARY KEY AUTO_INCREMENT, Age INT, FirstName VARCHAR (20) NOT NULL, LastName VARCHAR (20) NOT NULL, Phone VARCHAR (20) NOT NULL UNIQUE); CREATE TABLE Orders (Id INT PRIMARY KEY AUTO_INCREMENT, CustomerId INT, CreatedAt Date, FOREIGN KEY (CustomerId) REFERENCES Customers (Id));

Dans ce cas, les tables Clients et Commandes sont définies. Le client est responsable et représente le client. Les commandes sont dépendantes et représentent une commande passée par un client. La table Orders est liée via la colonne CustomerId à la table Customers et à sa colonne Id. Autrement dit, la colonne CustomerId est une clé étrangère qui pointe vers la colonne Id de la table Customers.

À l'aide de l'instruction CONSTRAINT, vous pouvez spécifier un nom pour la contrainte de clé étrangère :

CREATE TABLE Orders (Id INT PRIMARY KEY AUTO_INCREMENT, CustomerId INT, CreatedAt Date, CONSTRAINT orders_custonmers_fk FOREIGN KEY (CustomerId) RÉFÉRENCES Customers (Id));

SUR SUPPRESSION et SUR MISE À JOUR

Les instructions ON DELETE et ON UPDATE peuvent être utilisées pour définir les actions à entreprendre, respectivement, lorsqu'une ligne associée est supprimée et modifiée de la table maître. Les options suivantes peuvent être utilisées comme action :

CASCADE : supprime ou modifie automatiquement les lignes d'une table dépendante lors de la suppression ou de la modification de lignes liées dans la table principale.

SET NULL : définit la colonne de clé étrangère sur NULL lors de la suppression ou de la mise à jour d'une ligne associée de la table maître. (Dans ce cas, la colonne de clé étrangère doit prendre en charge la valeur NULL)

RESTREINDRE : rejette la suppression ou la modification de lignes dans la table maître s'il existe des lignes liées dans la table dépendante.

AUCUNE ACTION : identique à RESTRICT.

SET DEFAULT : lors de la suppression d'une ligne associée de la table maître, définit la colonne de clé étrangère sur la valeur par défaut, qui est définie à l'aide des attributs DEFAULT. Bien que cette option soit en principe disponible, le moteur InnoDB ne prend pas en charge cette expression.

Suppression en cascade

La suppression en cascade vous permet de supprimer automatiquement toutes les lignes liées de la table dépendante lorsque vous supprimez une ligne de la table maître. Pour cela, l'option CASCADE est utilisée :

CREATE TABLE Orders (Id INT PRIMARY KEY AUTO_INCREMENT, CustomerId INT, CreatedAt Date, FOREIGN KEY (CustomerId) REFERENCES Customers (Id) ON DELETE CASCADE);

L'instruction ON UPDATE CASCADE fonctionne de manière similaire. Changer la valeur de la clé primaire changera automatiquement la valeur de sa clé étrangère associée. Cependant, étant donné que les clés primaires sont très rarement modifiées et, en principe, il n'est pas recommandé d'utiliser des colonnes avec des valeurs mutables comme clés primaires, en pratique l'instruction ON UPDATE est rarement utilisée.

Réglage sur NULL

Lors de la définition de l'option SET NULL pour une clé étrangère, la colonne de clé étrangère doit être nullable :

CREATE TABLE Orders (Id INT PRIMARY KEY AUTO_INCREMENT, CustomerId INT, CreatedAt Date, FOREIGN KEY (CustomerId) REFERENCES Customers (Id) ON DELETE SET NULL);

), nous avons analysé le fonctionnement d'une base de données relationnelle (tabulaire) et découvert que les principaux éléments d'une base de données relationnelle sont : les tableaux, les colonnes et les lignes, et en termes mathématiques : les relations, les attributs et les tuples. Aussi souvent, les lignes sont appelées enregistrements, les colonnes sont appelées colonnes et l'intersection d'un enregistrement et d'une colonne est appelée une cellule.

Il est important de se rappeler que le contenu des lignes et les noms de colonnes doivent être uniques dans la même base de données.

Types de données de la base de données

Il est important de comprendre que vous pouvez créer des bases de données pour tout type de données : textes, dates, heures, événements, nombres. Les bases de données relationnelles sont divisées en types selon le type d'information. Chaque type de données (attribut) a sa propre désignation :

INTEGER - données à partir d'entiers ;
FLOAT - données de nombres fractionnaires, les données dites à virgule flottante ;
CHAR, VARCHAR - types de données texte (caractère);
LOGIQUE - type booléen données (oui / non);
DATE / HEURE - données temporaires.

Ce sont les principaux types de données, dont il existe en fait beaucoup plus. De plus, chaque langage de programmation possède son propre ensemble d'attributs système (types de données).

Qu'est-ce que la clé primaire et la clé étrangère des tables de bases de données relationnelles

Clé primaire

Nous l'avons rappelé plus haut : chaque ligne (enregistrement) de la base de données doit être unique. C'est la clé primaire sous forme d'ensembles certaines valeurs identifier au maximum chaque entrée. Vous pouvez le définir différemment. Clé primaire : Un ensemble de caractéristiques spécifiques qui sont uniques à chaque enregistrement. La clé primaire est désignée comme clé primaire.

Clé primaire (PK) très important pour chaque table. Laissez-moi vous expliquer pourquoi.

La clé primaire ne permet pas de créer des enregistrements (lignes) identiques dans la table ;
PK fournit un lien logique entre les tables d'une même base de données (pour les bases de données relationnelles).

Il vaut la peine de s'attarder sur la connexion logique entre les tables.

Clé externe

Clé étrangère, abrégé FK. Fournit une connexion logique sans ambiguïté entre les tables de la même base de données.

Par exemple, il y a deux tables A et B. Dans la table A (chaussures), il y a une clé primaire : taille, dans la table B (couleur) il devrait y avoir une colonne avec le nom taille. Dans cette table, "taille" sera la clé étrangère pour la connexion logique entre les tables B et A.

Un exemple plus complexe.

Deux tableaux de données : Personnes et Numéros de téléphone.

Tableau : Personnes

Tableau : Numéros de téléphone

PK est unique dans la table des numéros de téléphone. Le FK de cette table est le PK de la table People. Le lien entre les numéros de téléphone et les personnes est assuré par les tables téléphoniques FK. C'est-à-dire:

Zaitsev a deux téléphones ;
Volkov a deux téléphones ;
Belkin a un téléphone.

clé primaire et clé étrangère

En conclusion, j'ajouterai que tout le gestionnaire de base de données a la capacité technique de composer la clé primaire.

CLÉ PRIMAIRE- clé primaire, une contrainte qui permet d'identifier de manière unique chaque enregistrement de la table SQL.

CLÉ PRIMAIRE Oracle
Clé primaire ( CLÉ PRIMAIRE) peut contraindre les tables ou leurs colonnes. Cette limitation fonctionne de la même manière que Contrainte unique... Cependant, vous devez tenir compte de la différence entre les clés primaires et l'unicité des colonnes dans la façon dont vous les utilisez avec les clés étrangères. Les clés primaires ne peuvent pas autoriser les valeurs NULL. Cela signifie que, comme les champs de la contrainte UNIQUE, tout champ utilisé dans la contrainte CLÉ PRIMAIRE, doit déjà avoir été déclaré NOT NULL.

CLÉ PRIMAIRE Oracle... Exemple 1.
Exemple de création d'un tableau SQL avec limitation CLÉ PRIMAIRE:

Étudiant
(Entier Kod_stud NON NULL CLÉ PRIMAIRE,
Fam char (30) NON NULL UNIQUE,
Char d'Adres (50),
Balle décimale);

Il est préférable de mettre une contrainte CLÉ PRIMAIRE dans le ou les champs qui formeront un identifiant de chaîne unique, et conservera la contrainte UNIQUE pour les champs qui doivent être logiquement uniques (tels que les numéros de téléphone ou les champs sname), pas pour les chaînes d'identification. Limitation CLÉ PRIMAIRE peut également être appliqué à plusieurs champs qui constituent une combinaison unique de valeurs :

CLÉ PRIMAIRE Oracle... Exemple #2.

CRÉER UN TABLEAUÉtudiant
(Fam char (30) NON NULL,
Je suis char (30) NON NULL
Char d'Adres (50),
CLÉ PRIMAIRE(Fam, je));

CLÉ PRIMAIRE MySQL

CLÉ PRIMAIRE SQL / MySQL... Exemple n°3.

CRÉER UN TABLEAU Personnes (
P_Id entier NON NULL,
LastName varchar (255) NON NULL,
Prénom varchar (255),
Adresse varchar (255),
Ville varchar (255),
CLÉ PRIMAIRE(P_Id));

CLÉ PRIMAIRE SQL/MySQL... Exemple n° 4.

CRÉER UN TABLEAU`paquets_annonces` (
`id` int (111) NON NULL auto_increment,
`title` varchar (132) NON NULL par défaut",
`price` float NOT NULL default' 0 ',
`type` varchar (22) NON NULL par défaut",
`c_type` enum (‘ cash ’,’ points ’,’ rur ’) NOT NULL default’ cash ’,
CLÉ PRIMAIRE(`id`)
);

CLÉ PRIMAIRE SQL/MySQL... Exemple n° 5.

CREER TABLE `gamestat` (
`id` int (11) NON NULL auto_increment,
`jeu` varchar (10) NON NUL par défaut 'tuz',
`stavok` int (11) NON NULL default' 0 ',
`usd` float NOT NULL default' 0 ',
`rur` float NOT NULL default' 0 ',
`point` float NOT NULL default' 0 ',
`bank_usd` décimal (12,2) NON NULL par défaut' 0.00 ',
`bank_rur` décimal (12,2) NON NULL par défaut' 0.00 ',
`bank_point` décimal (12,2) NOT NULL default' 0.00 ',
CLÉ PRIMAIRE (`id`)
);

La clé primaire est un champ dans une table qui identifie de manière unique chaque ligne/enregistrement dans une table de base de données. Les clés primaires doivent contenir des valeurs uniques. La colonne de clé primaire ne peut pas avoir de valeur.

Une table ne peut avoir qu'une seule clé primaire, qui peut être constituée d'un ou plusieurs champs. Lorsque plusieurs champs sont utilisés comme clé primaire, ils sont appelés clé composite.

Si une table a une clé primaire définie sur un ou plusieurs champs, vous ne pouvez pas avoir deux enregistrements ayant la même valeur pour ce ou ces champs.

Noter- Vous pouvez utiliser ces concepts lors de la création de tables de base de données.

Création d'une clé primaire

Voici la syntaxe pour définir l'attribut ID comme clé primaire dans la table Customers.

CRÉER DES CLIENTS DE TABLE (ID INT NON NULL, NOM VARCHAR (20) NON NULL, AGE INT NON NULL, ADRESSE CAR (25), SALAIRE DECIMAL (18, 2), PRIMARY KEY (ID));

Pour créer une contrainte de clé primaire sur la colonne "ID" lorsque la table CUSTOMERS existe déjà, utilisez la commande suivante Syntaxe SQL:

ALTER TABLE LES CLIENTS AJOUTENT LA CLÉ PRIMAIRE (ID) ;

Noter

Si vous utilisez instruction ALTER TABLE, pour ajouter une clé primaire, la ou les colonnes de clé primaire doivent avoir déjà été déclarées comme non NULL (si la table a été créée en premier).

Pour définir une clé primaire sur plusieurs colonnes, utilisez la syntaxe SQL ci-dessous :

CRÉER DES CLIENTS DE TABLE (ID INT NON NULL, NOM VARCHAR (20) NON NULL, AGE INT NON NULL, ADRESSE CAR (25), SALAIRE DECIMAL (18, 2), PRIMARY KEY (ID, NAME));

Pour créer une contrainte de clé primaire sur les colonnes "ID" et "NAME" lorsque la table CUSTOMERS existe déjà, utilisez la syntaxe SQL suivante.

ALTER TABLE LES CLIENTS AJOUTENT LA CONTRAINTE PK_CUSTID PRIMARY KEY (ID, NAME);

Suppression de la clé primaire

Vous pouvez effacer les contraintes de clé primaire du tableau à l'aide de la syntaxe ci-dessous.

ALTER TABLE LES CLIENTS LAISSERENT LA CLÉ PRIMAIRE ;