Dit artikel laat zien hoe u een primaire sleutel in SQL Server maakt bij het maken van een tabel met Transact-SQL.
Een primaire sleutel is een of meer kolommen die zijn geconfigureerd als de unieke ID voor een bepaalde tabel. Primaire sleutels kunnen worden gebruikt om de gegevensintegriteit in de tabel af te dwingen.
Een tabel kan slechts één primaire sleutel hebben en primaire sleutels kunnen alleen worden toegevoegd aan kolommen die zijn gedefinieerd als NOT NULL .
Dit artikel laat zien hoe u een primaire sleutel maakt in een nieuwe tabel (d.w.z. bij het maken van de tabel). Als u een primaire sleutel moet maken in een bestaande tabel, zie Een primaire sleutel toevoegen aan een bestaande tabel in SQL Server.
Voorbeeld 1 – Maak een tabel met een primaire sleutel
Eerst maak ik een testdatabase aan:
CREATE DATABASE PK_Test;
Maak nu een nieuwe tabel die een primaire sleutelbeperking bevat:
USE PK_Test;
CREATE TABLE Colors
(
ColorId int IDENTITY (1,1) NOT NULL PRIMARY KEY,
ColorName varchar(50)
);
Dit creëerde een nieuwe tabel met de naam Colors die een primaire sleutelbeperking heeft op zijn ColorId kolom.
Voorbeeld 2 – Controleer de primaire sleutelbeperking
We kunnen de volgende code uitvoeren om een lijst met primaire sleutelbeperkingen in de database te retourneren:
SELECT name, type, unique_index_id, is_system_named FROM sys.key_constraints WHERE type = 'PK';
Resultaat:
+------------------------------+--------+-------------------+-------------------+ | name | type | unique_index_id | is_system_named | |------------------------------+--------+-------------------+-------------------| | PK__Colors__8DA7674DD34F4585 | PK | 1 | 1 | +------------------------------+--------+-------------------+-------------------+
Ik heb de kolommen voor dit voorbeeld verkleind. De sys.key_constraints systeemweergave retourneert meer kolommen dan dit. U kunt altijd de * . gebruiken wildcard om desgewenst alle kolommen terug te geven.
We kunnen aan het zoekresultaat zien dat deze database slechts één primaire sleutel heeft (degene die we zojuist hebben gemaakt).
In dit geval werd de primaire sleutel automatisch benoemd door het systeem. Je hebt ook de mogelijkheid om je eigen naam op te geven (daarover later meer).
Voorbeeld 3 – Controleer de Index
Standaard wordt er een geclusterde index gemaakt wanneer u de primaire sleutel maakt. U kunt de geclusterde index expliciet specificeren of deze automatisch laten maken. U heeft ook de mogelijkheid om een niet-geclusterde index op te geven.
Hier is een query die de index retourneert die automatisch is gemaakt toen ik de bovenstaande primaire sleutel maakte:
SELECT * FROM sys.indexes WHERE name = 'PK__Colors__8DA7674DD34F4585';
Resultaat (met verticale uitvoer):
object_id | 885578193 name | PK__Colors__8DA7674DD34F4585 index_id | 1 type | 1 type_desc | CLUSTERED is_unique | 1 data_space_id | 1 ignore_dup_key | 0 is_primary_key | 1 is_unique_constraint | 0 fill_factor | 0 is_padded | 0 is_disabled | 0 is_hypothetical | 0 is_ignored_in_optimization | 0 allow_row_locks | 1 allow_page_locks | 1 has_filter | 0 filter_definition | NULL compression_delay | NULL suppress_dup_key_messages | 0 auto_created | 0
In dit geval heb ik de resultaten beperkt tot alleen de rij die dezelfde naam bevat als de primaire sleutel die ik zojuist heb gemaakt. Je kunt de WHERE . altijd verwijderen clausule als u meer resultaten wilt retourneren.
We kunnen zien dat deze index een type_desc . heeft van GECLUSTERD .
Voorbeeld 4 – De primaire sleutel een naam geven
De primaire sleutel die we hierboven hebben gemaakt, werd automatisch benoemd door het systeem. U kunt uw eigen naam opgeven als u dat wilt.
Hier is een voorbeeld van het specificeren van een naam voor de primaire sleutel. In dit geval specificeer ik ook een niet-geclusterde index.
USE PK_Test;
CREATE TABLE Cats
(
CatId int IDENTITY (1,1) NOT NULL,
CONSTRAINT PK_Cats_CatId PRIMARY KEY NONCLUSTERED (CatId),
CatName varchar(50)
);
In dit geval gebruik ik de optionele CONSTRAINT trefwoord om het begin van de definitie van de primaire sleutel aan te geven, gevolgd door mijn gekozen naam voor de primaire sleutel. Ik gebruik ook de NONCLUSTERED trefwoord om aan te geven dat het een niet-geclusterde index is.
Controleer de primaire sleutel:
SELECT name, type, unique_index_id, is_system_named FROM sys.key_constraints WHERE type = 'PK';
Resultaat:
+------------------------------+--------+-------------------+-------------------+ | name | type | unique_index_id | is_system_named | |------------------------------+--------+-------------------+-------------------| | PK__Colors__8DA7674DD34F4585 | PK | 1 | 1 | | PK_Cats_CatId | PK | 2 | 0 | +------------------------------+--------+-------------------+-------------------+
Controleer de index:
SELECT * FROM sys.indexes WHERE name = 'PK_Cats_CatId';
Resultaat (met verticale uitvoer):
object_id | 917578307 name | PK_Cats_CatId index_id | 2 type | 2 type_desc | NONCLUSTERED is_unique | 1 data_space_id | 1 ignore_dup_key | 0 is_primary_key | 1 is_unique_constraint | 0 fill_factor | 0 is_padded | 0 is_disabled | 0 is_hypothetical | 0 is_ignored_in_optimization | 0 allow_row_locks | 1 allow_page_locks | 1 has_filter | 0 filter_definition | NULL compression_delay | NULL suppress_dup_key_messages | 0 auto_created | 0
Dus we kunnen zien dat deze keer de type_desc is NIET GECLUSTERD .
Merk op dat bij het maken van een tabel, CLUSTERED kan slechts voor één beperking worden opgegeven. Als het is opgegeven voor een UNIQUE beperking en een PRIMARY KEY beperking is ook gespecificeerd, de PRIMARY KEY standaard ingesteld op NONCLUSTERED .
Voorbeeld 5 – Maak een primaire sleutel op een nullable-kolom
Een primaire sleutel kan alleen worden gemaakt voor kolommen die zijn gedefinieerd als NOT NULL . Als u een primaire sleutel probeert te maken op een kolom die is ingesteld op NULL , krijg je een foutmelding.
Als u de nullabiliteit echter niet opgeeft, wordt de kolom ingesteld op NOT NULL standaard.
Laten we om dit te demonstreren een andere tabel maken, maar deze keer stellen we deze in op NULL :
USE PK_Test;
CREATE TABLE Dogs
(
DogId int IDENTITY (1,1) NULL PRIMARY KEY,
DogName varchar(50)
);
Resultaat:
Msg 8147, Level 16, State 1, Line 3 Could not create IDENTITY attribute on nullable column 'DogId', table 'Dogs'. Msg 8111, Level 16, State 1, Line 3 Cannot define PRIMARY KEY constraint on nullable column in table 'Dogs'. Msg 1750, Level 16, State 0, Line 3 Could not create constraint or index. See previous errors.
Zoals verwacht krijgen we een foutmelding.
Laten we NULL verwijderen uit de tabeldefinitie en probeer het opnieuw:
USE PK_Test;
CREATE TABLE Dogs
(
DogId int IDENTITY (1,1) PRIMARY KEY,
DogName varchar(50)
);
Resultaat:
Commands completed successfully. Total execution time: 00:00:00.015
Deze keer is de tabel met succes gemaakt.
Laten we er eens naar kijken:
SELECT t.name AS 'Table', c.name AS 'Column', c.is_nullable, c.is_identity FROM sys.columns c INNER JOIN sys.tables T ON c.object_id = t.object_id WHERE c.name = 'DogId';
Resultaat:
+---------+----------+---------------+---------------+ | Table | Column | is_nullable | is_identity | |---------+----------+---------------+---------------| | Dogs | DogId | 0 | 1 | +---------+----------+---------------+---------------+
Dus we kunnen zien dat het niet nullable is, omdat de is_nullable vlag is ingesteld op 0 .
Voorbeeld 6 – Primaire sleutel op meerdere kolommen
U kunt ook een primaire sleutel maken voor meerdere kolommen. Primaire sleutels met meerdere kolommen worden ook wel samengestelde primaire sleutels genoemd. Om een samengestelde primaire sleutel te maken, scheidt u de kolommen eenvoudig met een komma bij het definiëren van de sleutel.
Zoals dit:
CONSTRAINT PK_Name PRIMARY KEY (Column1, Column2)
Hier is een voorbeeld van een situatie waarin een primaire sleutel met meerdere kolommen zou kunnen worden gebruikt:
CREATE TABLE Musician ( MusicianId int NOT NULL, FirstName varchar(60), LastName varchar(60), CONSTRAINT PK_Musician PRIMARY KEY (MusicianID) ); CREATE TABLE Band ( BandId int NOT NULL, BandName varchar(255), CONSTRAINT PK_Band PRIMARY KEY (BandId) ); CREATE TABLE BandMember ( MusicianId int NOT NULL, BandId int NOT NULL, CONSTRAINT PK_BandMember PRIMARY KEY (MusicianID, BandId), CONSTRAINT FK_BandMember_Band FOREIGN KEY (BandId) REFERENCES Band(BandId), CONSTRAINT FK_BandMember_Musician FOREIGN KEY (MusicianId) REFERENCES Musician(MusicianId) );
In dit voorbeeld is de BandMember tabel heeft een primaire sleutel met meerdere kolommen. In dit geval is elke kolom in de primaire sleutel ook een externe sleutel naar de primaire sleutel van een andere tabel, maar dit is geen vereiste.
Zie Een samengestelde primaire sleutel maken in SQL Server voor een meer gedetailleerde uitleg van dit voorbeeld.
Zie ook Een samengestelde externe sleutel maken in SQL Server voor een voorbeeld dat een stap verder gaat met een externe sleutel met meerdere kolommen die verwijst naar de bovenstaande samengestelde primaire sleutel.