Zurück zu allen Anleitungen
SQL··7 Min. Lesezeit

SQL-Constraints erklärt: NOT NULL, UNIQUE, CHECK, DEFAULT und mehr

Meistere SQL-Einschränkungen zum Schutz der Datenintegrität. Lerne NOT NULL, UNIQUE, CHECK, DEFAULT, PRIMARY KEY und FOREIGN KEY anhand klarer Beispiele.

Produkttabelle mit NOT NULL, UNIQUE, CHECK für nicht negative Preise und DEFAULT Null
In diesem Leitfaden
  1. Was sind SQL-Integritätsbedingungen?
  2. NICHT NULL
  3. UNIQUE
  4. CHECK
  5. DEFAULT
  6. PRIMARY KEY- & FOREIGN KEY-Constraints
  7. Spalten- vs. tabellenbezogene Beschränkungen
  8. Benannte Einschränkungen und warum sie wichtig sind
  9. Kombinieren von Einschränkungen & gängigen Mustern
  10. Gängige Fallstricke
  11. Referenzen und weiterführende Literatur

SQL-Beispiele verwenden PostgreSQL, sofern kein anderes Dialekt genannt wird. Kurze Schnipsel setzen voraus, dass ihre referenzierten Tabellen bereits existieren. Validieren Sie DDL in Ihrer Zieldatenbank, bevor Sie sie anwenden.

Was sind SQL-Integritätsbedingungen?

Integritätsbedingungen sind Regeln, die von der Datenbank-Engine durchgesetzt werden, um die Genauigkeit und Zuverlässigkeit von Daten in einer Tabelle zu garantieren. Sie fungieren als Leitplanken, die ungültige Einfügungen, Aktualisierungen und Löschungen an der Datenbankgrenze verhindern. Sie schützen die deklarierten Regeln; Anwendungsvalidierung und Transaktionsdesign sind dennoch wichtig.

SQL definiert verschiedene Constraint-Typen. In diesem Leitfaden behandeln wir jeden einzelnen ausführlich, zeigen, wann er zu verwenden ist, und heben häufige Fallstricke hervor.

NICHT NULL

Das NOT NULL Die Bedingung stellt sicher, dass eine Spalte immer einen Wert hat. Jede INSERT oder UPDATE das versucht, die Spalte auf NULL wird abgelehnt. Ein leerer String ist immer noch ein Wert; fügen Sie ein CHECK hinzu, wenn leerer Text verboten ist.

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 constraint

Tipp: Standard auf NOT NULL für jede Spalte und entfernen Sie sie erst, wenn Sie einen klaren geschäftlichen Grund für die Zulassung von Nullwerten haben. Nullwerte führen eine dreiwertige Logik in Abfragen ein und sind eine häufige Quelle für schwer zu findende Fehler.

UNIQUE

A UNIQUE Bedingung garantiert, dass keine zwei Zeilen denselben Wert in der eingeschränkten Spalte (oder Kombination von Spalten) enthalten. Im Gegensatz zu einem Primärschlüssel kann eine UNIQUE Spalte kann enthalten NULL. PostgreSQL und MySQL erlauben normalerweise mehrere NULL-Werte in einer eindeutigen Spalte; SQL Server erlaubt einen in einer einspaltigen UNIQUE-Beschränkung. Dies ist eine Eindeutigkeitsregel und nicht das Ergebnis der Auswertung von 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)
);

Die mehrspaltige UNIQUE Die obige Bedingung stellt sicher, dass dasselbe Zimmer am selben Datum nicht zweimal gebucht werden kann.

CHECK

CHECK Bedingungen validieren, dass ein Wert einen booleschen Ausdruck erfüllt, bevor er gespeichert wird. Sie erzwingen Regeln auf Zeilenebene, die das Typsystem allein nicht ausdrücken kann. Ein CHECK akzeptiert TRUE oder UNKNOWN; kombinieren Sie ihn mit NOT NULL, wenn ein Wert erforderlich ist.

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)
);

Falle: In MySQL-Versionen vor 8.0.16,CHECK Bedingungen werden geparst, aber stillschweigend ignoriert. Überprüfen Sie immer, ob Ihre Datenbankversion diese tatsächlich erzwingt.

DEFAULT

Das DEFAULT liefert einen Wert, wenn eine Spalte weggelassen wird aus einer INSERT oder DEFAULT wird explizit angefordert. Ein explizites NULL ruft den Standardwert nicht auf. Standardwerte reduzieren Boilerplate-Code im Anwendungscode und machen Schemata selbstdokumentierend.

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=1

DEFAULT mit Ausdrücken

PostgreSQL und SQL Server erlauben Ausdrücke und Funktionsaufrufe in Defaults. MySQL unterstützt dies seit Version 8.0.13 für einige Typen.

-- PostgreSQL: UUID default
CREATE TABLE tokens (
    id    UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    value TEXT NOT NULL
);

PRIMARY KEY- & FOREIGN KEY-Constraints

