Volver a todas las guías
SQL··7 min de lectura

Restricciones SQL explicadas: NOT NULL, UNIQUE, CHECK, DEFAULT y más

Domine las restricciones SQL para proteger la integridad de los datos. Aprenda NOT NULL, UNIQUE, CHECK, DEFAULT, PRIMARY KEY y FOREIGN KEY con ejemplos claros.

Tabla de productos con NOT NULL, UNIQUE, CHECK de precio no negativo y DEFAULT cero
En esta guía
  1. ¿Qué son las restricciones SQL?
  2. NOT NULL
  3. UNIQUE
  4. CHECK
  5. DEFAULT
  6. Restricciones PRIMARY KEY y FOREIGN KEY
  7. Restricciones a nivel de columna vs a nivel de tabla
  8. Restricciones con nombre y por qué son importantes
  9. Combinación de restricciones y patrones comunes
  10. Errores comunes
  11. Referencias y lecturas adicionales

Los ejemplos de SQL utilizan PostgreSQL a menos que se mencione otro dialecto. Los fragmentos cortos asumen que las tablas a las que se hace referencia ya existen. Valide el DDL en su base de datos de destino antes de aplicarlo.

¿Qué son las restricciones SQL?

Restricciones son reglas aplicadas por el motor de base de datos para garantizar la precisión y fiabilidad de los datos en una tabla. Actúan como barandillas, evitando inserciones, actualizaciones y eliminaciones no válidas en el límite de la base de datos. Protegen las reglas declaradas; la validación de la aplicación y el diseño de transacciones siguen siendo importantes.

SQL define varios tipos de restricciones. En esta guía cubriremos cada uno en profundidad, mostraremos cuándo usarlo y destacaremos los errores comunes.

NOT NULL

El NOT NULL la restricción asegura que una columna siempre tenga un valor. Cualquier INSERT o UPDATE que intenta establecer la columna en NULL será rechazado. Una cadena vacía sigue siendo un valor; añade un CHECK cuando el texto en blanco esté prohibido.

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

Consejo: Predeterminado a NOT NULL para cada columna y solo elimínalo cuando tengas una razón de negocio clara para permitir nulos. Los nulos introducen lógica trivalente en las consultas y son una fuente común de errores sutiles.

UNIQUE

A UNIQUE la restricción garantiza que no haya dos filas que contengan el mismo valor en la columna restringida (o combinación de columnas). A diferencia de una clave primaria, una UNIQUE columna puede contienen NULL. PostgreSQL y MySQL normalmente permiten múltiples valores nulos en una columna única; SQL Server permite uno en una restricción única de una sola columna. Esta es una regla de unicidad, no el resultado de evaluar 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)
);

La columna múltiple UNIQUE la restricción de arriba asegura que la misma habitación no pueda reservarse dos veces en la misma fecha.

CHECK

CHECK las restricciones validan que un valor satisfaga una expresión booleana antes de ser almacenado. Aplican reglas a nivel de fila que el sistema de tipos por sí solo no puede expresar. Un CHECK acepta TRUE o UNKNOWN; combínelo con NOT NULL cuando se requiera un valor.

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

Advertencia: En versiones de MySQL anteriores a la 8.0.16,CHECK las restricciones son analizadas pero ignorado silenciosamente. Verifique siempre que la versión de su base de datos realmente las aplique.

DEFAULT

El DEFAULT proporciona un valor cuando se omite una columna de un INSERT o se solicita DEFAULT explícitamente. Un NULL explícito no invoca el valor predeterminado. Los valores predeterminados reducen el código repetitivo en la aplicación y hacen que los esquemas sean autodocumentados.

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 con expresiones

PostgreSQL y SQL Server permiten expresiones y llamadas a funciones en valores predeterminados. MySQL admite esto desde la versión 8.0.13 para algunos tipos.

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

Restricciones PRIMARY KEY y FOREIGN KEY

Estas son las restricciones más estructurales en las bases de datos relacionales. Un PRIMARY KEY identifica de forma única cada fila e implícitamente añade NOT NULL + UNIQUE. Un FOREIGN KEY vincula una tabla con otra y aplica la integridad referencial.

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

Consulte nuestra guía detallada sobre Claves primarias frente a claves foráneas para acciones en cascada, claves compuestas y mejores prácticas. También puede modelar estas relaciones visualmente en el Editor de Erd Go.

Restricciones a nivel de columna vs a nivel de tabla

Se pueden definir restricciones en línea (a nivel de columna) o como una cláusula independiente después de todas las columnas (a nivel de tabla). El resultado es idéntico — pero a nivel de tabla se requiere cuando la restricción abarca varias columnas.

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

Restricciones con nombre y por qué son importantes

Nombre siempre sus restricciones explícitamente utilizando el CONSTRAINT palabra clave. Cuando se viola una restricción, la base de datos devuelve el nombre de la restricción en el mensaje de error, un nombre significativo como chk_positive_salary es infinitamente más útil que un hash generado automáticamente.

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

Una convención de nomenclatura consistente hace que las migraciones, la depuración y la incorporación del equipo sean mucho más fluidas. Un patrón común es:

  • pk_<table> — claves primarias
  • fk_<table>_<column> — claves foráneas
  • uq_<table>_<column(s)> — restricciones únicas
  • chk_<table>_<rule> — restricciones de verificación (check constraints)

Combinación de restricciones y patrones comunes

En la práctica, las columnas conllevan varias restricciones a la vez. Aquí hay patrones que usará una y otra vez:

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

Patrón de eliminación lógica (Soft-Delete)

El deleted_at la columna de arriba implementa un eliminación lógica. En lugar de eliminar filas, usted establece deleted_at = now(). Combine esto con un índice único parcial para evitar duplicados "activos" y al mismo tiempo permitir filas eliminadas con el mismo correo electrónico. La tabla no tiene deliberadamente una restricción UNIQUE global en el correo electrónico; mantener una también rechazaría duplicados entre las filas eliminadas:

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

Errores comunes

  • NULL y UNIQUE: La mayoría de las bases de datos permiten múltiples NULL valores en una UNIQUE columna porque NULL no es igual a nada, incluyéndose a sí mismo. SQL Server es la excepción y trata a NULL como duplicado de forma predeterminada; use un índice filtrado para solucionar esto.
  • CHECK en versiones antiguas de MySQL: Como se señaló anteriormente, MySQL antes de 8.0.16 analiza pero ignora CHECK restricciones. Valide su versión de MySQL o aplique las reglas en el código de la aplicación.
  • Restricciones diferidas: PostgreSQL admite la comprobación diferida para restricciones de clave foránea, única, clave primaria y exclusión declaradas DEFERRABLE INITIALLY DEFERRED. CHECK y NOT NULL no se pueden diferir. Esto es útil para referencias circulares, pero puede dificultar la depuración.
  • Rendimiento de CHECK: Simple CHECK las restricciones tienen una sobrecarga insignificante. Evite incrustar subconsultas o llamadas a funciones en CHECK — es posible que ni siquiera sean compatibles y pueden ocultar una lógica lenta.
  • Alteración de restricciones en tablas grandes: Añadiendo un/a NOT NULL la restricción en PostgreSQL puede requerir un escaneo de tabla a menos que un CHECK validado existente pruebe que la columna no contiene nulos. En tablas muy grandes, considere agregar una CHECK (column IS NOT NULL) NOT VALID primero, luego validándolo por separado.

Revise las restricciones en el SQL y el diagrama juntos en el Editor de SQL a ERD, luego valide su comportamiento en la base de datos de destino. Un diagrama no impone la integridad de los Datos.

Referencias y lecturas adicionales

Más publicaciones