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 constraintConsejo: 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=1DEFAULT 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 primariasfk_<table>_<column>— claves foráneasuq_<table>_<column(s)>— restricciones únicaschk_<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
NULLvalores en unaUNIQUEcolumna porqueNULLno es igual a nada, incluyéndose a sí mismo. SQL Server es la excepción y trata aNULLcomo 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
CHECKrestricciones. 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
CHECKlas restricciones tienen una sobrecarga insignificante. Evite incrustar subconsultas o llamadas a funciones enCHECK— 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 NULLla 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 unaCHECK (column IS NOT NULL) NOT VALIDprimero, 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.



