SQL-voorbeelden gebruiken PostgreSQL, tenzij een andere dialect wordt genoemd. Korte fragmenten gaan ervan uit dat hun verwijderde tabellen al bestaan. Valideer DDL in uw doeldatabase voordat u deze toepast.
Wat Zijn SQL-beperkingen?
Beperkingen zijn regels die worden afgedwongen door de database-engine om de nauwkeurigheid en betrouwbaarheid van gegevens in een tabel te garanderen. Ze fungeren als vangrails - het voorkomen van ongeldige invoegingen, updates en verwijderingen aan de databasedrempel. Ze beschermen de verklaarde regels; applicatievalidatie en transactieontwerp zijn nog steeds belangrijk.
SQL definieert verschillende soorten beperkingen. In deze handleiding behandelen we elk ervan in detail, laten we zien wanneer u deze moet gebruiken en benadrukken we veelvoorkomende valkuilen.
NOT NULL
De NOT NULL constraint zorgt ervoor dat een kolom altijd een waarde heeft. Elke INSERT of UPDATE dat probeert de kolom in te stellen op NULL wordt afgewezen. Een lege tekenreeks is nog steeds een waarde; voeg een CHECK toe wanneer lege tekst verboden is.
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name VARCHAR(150) NOT NULL, -- every product MUST have a name
price NUMERIC(10,2) NOT NULL -- every product MUST have a price
);
-- This will fail:
INSERT INTO products (name, price) VALUES (NULL, 9.99);
-- ERROR: null value in column "name" violates not-null constraintTip: Standaard op NOT NULL voor elke kolom en verwijder deze alleen als u een duidelijke zakelijke reden heeft om null-waarden toe te staan. Null-waarden introduceren drie-waardige logica in query's en zijn een veelvoorkomende bron van subtiele fouten.
UNIEK
A UNIQUE constraint garandeert dat geen twee rijen dezelfde waarde bevatten in de beperkte kolom (of combinatie van kolommen). In tegenstelling tot een primaire sleutel, kan een UNIQUE kolom kan bevatten NULL. PostgreSQL en MySQL staan doorgaans meerdere null-waarden toe in een unieke kolom; SQL Server staat er één toe in een unieke beperking met één kolom. Dit is een uniciteitsregel, geen resultaat van het evalueren van NULL = NULL.
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL UNIQUE,
username VARCHAR(50) NOT NULL UNIQUE
);
-- Multi-column unique constraint
CREATE TABLE reservations (
id SERIAL PRIMARY KEY,
room_id INT NOT NULL,
date DATE NOT NULL,
CONSTRAINT uq_room_date UNIQUE (room_id, date)
);De multi-kolom UNIQUE constraint hierboven zorgt ervoor dat dezelfde kamer niet twee keer op dezelfde datum kan worden geboekt.
CHECK
CHECK constraints valideren dat een waarde voldoet aan een Booleaanse expressie voordat deze wordt opgeslagen. Ze handhaven regels op rijniveau die het typesysteem alleen niet kan uitdrukken. Een CHECK accepteert TRUE of UNKNOWN; combineer het met NOT NULL wanneer een waarde vereist is.
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
age INT NOT NULL CHECK (age >= 18 AND age <= 120),
salary NUMERIC(12,2) NOT NULL CHECK (salary > 0)
);
-- Named CHECK constraint with multiple columns
CREATE TABLE events (
id SERIAL PRIMARY KEY,
start_date DATE NOT NULL,
end_date DATE NOT NULL,
CONSTRAINT chk_dates CHECK (end_date >= start_date)
);Addertje onder het gras: In MySQL-versies van vóór 8.0.16,CHECK constraints worden geparseerd maar stilzwijgend genegeerd. Controleer altijd of uw databaseversie deze daadwerkelijk afdwingt.
DEFAULT
De DEFAULT levert een waarde wanneer een kolom wordt weggelaten uit een INSERT of DEFAULT expliciet wordt aangevraagd. Een expliciete NULL activeert niet de standaardwaarde. Standaardwaarden verminderen boilerplate in applicatiecode en maken schema's zelfdocumenterend.
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
status VARCHAR(20) NOT NULL DEFAULT 'pending',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
quantity INT NOT NULL DEFAULT 1
);
-- Inserting without specifying status, created_at, or quantity
INSERT INTO orders DEFAULT VALUES;
-- Result: status='pending', created_at=<current time>, quantity=1DEFAULT met expressies
PostgreSQL en SQL Server staan expressies en functieaanroepen toe in standaarden. MySQL ondersteunt dit sinds versie 8.0.13 voor bepaalde typen.
-- PostgreSQL: UUID default
CREATE TABLE tokens (
id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
value TEXT NOT NULL
);PRIMARY KEY- & FOREIGN KEY-beperkingen
Dit zijn de meest structurele beperkingen in relationele databases. Een PRIMARY KEY identificeert elke rij uniek en voegt impliciet toe NOT NULL + UNIQUE. Een FOREIGN KEY koppelt één tabel aan een andere en handhaaft referentiële integriteit.
CREATE TABLE departments (
id SERIAL PRIMARY KEY,
name VARCHAR(80) NOT NULL UNIQUE
);
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL,
department_id INT NOT NULL,
CONSTRAINT fk_emp_dept
FOREIGN KEY (department_id)
REFERENCES departments (id)
ON DELETE RESTRICT
ON UPDATE CASCADE
);Zie onze diepgaande gids over Primary keys versus foreign keys voor cascade-acties, samengestelde sleutels en best practices. U kunt deze relaties ook visueel modelleren in de Erd Go-editor.
Kolomniveau- versus tabelniveaubeperkingen
Beperkingen kunnen worden gedefinieerd inline (kolomniveau) of als een afzonderlijke clausule na alle kolommen (tabelniveau). Het resultaat is identiek — maar tabelniveau is vereist wanneer de beperking over meerdere kolommen loopt.
-- Column-level (single column)
CREATE TABLE items (
id SERIAL PRIMARY KEY,
code VARCHAR(20) NOT NULL UNIQUE,
price NUMERIC(10,2) NOT NULL CHECK (price >= 0)
);
-- Table-level (multi-column constraint)
CREATE TABLE shipments (
id SERIAL PRIMARY KEY,
origin VARCHAR(3) NOT NULL,
destination VARCHAR(3) NOT NULL,
CONSTRAINT chk_different_locations CHECK (origin <> destination),
CONSTRAINT uq_route UNIQUE (origin, destination)
);Benoemde beperkingen & waarom ze belangrijk zijn
Geef uw beperkingen altijd expliciet een naam met de CONSTRAINT sleutelwoord. Wanneer een beperking wordt geschonden, retourneert de database de naam van de beperking in het foutbericht — een betekenisvolle naam zoals chk_positive_salary is oneindig veel nuttiger dan een automatisch gegenereerde hash.
-- Good: named constraint
ALTER TABLE products
ADD CONSTRAINT chk_positive_price CHECK (price > 0);
-- You can also drop a constraint by name
ALTER TABLE products
DROP CONSTRAINT chk_positive_price;Een consistente naamgeving maakt migraties, foutopsporing en het inwerken van teamleden een stuk eenvoudiger. Een veelvoorkomend patroon is:
pk_<table>— primaire sleutelsfk_<table>_<column>— vreemde sleutelsuq_<table>_<column(s)>— unieke beperkingenchk_<table>_<rule>— controleer beperkingen
Beperkingen combineren en veelvoorkomende patronen
In de praktijk dragen kolommen meerdere beperkingen tegelijk. Hier zijn patronen die u keer op keer zult gebruiken:
CREATE TABLE accounts (
id SERIAL PRIMARY KEY,
email VARCHAR(255) NOT NULL,
role VARCHAR(20) NOT NULL DEFAULT 'user'
CHECK (role IN ('user', 'admin', 'moderator')),
balance NUMERIC(12,2) NOT NULL DEFAULT 0.00
CHECK (balance >= 0),
is_active BOOLEAN NOT NULL DEFAULT TRUE,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
deleted_at TIMESTAMPTZ -- nullable: NULL means "not deleted"
);Soft-Delete Patroon
De deleted_at kolom hierboven implementeert een soft delete. In plaats van rijen te verwijderen, stelt u deleted_at = now(). Combineer dit met een partiële unieke index om "actieve" duplicaten te voorkomen, terwijl verwijderde rijen met hetzelfde e-mailadres wel mogelijk blijven. De tabel heeft bewust geen globale UNIQUE-beperking op e-mailadres; het aanhouden daarvan zou ook duplicaten onder verwijderde rijen weigeren:
-- PostgreSQL: unique email only among active accounts
CREATE UNIQUE INDEX uq_accounts_active_email
ON accounts (email)
WHERE deleted_at IS NULL;Veelvoorkomende valkuilen
- NULL en UNIQUE: De meeste databases staan meerdere toe
NULLwaarden in eenUNIQUEkolom omdatNULLis aan niets gelijk — inclusief zichzelf. SQL Server is de uitzondering en behandeltNULLstandaard als een duplicaat; gebruik een gefilterde index om dit te omzeilen. - CHECK in oudere MySQL: Zoals hierboven opgemerkt, ontleedt MySQL van vóór 8.0.16 dit wel maar negeert het
CHECKconstraints. Valideer uw MySQL-versie of handhaaf regels in applicatiecode. - Uitgestelde beperkingen (constraints): PostgreSQL ondersteunt uitgestelde controle voor foreign key-, unieke, primary key- en exclusiebeperkingen die zijn gedeclareerd
DEFERRABLE INITIALLY DEFERRED. CHECK en NOT NULL kunnen niet worden uitgesteld. Dit is handig voor circulaire verwijzingen, maar kan het debuggen moeilijker maken. - Prestaties van CHECK: Eenvoudig
CHECKconstraints hebben verwaarloosbare overhead. Vermijd het insluiten van subqueries of functieaanroepen inCHECK— ze worden mogelijk niet eens ondersteund en kunnen trage logica verbergen. - Beperkingen wijzigen op grote tabellen: Het toevoegen van een
NOT NULLconstraint in PostgreSQL een tabelscan vereisen, tenzij een bestaande gevalideerde CHECK bewijst dat de kolom geen nulls bevat. Overweeg op zeer grote tabellen eenCHECK (column IS NOT NULL) NOT VALIDeerst, en vervolgens afzonderlijk valideren.
Controleer beperkingen in de SQL en het diagram samen in de SQL-naar-ERD-editor, en valideer vervolgens hun gedrag in de doeltabel. Een diagram afdwingen geen gegevensintegriteit.



