5 SQL-beperkingen om een ​​goede databasestructuur te garanderen

Belangrijkste leerpunten

• Gebruik SQL-beperkingen om de gegevensintegriteit te behouden en uniformiteit in uw database te garanderen. De NOT NULL-beperking dwingt kolommen om NULL-waarden te weigeren.
• Implementeer primaire sleutelbeperkingen om de uniciteit van waarden in een kolom of reeks kolommen te garanderen. Dit voorkomt dubbele records in een databasetabel.
• Externe sleutelbeperkingen leggen relaties tussen tabellen vast en voorkomen acties die de koppelingen daartussen zouden vernietigen. Ze zorgen ervoor dat een record in de onderliggende tabel verwijst naar de bovenliggende tabel.

Een database is essentieel voor veel toepassingen, maar kan rommelig worden als u geen richtlijnen heeft voor het opslaan en verwerken van gegevens.

SQL-beperkingen specificeren regels voor het opslaan van gegevens in een tabel. Wanneer u beperkingen instelt, genereert de database een foutmelding als u gegevens probeert op te slaan die deze regels overtreden. Beperkingen helpen de gegevensintegriteit te behouden en zorgen voor uniformiteit in uw database.

Er zijn verschillende soorten SQL-beperkingen die u kunt gebruiken; hier zijn enkele van de nuttigste.

1. NIET NULL-beperking

Databasekolommen accepteren standaard gegevens met NULL-waarden. NULL betekent in wezen dat er geen waarde bestaat. De NOT NULL-beperking dwingt een kolom om NULL-waarden te weigeren.

Deze beperking zorgt ervoor dat elke kolom een ​​waarde moet bevatten. U kunt geen record aan de database toevoegen zonder gegevens op te geven voor kolommen met de NOT NULL-beperking.

Neem het voorbeeld van A Klanten tafel. Er zijn enkele noodzakelijke gegevens over elke klant die u wilt vastleggen, zoals hun naam. Voeg de NOT NULL-beperking toe aan de verplichte velden om ervoor te zorgen dat klanten deze informatie verstrekken.

Hier is een voorbeeld dat laat zien hoe u de NOT NULL-beperking kunt gebruiken in a PostgreSQL-database:

CREATETABLE Customers (
 ID int NOT NULL,
 LastName varchar(255) NOT NULL,
 FirstName varchar(255) NOT NULL,
 Mobile_No int NOT NULL,
 Age int
);

Als u probeert een klantrecord in te voegen zonder de Leeftijd veld, accepteert de database dit zonder fouten:

INSERTINTO Customers (ID, LastName, FirstName, Mobile_No)
VALUES (123456, 'Dior', 'Christian', 0723000000);

Als u echter probeert een record in te voegen zonder de Voornaam veld, zal de database het weigeren met een foutmelding:

ERROR: null value in column "firstname" violates not-null constraint
Detail: Failing row contains (123456, Dior, null, 723000000, null).

2. PRIMAIRE SLEUTELbeperking

Een SLEUTEL is een uniek attribuut dat is ingesteld op een kolom of veld en dat de tupel van een tabel (of een record) in databasesystemen identificeert. Een PRIMARY KEY-beperking zorgt ervoor dat waarden in een kolom of reeks kolommen uniek zijn. Het fungeert als een unieke identificatie op rij, waardoor dubbele records in een databasetabel worden voorkomen.

Primaire sleutels bevatten unieke waarden en kunnen geen NULL-waarden bevatten. Elk SQL-databasetabel mag slechts één primaire sleutel hebben. De PRIMARY KEY kan één of meerdere kolommen hebben.

U maakt bijvoorbeeld een database met klantrecords. Elke klant moet zijn ID-nummer anders invoeren dan alle anderen. U kunt de primaire sleutelbeperking toepassen om ervoor te zorgen dat geen van uw klanten hetzelfde ID-nummer heeft.

De volgende code laat zien hoe u een primaire sleutelbeperking in een MySQL-database kunt introduceren:

CREATETABLE Customers (
 ID int NOT NULL,
 LastName varchar(255) NOT NULL,
 FirstName varchar(255),
 Age int,
 PRIMARY KEY (ID)
);

De database accepteert die waarde niet als een gebruiker een ander record met een vergelijkbare ID invoert. In plaats daarvan zal het een fout genereren die duplicatie aangeeft. In het volgende voorbeeld probeert de gebruiker twee records met dezelfde ID in te voegen:

INSERTINTO Customers (ID, LastName, FirstName, Age)
VALUES (1, 'John', 'Doe', 35 ); 
INSERTINTO Customers (ID, LastName, FirstName, Age)
VALUES (1, 'Mary', 'Jane', 35 );

De database toont een foutmelding:

Duplicate entry '1' for key 'PRIMARY'

Maar als u de ID van de tweede klant wijzigt, accepteert de database de invoer. Daarom zorgt de primaire sleutel ervoor dat er geen dubbele ID's in uw klantrecords voorkomen.

3. BUITENLANDSE SLEUTELbeperking

Buitenlandse sleutels relaties leggen tussen twee tabellen. U kunt een refererende sleutel toevoegen aan een veld/kolom in de ene tabel die verwijst naar de primaire sleutel in een andere tabel.

De tabel met de primaire sleutel is de bovenliggende tabel, terwijl de tabel met de externe sleutel de onderliggende tabel is. Er kan dan geen record in de onderliggende tabel bestaan ​​zonder een verwijzing naar de bovenliggende tabel.

