Primaire sleutel en buitenlandse sleutel invoeren SQLite met voorbeelden

SQLite beperkingen

Kolombeperkingen dwingen beperkingen en regels af voor de waarden die in een kolom zijn ingevoegd om de ingevoegde gegevens te valideren. Kolommenbeperkingen worden gedefinieerd bij het maken van een tabel, in de kolomdefinitie.

SQLite Hoofdsleutel

Alle waarden in een primaire sleutelkolom moeten uniek zijn en niet null

De primaire sleutel kan op slechts één kolom of op een combinatie van kolommen worden toegepast. In het laatste geval moet de combinatie van de waarden van de kolommen uniek zijn voor alle rijen van de tabellen.

Syntax:

Er zijn veel verschillende manieren om een primaire sleutel in een tabel te definiëren, zoals:

In de kolomdefinitie zelf:

ColumnName INTEGER NOT NULL PRIMARY KEY;

Als aparte definitie:
```
PRIMARY KEY(ColumnName);
```
Om een combinatie van kolommen als primaire sleutel te maken:
```
PRIMARY KEY(ColumnName1, ColumnName2);
```

Geen nulbeperking

SQLite De niet-null-beperking voorkomt dat een kolom een null-waarde heeft:

ColumnName INTEGER  NOT NULL;

STANDAARD Beperking

SQLite Standaardbeperking Als u geen waarde in een kolom invoegt, wordt in plaats daarvan de standaardwaarde ingevoegd.

Bijvoorbeeld:

ColumnName INTEGER DEFAULT 0;

Als u een insert-instructie schrijft en u geen waarde voor die kolom hebt opgegeven, heeft de kolom de waarde 0.

SQLite UNIEKE beperking

SQLite Unieke beperking: het voorkomt dubbele waarden tussen alle waarden van de kolom.

Bijvoorbeeld:

EmployeeId INTEGER NOT NULL UNIQUE;

Hierdoor wordt de “WerknemerID” waarde uniek moet zijn; dubbele waarden zijn niet toegestaan. Houd er rekening mee dat dit van toepassing is op de waarden van de kolom “WerknemerID” alleen.

SQLite CHECK-beperking

SQLite constraint een voorwaarde controleren om een ingevoegde waarde te controleren. Als de waarde niet overeenkomt met de voorwaarde, wordt deze niet ingevoegd.

Quantity INTEGER NOT NULL CHECK(Quantity > 10);

U kunt geen waarde kleiner dan 10 invoegen in de "Aantal stuks" kolom.

SQLite Vreemde sleutel

De SQLite Een externe sleutel is een beperking die het bestaan van een waarde in de ene tabel verifieert ten opzichte van een andere tabel die een relatie heeft met de eerste tabel waarin de externe sleutel is gedefinieerd.

Wanneer u met meerdere tabellen werkt, wanneer er twee tabellen zijn die met elkaar verband houden en één kolom gemeen hebben. En als u er zeker van wilt zijn dat de waarde die in een van de tabellen is ingevoegd, ook in de kolom van de andere tabel moet voorkomen, dan moet u een “Foreign key Constraint” gebruiken voor de gemeenschappelijke kolom.

Wanneer u in dit geval een waarde in die kolom probeert in te voegen, zorgt de externe sleutel ervoor dat de ingevoegde waarde in de kolom van de tabel voorkomt.

Houd er rekening mee dat beperkingen voor externe sleutels niet standaard zijn ingeschakeld in SQLite, moet u ze eerst inschakelen door de volgende opdracht uit te voeren:

PRAGMA foreign_keys = ON;

Er zijn externe sleutelbeperkingen geïntroduceerd SQLite vanaf versie 3.6.19.

Voorbeeld SQLite Vreemde sleutel

Stel dat we twee tabellen hebben; Studenten en afdelingen.

De tabel Studenten bevat een lijst met studenten en de tabel met afdelingen bevat een lijst met afdelingen. Elke student behoort tot een afdeling; Dat wil zeggen dat elke student een afdelingsId-kolom heeft.

Nu zullen we zien hoe de refererende sleutelbeperking nuttig kan zijn om ervoor te zorgen dat de waarde van het afdelings-ID in de studententabel moet bestaan in de afdelingentabel.

Dus als we een externe sleutelbeperking hebben gemaakt voor de AfdelingId in de tabel Studenten, moet elke ingevoegde afdelingId aanwezig zijn in de tabel Afdelingen.

CREATE TABLE [Departments] (
	[DepartmentId] INTEGER  NOT NULL PRIMARY KEY AUTOINCREMENT,
	[DepartmentName] NVARCHAR(50)  NULL
);
CREATE TABLE [Students] (
	[StudentId] INTEGER  PRIMARY KEY AUTOINCREMENT NOT NULL,
	[StudentName] NVARCHAR(50)  NULL,
	[DepartmentId] INTEGER  NOT NULL,
	[DateOfBirth] DATE  NULL,
	FOREIGN KEY(DepartmentId) REFERENCES Departments(DepartmentId)
);

Om te controleren hoe externe sleutelbeperkingen kunnen voorkomen dat een ongedefinieerd element of waarde in een tabel wordt ingevoegd die een relatie heeft met een andere tabel, bekijken we het volgende voorbeeld.

In dit voorbeeld heeft de tabel Departementen een beperking voor een buitenlandse sleutel voor de tabel Studenten, dus elke waarde van DepartmentId die in de tabel Studenten wordt ingevoegd, moet in de tabel Departementen voorkomen. Als u wordt geprobeerd een afdelingId-waarde in te voegen die niet bestaat in de afdelingentabel, zou de beperking van de refererende sleutel u ervan weerhouden dat te doen.

Laten we twee afdelingen invoegen "HET" en “Kunsten” in de tabel met afdelingen als volgt:

INSERT INTO Departments VALUES(1, 'IT');
INSERT INTO Departments VALUES(2, 'Arts');

De twee instructies moeten twee afdelingen in de afdelingentabel invoegen. U kunt ervoor zorgen dat de twee waarden zijn ingevoegd door de query uit te voeren “SELECT * UIT afdelingen” daarna:

Probeer vervolgens een nieuwe student in te voegen met een afdelingId die niet bestaat in de afdelingentabel:

INSERT INTO Students(StudentName,DepartmentId) VALUES('John', 5);

De rij wordt niet ingevoegd en u krijgt een foutmelding die zegt: FOREIGN KEY-beperking is mislukt.

Je houdt misschien van: