Sqlserver
 sql >> Base de données >  >> RDS >> Sqlserver

Clés primaires dans SQL Server

Dans tous les principaux produits SGBDR, Clé primaire dans les contraintes SQL a un rôle vital. Ils identifient de manière unique les enregistrements présents dans une table. Par conséquent, nous devons choisir avec soin le serveur de clés primaires lors de la conception de la table pour améliorer les performances.

Dans cet article, nous allons apprendre ce qu'est une contrainte de clé primaire. Nous verrons également comment créer, modifier ou supprimer des contraintes de clés primaires.

Contraintes SQL Server

Dans SQL Server, Contraintes sont des règles qui régissent la saisie des données dans les colonnes nécessaires. Les contraintes renforcent l'exactitude des données et la manière dont ces données correspondent aux besoins de l'entreprise. De plus, ils rendent les données fiables pour les utilisateurs finaux. C'est pourquoi il est essentiel d'identifier les contraintes correctes pendant la phase de conception de la base de données ou du schéma de table.

SQL Server prend en charge les types de contraintes suivants pour faire respecter l'intégrité des données :

Contraintes de clé primaire sont créés sur une seule colonne ou une combinaison de colonnes pour renforcer l'unicité des enregistrements et identifier les enregistrements plus rapidement. Les colonnes concernées ne doivent pas contenir de valeurs NULL. Par conséquent, la propriété NOT NULL doit être définie sur les colonnes.

Contraintes de clé étrangère sont créés sur une seule colonne ou une combinaison de colonnes pour créer une relation entre deux tables et appliquer les données présentes dans une table à une autre. Idéalement, les colonnes de table où nous devons appliquer les données avec des contraintes de clé étrangère se réfèrent à la table source avec une clé primaire en SQL ou une contrainte de clé unique. En d'autres termes, seuls les enregistrements disponibles dans les contraintes de clé primaire ou unique de la table source peuvent être insérés ou mis à jour dans la table de destination.

Contraintes clés uniques sont créés sur une seule colonne ou sur une combinaison de colonnes pour renforcer l'unicité des données de la colonne. Elles sont similaires aux contraintes de clé primaire avec un seul changement. La différence entre les contraintes de clé primaire et de clé unique est que cette dernière peut être créée sur Nullable colonnes et autoriser un enregistrement de valeur NULL dans sa colonne.

Vérifier les contraintes sont créés sur une colonne unique ou une combinaison de colonnes en limitant les valeurs de données acceptées pour les colonnes impliquées via une expression logique. Il existe une différence entre les contraintes de clé étrangère et de vérification. La clé étrangère renforce l'intégrité des données en vérifiant les données de la clé primaire ou unique d'une autre table. Cependant, la contrainte de vérification le fait en utilisant une expression logique.

Passons maintenant en revue les contraintes de clé primaire.

Contrainte de clé primaire

La contrainte de clé primaire applique l'unicité sur une seule colonne ou une combinaison de colonnes sans aucune valeur NULL dans les colonnes impliquées.

Pour appliquer l'unicité, SQL Server crée un index clusterisé unique sur les colonnes où les clés primaires ont été créées. S'il existe des index clusterisés, SQL Server crée un index unique non clusterisé sur la table pour la clé primaire.

Voyons comment nous créons, modifions, supprimons, désactivons ou activons des clés primaires sur une table à l'aide de scripts T-SQL.

Créer une clé primaire

Nous pouvons créer des clés primaires sur une table lors de la création de la table ou après. La syntaxe varie légèrement pour ces scénarios.

Création de la clé primaire lors de la création de la table

La syntaxe est ci-dessous :

CREATE TABLE SCHEMA_NAME.TABLE_NAME
( 
  COLUMN1 datatype [ NULL | NOT NULL ] PRIMARY KEY,
  COLUMN2 datatype [ NULL | NOT NULL ],
  ...
);

Créons une table nommée Employés dans les Ressources Humaines schéma à des fins de test avec le script ci-dessous :

CREATE TABLE HumanResources.Employees
( Employee_Id INT IDENTITY NOT NULL PRIMARY KEY,
  First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money
);