Dies sind die strukturellsten Einschränkungen in relationalen Datenbanken. Ein PRIMARY KEY identifiziert jede Zeile eindeutig und fügt implizit hinzu NOT NULL + UNIQUE. Ein FOREIGN KEY verknüpft eine Tabelle mit einer anderen und erzwingt die referenzielle Integrität.

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
);

Lesen Sie unseren ausführlichen Leitfaden zu Primärschlüssel vs. Fremdschlüssel für kaskadierende Aktionen, zusammengesetzte Schlüssel und bewährte Methoden. Sie können diese Beziehungen auch visuell modellieren im Erd Go Editor.

Spalten- vs. tabellenbezogene Beschränkungen

Einschränkungen können definiert werden inline (Spaltenebene) oder als separate Klausel nach allen Spalten (Tabellenebene). Das Ergebnis ist identisch – aber die Tabellenebene ist erforderlich, wenn die Einschränkung mehrere Spalten umfasst.

-- 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)
);

Benannte Einschränkungen und warum sie wichtig sind

Benennen Sie Ihre Constraints immer explizit mit dem CONSTRAINT Schlüsselwort. Wenn eine Einschränkung verletzt wird, gibt die Datenbank den Namen der Einschränkung in der Fehlermeldung zurück — ein aussagekräftiger Name wie chk_positive_salary ist unendlich viel hilfreicher als ein automatisch generierter 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;

Eine konsistente Namenskonvention macht Migrationen, Debugging und das Onboarding von Teams wesentlich reibungsloser. Ein gängiges Muster ist:

  • pk_<table> — Primärschlüssel
  • fk_<table>_<column> — Fremdschlüssel
  • uq_<table>_<column(s)> — Eindeutigkeitsbeschränkungen (Unique Constraints)
  • chk_<table>_<rule> — Prüfringe (Check-Constraints)

Kombinieren von Einschränkungen & gängigen Mustern

In der Praxis tragen Spalten mehrere Einschränkungen gleichzeitig. Hier sind Muster, die Sie immer wieder verwenden werden:

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-Muster

Das deleted_at Spalte oben implementiert ein Soft-Delete. Anstatt Zeilen zu entfernen, setzen Sie deleted_at = now(). Kombinieren Sie dies mit einem partiellen eindeutigen Index, um "aktive" Duplikate zu verhindern und gleichzeitig gelöschte Zeilen mit derselben E-Mail-Adresse zuzulassen. Die Tabelle hat bewusst keine globale UNIQUE-Beschränkung für die E-Mail-Adresse; das Beibehalten einer solchen würde auch Duplikate unter gelöschten Zeilen ablehnen:

-- PostgreSQL: unique email only among active accounts
CREATE UNIQUE INDEX uq_accounts_active_email
    ON accounts (email)
    WHERE deleted_at IS NULL;

Gängige Fallstricke

  • NULL und UNIQUE: Die meisten Datenbanken erlauben mehrere NULL Werte in einer UNIQUE Spalte, weil NULL ist gleich überhaupt nichts – einschließlich sich selbst. SQL Server bildet hierbei die Ausnahme und behandelt NULL standardmäßig als Duplikat; verwenden Sie einen gefilterten Index, um dies zu umgehen.
  • CHECK in älteren MySQL-Versionen: Wie oben erwähnt, analysiert MySQL vor 8.0.16, ignoriert aber CHECK Bedingungen. Validieren Sie Ihre MySQL-Version oder erzwingen Sie Regeln im Anwendungscode.
  • Aufgeschobene Einschränkungen: PostgreSQL unterstützt verzögerte Überprüfung für Fremdschlüssel-, eindeutige-, Primärschlüssel- und Ausschlussbeschränkungen, die deklariert wurden DEFERRABLE INITIALLY DEFERRED. CHECK und NOT NULL können nicht zurückgestellt werden. Dies ist nützlich für zirkuläre Verweise, kann aber das Debugging erschweren.
  • Leistung von CHECK: Einfach CHECK Bedingungen haben einen vernachlässigbaren Overhead. Vermeiden Sie das Einbetten von Unterabfragen oder Funktionsaufrufen in CHECK — sie werden möglicherweise nicht einmal unterstützt und können langsam laufende Logik verbergen.
  • Ändern von Constraints bei großen Tabellen: Hinzufügen eines NOT NULL Bedingung in PostgreSQL einen Tabellenscan erfordern, es sei denn, ein bestehender, validierter CHECK beweist, dass die Spalte keine NULL-Werte enthält. Erwägen Sie bei sehr großen Tabellen das Hinzufügen einer CHECK (column IS NOT NULL) NOT VALID zuerst und validieren Sie es dann separat.

Überprüfen Sie Einschränkungen im SQL und im Diagramm gemeinsam im SQL-zu-ERD-Editor, dann validieren Sie ihr Verhalten in der Zieldatenbank. Ein Diagramm erzwingt keine Datenintegrität.

Referenzen und weiterführende Literatur

Weitere Beiträge