De externe sleutelbeperking voorkomt acties die koppelingen tussen tabellen zouden vernietigen. Dat kan bijvoorbeeld niet DRUPPEL de ene tabel als deze met een externe sleutel naar een andere verwijst. Je zult beide tabellen in één keer moeten laten vallen.

In tegenstelling tot een primaire sleutel kunt u een refererende sleutel dupliceren en er meer dan één in één tabel hebben. Externe sleutelwaarden kunnen dat ook zijn NUL. In het volgende voorbeeld moet u de Klanten ID om een ​​bestelling te maken.

CREATETABLE Customers (
 customer_id INT PRIMARY KEY,
 first_name VARCHAR(50),
 last_name VARCHAR(50)
);
CREATETABLE Orders (
 order_id INT PRIMARY KEY,
 customer_id INT,
 order_date DATE,
 FOREIGN KEY (customer_id) REFERENCES Customers(customer_id)
);
INSERTINTO Customers(customer_id, first_name, last_name)
VALUES (1, 'Christian', 'Dior');
INSERTINTO Orders(order_id, customer_id, order_date)
VALUES (1, 1, '2023-08-07');

Als u probeert een bestelling te maken zonder dat deze bestaat Klanten ID, toont de database een foutmelding:

Cannot add or update a child row: a foreign key constraint fails
(`db_9_4ee205c`.`orders`, CONSTRAINT `orders_ibfk_1` FOREIGN KEY
(`customer_id`) REFERENCES `customers` (`customer_id`))

4. UNIEKE beperking

Deze beperking zorgt ervoor dat geen twee rijen dezelfde waarden kunnen hebben voor een specifieke kolom. Net als primaire sleutels handhaaft een unieke beperking de gegevensintegriteit en voorkomt dubbele invoer. Als u met een slecht ontworpen database werkt zonder de UNIEKE beperking, kan het zijn dat u dit uiteindelijk wel moet doen zoek en verwijder de duplicaten.

In tegenstelling tot primaire sleutels kunt u veel UNIEKE beperkingen in één tabel hebben. Bijvoorbeeld bij het maken van een Klanten tabel, wilt u misschien unieke ID's en telefoonnummers hebben. Om een ​​dergelijke beperking toe te voegen met behulp van de MySQL-server, gebruikt u deze syntaxis:

CREATETABLE Customers (
 ID int NOT NULL UNIQUE,
 LastName varchar(255) NOT NULL,
 FirstName varchar(255),
 Mobile_No BIGINT UNIQUE 
);

Als u records met hetzelfde mobiele nummer in de database invoegt, verschijnt er een foutmelding.

INSERTINTO Customers (ID, LastName, FirstName, Mobile_No)
VALUES (123456, 'Dior', 'Christian', 254000000 );
INSERTINTO Customers (ID, LastName, FirstName, Mobile_No)
VALUES (7891011, 'Dedan', 'Kimathi', 254000000 );

De foutmelding zal ongeveer zo zijn:

Duplicate entry '254000000' for key 'Mobile_No'

Deze UNIEKE beperking zorgt ervoor dat de database geen klanten heeft met dezelfde ID's of mobiele nummers.

5. CONTROLEER Beperking

De CHECK-beperking beperkt het waardebereik dat in een kolom wordt geplaatst. Als u een CHECK-beperking aan een kolom toevoegt, zijn alleen opgegeven waarden voor die kolom toegestaan. Het dwingt de gegevensintegriteit af door ervoor te zorgen dat een gebruiker alleen geldige gegevens in een tabel invoegt.

De CHECK-beperking moet een waarde evalueren als TRUE of UNKNOWN voor elke opgegeven rij- of tabelinvoer. Als de waarde FALSE is, toont de database een foutmelding.

In de tabel Klanten wilt u bijvoorbeeld mogelijk alleen klanten bedienen die ouder zijn dan 18 jaar. U kunt een CHECK-beperking toevoegen om ervoor te zorgen dat u geen minderjarige klanten bedient. U kunt de beperking toevoegen aan een PostgreSQL-database, zoals weergegeven in de volgende code:

CREATETABLE Customers (
 ID int NOT NULL,
 Age int CHECK(Age>=18),
 LastName varchar(255) NOT NULL,
 FirstName varchar(255),
 Mobile_No BIGINT UNIQUE 
);

Als u nu de leeftijd van een klant jonger dan 18 jaar probeert in te voeren:

INSERTINTO Customers (ID, Age, LastName, FirstName, Mobile_No)
VALUES (123456, 15, 'Dior', 'Christian', 1254000000 );

De database zal een foutmelding als deze tonen:

ERROR: new row for relation "customers" violates check constraint
"customers_age_check"
Detail: Failing row contains (123456, 15, Dior, Christian, 1254000000)

SQL-beperkingen toevoegen aan en verwijderen uit databases

SQL-beperkingen zijn niet in steen gegoten. U kunt beperkingen aan bestaande tabellen toevoegen of verwijderen met behulp van de instructie ALTER TABLE. Met de ALTER-instructie kunt u met beperkingen werken om aan uw gegevensbehoeften te voldoen.

Er zijn nog veel meer SQL-beperkingen die u kunt leren om een ​​database naar uw wens te ontwerpen. U kunt beginnen met degene die in dit artikel worden vermeld.