Nous avons créé avec succès le HumanResources.Employees table sur AdventureWorks base de données :

Nous pouvons voir que l'index clusterisé a été créé sur la table correspondant au nom de la clé primaire, comme indiqué ci-dessus.

Supprimons le tableau à l'aide du script ci-dessous et réessayons avec la nouvelle syntaxe.

DROP TABLE HumanResources.Employees

Pour créer la clé primaire dans SQL sur une table avec le nom de clé primaire défini par l'utilisateur PK_Employees , utilisez la syntaxe ci-dessous :

CREATE TABLE HumanResources.Employees
( Employee_Id INT IDENTITY NOT NULL,
  First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money,
  CONSTRAINT PK_Employees PRIMARY KEY (Employee_Id)
);

Nous avons créé le HumanResources.Employees table avec le nom de clé primaire PK_Employees :

Création de la clé primaire après la création de la table

Parfois, les développeurs ou les DBA oublient les clés primaires et créent des tables sans elles. Mais il est possible de créer une clé primaire sur des tables existantes.

Laissons tomber les HumanResources.Employees table et recréez-la en utilisant le script ci-dessous :

DROP TABLE HumanResources.Employees
GO
CREATE TABLE HumanResources.Employees
( Employee_Id INT IDENTITY NOT NULL,
  First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money
);
GO

Lorsque vous exécutez ce script avec succès, nous pouvons voir les HumanResources.Employees table créée sans clé primaire ni index :

Pour créer une clé primaire nommée PK_Employees sur ce tableau, utilisez la syntaxe ci-dessous :

ALTER TABLE <schema_name>.<table_name>
ADD CONSTRAINT <constraint_name> PRIMARY KEY ( <column_name> );

L'exécution de ce script crée la clé primaire sur notre table :

ALTER TABLE HumanResources.Employees
ADD CONSTRAINT PK_Employees PRIMARY KEY (Employee_ID);

Création de clé primaire sur plusieurs colonnes

Dans nos exemples, nous avons créé des clés primaires sur des colonnes uniques. Si nous voulons créer des clés primaires sur plusieurs colonnes, nous avons besoin d'une syntaxe différente.

Pour ajouter plusieurs colonnes dans le cadre de la clé primaire, nous devons simplement ajouter des valeurs séparées par des virgules des noms de colonne qui doivent faire partie de la clé primaire.

Clé primaire lors de la création de la table

CREATE TABLE HumanResources.Employees
( First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money,
  CONSTRAINT PK_Employees PRIMARY KEY (First_Name, Last_Name)
);
GO

Clé primaire après la création de la table

CREATE TABLE HumanResources.Employees
( First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money
);
GO
ALTER TABLE HumanResources.Employees
ADD CONSTRAINT PK_Employees PRIMARY KEY (First_Name, Last_Name);
GO

Supprimer la clé primaire

Pour supprimer la clé primaire, nous utilisons la syntaxe ci-dessous. Peu importe si la clé primaire était sur une ou plusieurs colonnes.

ALTER TABLE <schema_name>.<table_name>
DROP CONSTRAINT <constraint_name> ;

Pour supprimer la contrainte de clé primaire sur HumanResources.Employees table, utilisez le script ci-dessous :

ALTER TABLE HumanResources.Employees
DROP CONSTRAINT PK_Employees;

La suppression de la clé primaire supprime à la fois les clés primaires et les index cluster ou non cluster créés avec la création de la clé primaire :

Modifier la clé primaire

Dans SQL Server, il n'y a pas de commandes directes pour modifier les clés primaires. Nous devons supprimer une clé primaire existante et la recréer avec les modifications nécessaires. Par conséquent, les étapes pour modifier la clé primaire sont :

  1. Supprimer une clé primaire existante.
  2. Créez de nouvelles clés primaires avec les modifications nécessaires.

Désactiver/Activer la clé primaire

Lors de l'exécution d'un chargement en bloc sur une table contenant de nombreux enregistrements, désactivez la clé primaire et réactivez-la pour de meilleures performances. Les étapes sont ci-dessous :

Désactivez la clé primaire existante avec la syntaxe ci-dessous :

ALTER INDEX <index_name> ON <schema_name>.<table_name> DISABLE;

