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é es SQL DDL?
Lenguaje de definición de datos (DDL) es el subconjunto de SQL utilizado para definir y gestionar estructuras de bases de datos. A diferencia del DML (Lenguaje de Manipulación de Datos) que maneja operaciones de datos (INSERT, SELECT, UPDATE, DELETE), el DDL se centra en el esquema en sí: crear, modificar y eliminar objetos de base de datos como tablas, tipos y restricciones.
Los tres comandos DDL principales son CREATE, ALTER, y DROP. Dominar estos aspectos es esencial para cualquier desarrollador que trabaje con bases de datos relacionales.
CREATE TABLE
La sentencia DDL más fundamental. Define una nueva tabla con sus columnas, tipos de datos y restricciones.
Sintaxis básica
CREATE TABLE table_name (
column_name data_type [constraints],
...
[table_constraints]
);Ejemplo completo
CREATE TABLE departments (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL
);
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
email TEXT UNIQUE NOT NULL,
department_id INTEGER REFERENCES departments(id),
salary NUMERIC(10, 2) DEFAULT 0 CHECK (salary >= 0),
hire_date DATE DEFAULT CURRENT_DATE,
is_active BOOLEAN DEFAULT true
);Tipos de datos comunes por base de datos
| Categoría | PostgreSQL | MySQL | SQL Server |
|---|---|---|---|
| Incremento automático | SERIAL | INT AUTO_INCREMENT | INT IDENTITY(1,1) |
| Texto variable | VARCHAR(n), TEXT | VARCHAR(n), TEXT | NVARCHAR(n), NVARCHAR(MAX) (texto JSON); json en SQL Server 2025 |
| Booleano | BOOLEAN | TINYINT(1) | BIT |
| Marca de tiempo | TIMESTAMP | DATETIME | DATETIME2 |
| UUID | UUID | CHAR(36) | UNIQUEIDENTIFIER |
| JSON | JSONB | JSON | NVARCHAR(MAX) (texto JSON); json en SQL Server 2025 |
Restricciones de columna
Las restricciones aplican reglas sobre los Datos en sus tablas:
CREATE TABLE categories (
id SERIAL PRIMARY KEY,
name VARCHAR(100) NOT NULL
);
CREATE TABLE products (
-- PRIMARY KEY: uniquely identifies each row
id SERIAL PRIMARY KEY,
-- NOT NULL: column cannot contain NULL
name VARCHAR(200) NOT NULL,
-- UNIQUE: no duplicate values allowed
sku VARCHAR(50) UNIQUE,
-- DEFAULT: automatic value when not provided
status VARCHAR(20) DEFAULT 'draft',
-- CHECK: validates data with a condition
price NUMERIC(10, 2) CHECK (price >= 0),
-- REFERENCES: creates a foreign key relationship
category_id INTEGER REFERENCES categories(id)
);Restricciones a nivel de tabla
Para claves compuestas y restricciones de múltiples columnas, defínalas a nivel de tabla:
CREATE TABLE students (id INTEGER PRIMARY KEY);
CREATE TABLE courses (id INTEGER PRIMARY KEY);
CREATE TABLE enrollments (
student_id INTEGER,
course_id INTEGER,
enrolled_at TIMESTAMP DEFAULT now(),
grade CHAR(2),
PRIMARY KEY (student_id, course_id),
CONSTRAINT fk_student
FOREIGN KEY (student_id) REFERENCES students(id),
CONSTRAINT fk_course
FOREIGN KEY (course_id) REFERENCES courses(id),
CONSTRAINT chk_grade
CHECK (grade IN ('A', 'B', 'C', 'D', 'F'))
);ALTER TABLE
Modifique la estructura de una tabla existente agregando o cambiando columnas y restricciones. Los ejemplos aquí utilizan PostgreSQL; SQL Server omite COLUMN en ADD, y SQLite requiere reconstruir la tabla para muchos cambios de restricciones.
Añadir una clave foránea
ALTER TABLE orders
ADD CONSTRAINT fk_orders_customer
FOREIGN KEY (customer_id)
REFERENCES customers(id);Añadir una columna
ALTER TABLE users
ADD COLUMN phone VARCHAR(20);Añadir una restricción de unicidad
ALTER TABLE users
ADD CONSTRAINT uq_users_email
UNIQUE (email);Añadir una restricción de verificación (Check Constraint)
ALTER TABLE products
ADD CONSTRAINT chk_price_positive
CHECK (price > 0);CREATE TYPE
Defina tipos reutilizables personalizados (característica de PostgreSQL también soportada por Erd Go):
Tipo Enum
CREATE TYPE order_status AS ENUM (
'pending', 'processing', 'shipped',
'delivered', 'cancelled'
);
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
status order_status DEFAULT 'pending'
);Tipo compuesto
CREATE TYPE address AS (
street VARCHAR(200),
city VARCHAR(100),
state CHAR(2),
zip VARCHAR(10)
);
CREATE TABLE companies (
id SERIAL PRIMARY KEY,
name VARCHAR(200) NOT NULL,
headquarters address
);DROP TABLE
DROP TABLE elimina la definición de la tabla y sus datos. Usa DELETE para eliminar filas seleccionadas manteniendo la estructura de la tabla. Este ejemplo de PostgreSQL crea una tabla de preparación y luego la elimina:
CREATE TABLE staging_orders (
id INTEGER PRIMARY KEY
);
DROP TABLE IF EXISTS staging_orders;IF EXISTS maneja una tabla faltante; no omite las comprobaciones de dependencia. PostgreSQL normalmente rechaza una eliminación cuando otros objetos dependen de la tabla. Revisa las dependencias antes de elegir CASCADE, que también puede eliminar objetos dependientes. El comportamiento de las transacciones DDL varía según el motor de la base de datos.
Referencia rápida
| Sentencia | Propósito | Ejemplo |
|---|---|---|
DROP TABLE | Eliminar una tabla y sus datos | DROP TABLE IF EXISTS staging_orders; |
CREATE TABLE | Definir una nueva tabla | CREATE TABLE users (...); |
CREATE TYPE | Definir tipo personalizado | CREATE TYPE status AS ENUM (...); |
ALTER TABLE ADD | Añadir columna/restricción | ALTER TABLE t ADD COLUMN c INT; |
PRIMARY KEY | Identificador de fila único | id SERIAL PRIMARY KEY |
FOREIGN KEY | Referenciar otra tabla | REFERENCES users(id) |
UNIQUE | Sin valores duplicados | email TEXT UNIQUE |
NOT NULL | Valor requerido | name VARCHAR(100) NOT NULL |
DEFAULT | Valor por defecto | status TEXT DEFAULT 'active' |
CHECK | Validar datos | CHECK (price >= 0) |



