De verschillende beperkingen in SQL Server verkennen

Beperkingen in SQL Server zijn vooraf gedefinieerde regels die u kunt afdwingen op één of meerdere kolommen. Deze beperkingen helpen de integriteit, betrouwbaarheid en nauwkeurigheid van de waarden die in deze kolommen zijn opgeslagen te behouden. U kunt beperkingen maken met CREATE TABLE- of ALTER Table-instructies. Als u de instructie ALTER TABLE gebruikt, controleert SQL Server de bestaande kolomgegevens voordat de beperking wordt gemaakt.

Als u gegevens invoegt in de kolom die voldoen aan de criteria van de beperkingsregel, voegt SQL Server gegevens met succes in. Als gegevens echter de beperking schenden, wordt de insert-instructie afgebroken met een foutmelding.

Bedenk bijvoorbeeld dat u een tabel [Werknemer] heeft waarin de werknemersgegevens van uw organisatie zijn opgeslagen, inclusief hun salaris. Er zijn een paar vuistregels als het gaat om waarden in de salariskolom.

• De kolom mag geen negatieve waarden hebben, zoals -10.000 of -15.000 USD.
• U wilt ook de maximale salariswaarde opgeven. Het maximale salaris moet bijvoorbeeld minder zijn dan 2.000.000 USD.

Als u een nieuw record met een beperking invoegt, valideert SQL Server de waarde aan de hand van de gedefinieerde regels.

Ingevoegde waarde:

Salaris 80.000:succesvol ingevoegd

Salaris -50.000: Fout

In dit artikel zullen we de volgende beperkingen in SQL Server onderzoeken.

• NIET NULL
• UNIEK
• CONTROLEER
• PRIMAIRE SLEUTEL
• BUITENLANDSE SLEUTEL
• STANDAARD

NIET NULL-beperking

Standaard staat SQL Server het opslaan van NULL-waarden in kolommen toe. Deze NULL-waarden vertegenwoordigen geen geldige gegevens.

Zo moet elke medewerker in een organisatie een Werkgever-ID, voornaam, geslacht en adres hebben. Daarom kunt u een kolom specificeren met NOT NULL-beperkingen om altijd geldige waarden te garanderen.

Het onderstaande CREATE TABLE-script definieert NOT NULL-beperkingen voor de kolommen [ID],[FirstName],[LastName],[Gender] en [Address].

CREATE TABLE Employees
(
ID INT NOT NULL,
[FirstName] Varchar(100) NOT NULL,
[MiddleName] Varchar(50) NULL,
[LastName] Varchar(100) NOT NULL,
[Gender] char(1) NOT NULL,
[Address] Varchar(200) NOT NULL
)

Om de NOT NULL-beperkingen, het gedrag te valideren, gebruiken we de volgende INSERT-instructies.

• Waarden invoegen voor alle kolommen (NULL en NIET NULL) – Succesvol ingevoegd

INSERT INTO Employees (ID,[FirstName],[MiddleName],[LastName],[gender],[Address]) VALUES(1,'Raj','','Gupta','M','India')

• Waarden invoegen voor kolommen met de eigenschap NOT NULL – Succesvol ingevoegd

INSERT INTO Employees (ID,[FirstName],[LastName],[gender],[Address]) VALUES(2,
'Shyam','Agarwal','M','UK')

• Sla het invoegen van waarden over voor [LastName]-kolom met NOT NULL-beperkingen - Fails+

INSERT INTO Employees (ID,[FirstName],[gender],[Address]) VALUES(3,'Sneha','F','India')

De laatste INSERT-instructie heeft de fout veroorzaakt - Kan geen NULL-waarden invoegen in de kolom .

Deze tabel heeft de volgende waarden ingevoegd in de tabel [Werknemers].

Stel dat we geen NULL-waarden nodig hebben in de [MiddleName]-kolom volgens de HR-vereisten. Voor dit doel kunt u de instructie ALTER TABLE gebruiken.

ALTER TABLE Employees
ALTER COLUMN [MiddleName] VARCHAR(50) NOT NULL

Deze instructie ALTER TABLE mislukt vanwege de bestaande waarden van de kolom [MiddleName]. Om de beperking af te dwingen, moet u deze NULL-waarden verwijderen en vervolgens de instructie ALTER uitvoeren.