Pour désactiver la clé primaire sur HumanResources.Employees table, le script est :

ALTER INDEX PK_Employees ON HumanResources.Employees
DISABLE;

Activez les clés primaires existantes qui sont à l'état désactivé. Nous devons RECONSTRUIRE l'index en utilisant la syntaxe ci-dessous :

ALTER INDEX <index_name> ON <schema_name>.<table_name> REBUILD;

Pour activer la clé primaire sur HumanResources.Employees table, utilisez le script suivant :

ALTER INDEX PK_Employees ON HumanResources.Employees
REBUILD;

Les mythes sur la clé primaire

Beaucoup de gens sont confus au sujet des mythes ci-dessous liés aux clés primaires dans SQL Server.

  • La table avec la clé primaire n'est pas une table Heap
  • Les clés primaires ont l'index groupé et les données sont triées par ordre physique

Clarifions-les.

La table avec la clé primaire n'est pas une table Heap

Avant d'approfondir, révisons la définition de la clé primaire et de la table des tas.

La clé primaire crée un index clusterisé sur une table s'il n'y a pas d'autres index clusterisés disponibles à cet endroit. Une table sans index clusterisé sera une table de tas.

Sur la base de ces définitions, nous pouvons comprendre que la clé primaire crée un index clusterisé uniquement s'il n'y a pas d'autres index clusterisés sur la table. S'il existe des index clusterisés existants, la création de la clé primaire créera un index non clusterisé sur la table correspondant à la clé primaire.

Vérifions cela en supprimant HumanResources.Employees Table et recréation :

DROP TABLE HumanResources.Employees
GO
CREATE TABLE HumanResources.Employees
( Employee_Id INT IDENTITY NOT NULL,
  First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money,
  CONSTRAINT PK_Employees PRIMARY KEY NONCLUSTERED (Employee_Id)
);
GO

Nous pouvons spécifier l'option d'index NONCLUSTERED pour la clé primaire (voir ci-dessus). Une table a été créée avec un index unique non clusterisé pour la clé principale PK_Employees .

Par conséquent, cette table est une table de tas même si elle a une clé primaire.

Voyons si SQL Server peut créer un index non clusterisé pour la clé primaire si nous ne spécifions pas le mot clé Non clusterisé lors de la création de la clé primaire. Utilisez le script ci-dessous :

DROP TABLE HumanResources.Employees
GO
CREATE TABLE HumanResources.Employees
( Employee_Id INT IDENTITY NOT NULL,
  First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL,
  DOB DATETIME,
  Dept varchar(100),
  Salary Money
);
GO

-- Create Clustered Index on Employee_Id column before creating Primary Key
CREATE CLUSTERED INDEX IX_Employee_ID ON HumanResources.Employees(First_Name, Last_Name);
GO

-- Create Primary Key on Employee_Id column
ALTER TABLE HumanResources.Employees
ADD CONSTRAINT PK_Employees PRIMARY KEY (Employee_ID);
GO

Ici, nous avons créé un index clusterisé séparément avant la création de la clé primaire. Et une table ne peut avoir qu'un seul index clusterisé. Par conséquent, SQL Server a créé la clé primaire en tant qu'index unique non clusterisé. À l'heure actuelle, la table n'est pas une table Heap car elle possède un index clusterisé.

Si je changeais d'avis et supprimais l'index clusterisé sur le First_Name et Last_Name colonnes en utilisant le script ci-dessous :

DROP INDEX IX_Employee_ID ON HumanResources.Employees;
GO

Nous avons supprimé l'index clusterisé avec succès. Les Ressources.humaines.Employés table est une table Heap même si nous avons une clé primaire disponible dans la table :

Cela efface le mythe selon lequel une table avec une clé primaire peut être une table Heap s'il n'y a pas d'index clusterisés disponibles sur la table.

La clé primaire aura un index groupé et des données triées dans l'ordre physique

Comme nous l'avons appris de l'exemple précédent, une clé primaire en SQL peut avoir un index non clusterisé. Dans ce cas, les enregistrements ne seraient pas triés par ordre physique.