UPDATE Employees SET [MiddleName]='' WHERE [MiddleName] IS NULL
Go
ALTER TABLE Employees
ALTER COLUMN [MiddleName] VARCHAR(50) NOT NULL

U kunt de NOT NULL-beperkingen ook valideren met behulp van de SSMS-tabelontwerper.

UNIEKE beperking

De UNIQUE-beperking in SQL Server zorgt ervoor dat u geen dubbele waarden in een enkele kolom of combinatie van kolommen hebt. Deze kolommen moeten deel uitmaken van de UNIQUE-beperkingen. SQL Server maakt automatisch een index wanneer UNIEKE beperkingen zijn gedefinieerd. U kunt slechts één unieke waarde in de kolom hebben (inclusief NULL).

Maak bijvoorbeeld de [DemoTable] met de [ID]-kolom met de UNIEKE beperking.

CREATE TABLE DemoTable
(
[ID] INT UNIQUE NOT NULL,
[EmpName] VARCHAR(50) NOT NULL
)

Vouw vervolgens de tabel uit in SSMS en u hebt een unieke index (niet-geclusterd), zoals hieronder weergegeven.

Klik met de rechtermuisknop op de index en genereer het bijbehorende script. Zoals hieronder wordt weergegeven, gebruikt het het trefwoord ADD UNIQUE NONCLUSTERED voor de beperking.

De volgende insert-instructie geeft een fout omdat het dubbele waarden probeert in te voegen.

INSERT INTO DemoTable ([ID],[EmpName]) VALUES (1,'Raj')
GO
INSERT INTO DemoTable ([ID],[EmpName]) VALUES (2,'Alisha')
GO
INSERT INTO DemoTable ([ID],[EmpName]) VALUES (1,'Raj')
GO

CONTROLEER beperking

De beperking CHECK in SQL Server definieert een geldig bereik van waarden die in opgegeven kolommen kunnen worden ingevoegd. Het evalueert elke ingevoegde of gewijzigde waarde, en als er aan wordt voldaan, wordt de SQL-instructie met succes voltooid.

Het volgende SQL-script plaatst een beperking voor de kolom [Leeftijd]. De waarde moet groter zijn dan 18 jaar.

CREATE TABLE DemoCheckConstraint
(
ID INT PRIMARY KEY,
[EmpName] VARCHAR(50) NULL,
[Age] INT CHECK (Age>18)
)
GO

Laten we twee records in deze tabel invoegen. De query voegt het eerste record met succes in.

INSERT INTO DemoCheckConstraint (ID,[EmpName],[Age])VALUES (1,'Raj',20)
Go
INSERT INTO DemoCheckConstraint (ID,[EmpName],[Age])VALUES (2,'Sohan',17)
GO

Het tweede INSERT-statement mislukt omdat het niet voldoet aan de CHECK-beperkingsvoorwaarde.

Een ander gebruiksscenario voor de CHECK-beperking is het opslaan van geldige waarden van postcodes. In het onderstaande script voegen we een nieuwe kolom [ZipCode] toe en het gebruikt de beperking CHECK om de waarden te valideren.

ALTER TABLE DemoCheckConstraint ADD zipcode int
GO
ALTER TABLE DemoCheckConstraint
ADD CONSTRAINT CK_zipcode CHECK (zipcode LIKE REPLICATE ('[0-9]', 5))

Deze beperking CHECK staat geen ongeldige postcodes toe. De tweede instructie INSERT genereert bijvoorbeeld een fout.

INSERT INTO DemoCheckConstraint values(3,'Sneha',19,30203)
Go
INSERT INTO DemoCheckConstraint values(4,'Jenny',21,122102)

PRIMAIRE SLEUTEL beperking

De PRIMARY KEY-beperking in SQL Server is een populaire keuze onder databaseprofessionals voor het implementeren van unieke waarden in een relationele tabel. Het combineert UNIEKE en NIET NULL-beperkingen. SQL Server maakt automatisch een geclusterde index zodra we een PRIMARY KEY-beperking hebben gedefinieerd. U kunt een enkele kolom of een reeks combinaties gebruiken om unieke waarden in een rij te definiëren.

Het primaire doel is om de integriteit van de tabel af te dwingen met behulp van de unieke entiteit of kolomwaarde.

Het is vergelijkbaar met de UNIQUE-beperking met de volgende verschillen.

Het volgende script definieert de PRIMAIRE SLEUTEL in de ID-kolom.

CREATE TABLE PrimaryKeyDemo
(
ID INT PRIMARY KEY,
[Name] VARCHAR(100) NULL
)

Zoals hieronder wordt getoond, heeft u een geclusterde sleutelindex na het definiëren van de PRIMAIRE SLEUTEL in de ID-kolom.

Laten we de records invoegen in de [PrimaryKeyDemo]-tabel met de volgende INSERT-instructies.

INSERT INTO PrimaryKeyDemo ([ID],[NAME]) VALUES (1,'Raj')
GO
INSERT INTO PrimaryKeyDemo ([NAME]) VALUES ('Mohan')
GO

U krijgt een fout in de tweede INSERT-instructie omdat deze de NULL-waarde probeert in te voegen.

Evenzo, als u dubbele waarden probeert in te voegen, krijgt u de volgende foutmelding.

BUITENLANDSE SLEUTEL beperking

De FOREIGN KEY-beperking in SQL Server creëert relaties tussen twee tabellen. Deze relatie staat bekend als de ouder-kindrelatie. Het dwingt referentiële integriteit af in SQL Server.

De refererende sleutel van de onderliggende tabel moet een corresponderend item hebben in de kolom van de bovenliggende primaire sleutel. U kunt geen waarden invoegen in de onderliggende tabel zonder deze eerst in de bovenliggende tabel in te voegen. Op dezelfde manier moeten we eerst de waarde uit de onderliggende tabel verwijderen voordat deze uit de bovenliggende tabel kan worden verwijderd.

Aangezien we geen dubbele waarden kunnen hebben in de PRIMARY KEY-beperking, staat het ook geen dubbele of NULL toe in de onderliggende tabel.

Het volgende SQL-script maakt een bovenliggende tabel met een primaire sleutel en een onderliggende tabel met een primaire en externe sleutelverwijzing naar de kolom [EmpID] van de bovenliggende tabel.

CREATE TABLE ParentTable
(
[EmpID] INT PRIMARY KEY,
[Name] VARCHAR(50) NULL
)
GO
CREATE TABLE ChildTable
(
[ID] INT PRIMARY KEY,
[EmpID] INT FOREIGN KEY REFERENCES ParentTable(EmpID)
)

Voeg records in beide tabellen in. Merk op dat de waarde van de refererende sleutel van de onderliggende tabel een item heeft in de bovenliggende tabel.

INSERT INTO ParentTable VALUES (1,'Raj'),(2,'Komal')
INSERT INTO ChildTable VALUES (101,1),(102,2)

Als u een record rechtstreeks in de onderliggende tabel probeert in te voegen die niet verwijst naar de primaire sleutel van de bovenliggende tabel, krijgt u de volgende foutmelding.

STANDAARD beperking

De DEFAULT-beperking in SQL Server biedt de standaardwaarde voor een kolom. Als we geen waarde opgeven in de INSERT-instructie voor de kolom met de DEFAULT-beperking, gebruikt SQL Server de standaard toegewezen waarde. Stel dat een besteltabel records heeft voor alle bestellingen van klanten. U kunt de GETDATE()-functie gebruiken om de besteldatum vast te leggen zonder een expliciete waarde op te geven.

CREATE TABLE Orders
(
[OrderID] INT PRIMARY KEY,
[OrderDate] DATETIME NOT NULL DEFAULT GETDATE()
)
GO

Om de records in deze tabel in te voegen, kunnen we het toewijzen van waarden voor de [OrderDate]-kolom overslaan.

INSERT INTO Orders([OrderID]) values (1)
GO

KIES * UIT Bestellingen

Zodra de DEFAULT-beperkingskolom een ​​expliciete waarde opgeeft, slaat SQL Server deze expliciete waarde op in plaats van de standaardwaarde.

Beperkende voordelen

De beperkingen in SQL Server kunnen nuttig zijn in de volgende gevallen:

• Bedrijfslogica afdwingen
• Referentiële integriteit afdwingen
• Voorkomen dat onjuiste gegevens in SQL Server-tabellen worden opgeslagen
• uniciteit afdwingen voor kolomgegevens
• Verbetering van de queryprestaties omdat de query-optimizer op de hoogte is van unieke gegevens en reeksen waarden valideert
• Voorkomen dat NULL-waarden in SQL-tabellen worden opgeslagen
• Codes schrijven om NULL te vermijden tijdens het weergeven van gegevens in de applicatie