Vérifions la table avec l'index clusterisé sur une clé primaire. Nous allons vérifier s'il trie les enregistrements par ordre physique.

Recréez HumanResources.Employees table avec un minimum de colonnes et la propriété IDENTITY supprimée pour Employee_ID colonne :

DROP TABLE HumanResources.Employees
GO
CREATE TABLE HumanResources.Employees
( Employee_Id INT NOT NULL,
  First_Name VARCHAR(100) NOT NULL,
  Last_Name VARCHAR(100) NOT NULL
);
GO

Maintenant que nous avons créé la table sans la clé primaire ou un index clusterisé, nous pouvons INSÉRER 3 enregistrements dans un ordre non trié pour Employee_Id colonne :

INSERT INTO HumanResources.Employees ( Employee_Id, First_Name, Last_Name)
VALUES
(3, 'Antony', 'Mark'),
(1, 'James', 'Cameroon'),
(2, 'Jackie', 'Chan')

Choisissons parmi les HumanResources.Employees tableau :

SELECT * 
FROM HumanResources.Employees

Nous pouvons voir les enregistrements récupérés dans le même ordre que les enregistrements insérés à partir de la table Heap en ce moment.

Créons une clé primaire sur cette table Heap et voyons si elle a un impact sur l'instruction SELECT :

ALTER TABLE HumanResources.Employees
ADD CONSTRAINT PK_Employees PRIMARY KEY (Employee_ID);
GO
SELECT * 
FROM HumanResources.Employees

Après la création de la clé primaire, nous pouvons voir que l'instruction SELECT a récupéré les enregistrements dans l'ordre croissant de Employee_Id (Colonne Clé primaire). Cela est dû à l'index clusterisé sur Employee_Id .

Si une clé primaire est créée avec l'option non clusterisée, les données de la table ne seront pas triées en fonction de la colonne de la clé primaire.

Si la longueur d'un seul enregistrement dans une table dépasse 4030 octets, un seul enregistrement peut tenir sur une page. L'index cluster garantit que les pages sont dans l'ordre physique.

Une page est une unité de stockage fondamentale dans les fichiers de données SQL Server d'une taille de 8 Ko (8192 octets). Seuls 8060 octets de cette unité sont utilisables pour le stockage de données. Le montant restant est pour les en-têtes de page et autres éléments internes.

Conseils pour choisir les colonnes de clé primaire

  • Les colonnes de type de données entier sont mieux adaptées aux colonnes de clé primaire car elles occupent des tailles de stockage plus petites et peuvent aider à récupérer les données plus rapidement.
  • Étant donné que les colonnes de clé primaire ont un index clusterisé par défaut, utilisez l'option IDENTITY sur les colonnes de type de données entier pour que les nouvelles valeurs soient générées dans un ordre incrémentiel.
  • Au lieu de créer une clé primaire sur plusieurs colonnes, créez une nouvelle colonne d'entiers avec la propriété IDENTITY définie. Créez également un index unique sur plusieurs colonnes identifiées à l'origine pour de meilleures performances.
  • Essayez d'éviter les colonnes avec un type de données de chaîne comme varchar, nvarchar, etc. Nous ne pouvons pas garantir l'incrémentation séquentielle des données sur ces types de données. Cela peut avoir un impact sur les performances d'INSERT sur ces colonnes.
  • Choisissez des colonnes dans lesquelles les valeurs ne seront pas mises à jour en tant que clés primaires. Par exemple, si la valeur de la clé primaire peut passer de 5 à 1000, l'arbre B associé à l'index clusterisé doit être mis à jour, ce qui entraîne une légère dégradation des performances.
  • Si des colonnes de type de données chaîne doivent être choisies comme colonnes de clé primaire, assurez-vous que la longueur des colonnes de type de données varchar ou nvarchar reste petite pour de meilleures performances.

Conclusion

Nous avons parcouru les bases des contraintes disponibles dans SQL Server. Nous avons examiné en détail les contraintes de clé primaire et appris à créer, supprimer, modifier, désactiver et reconstruire des clés primaires. De plus, nous avons clarifié certains mythes populaires autour des clés primaires avec des exemples.

Restez à l'écoute pour le prochain article !