SQL CREATE TABLE: definir una tabla

Lección 9.1 · Tiempo de lectura: ~9 min · Tareas de práctica ↓

La sentencia SQL CREATE TABLE crea una tabla nueva: sus columnas, sus tipos de datos y las reglas que deben cumplir los datos. En esta lección aprenderás a definir columnas, elegir tipos de datos y usar las restricciones principales: PRIMARY KEY, NOT NULL, UNIQUE, DEFAULT, CHECK y FOREIGN KEY.

Hasta ahora trabajaste con tablas que ya existían. CREATE TABLE pertenece al lenguaje de definición de datos (DDL): comandos que definen la estructura de una base de datos, no sus datos. Una tabla bien diseñada guarda los datos de forma compacta, rechaza valores no válidos y mantiene coherentes las relaciones entre tablas.

Los ejemplos usan la sintaxis de MySQL y MariaDB. Las bases de datos de ejemplo de SQLtest son de solo lectura, así que practica estas sentencias en el playground, en una base sin datos de ejemplo.

Sintaxis de CREATE TABLE

CREATE TABLE table_name (
    column1 data_type constraints,
    column2 data_type constraints,
    table_constraints
);

Cada columna tiene un nombre, un tipo de datos y, opcionalmente, restricciones y parámetros. Las restricciones que abarcan varias columnas, como una clave primaria compuesta, se escriben después de las columnas.

Una primera tabla

CREATE TABLE students (
    student_id INT,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    birth_date DATE,
    created_at TIMESTAMP
);

Resultado: una tabla students vacía con cinco columnas.

Esta tabla funciona, pero acepta cualquier cosa: ids repetidos, estudiantes sin nombre. Las restricciones lo solucionan.

Elegir los tipos de datos

Elige el tipo más estrecho que sirva para los datos: ahorra espacio y rechaza valores incorrectos. Guarda el dinero en DECIMAL, no en FLOAT, que no puede representar con exactitud muchas fracciones decimales. Más detalles en la lección sobre tipos de datos.

Clave primaria y AUTO_INCREMENT

Una clave primaria identifica cada fila: sus valores son únicos y nunca NULL. Normalmente la base de datos genera una clave sustituta con AUTO_INCREMENT:

CREATE TABLE students (
    student_id INT AUTO_INCREMENT PRIMARY KEY,
    first_name VARCHAR(50) NOT NULL,
    last_name VARCHAR(50) NOT NULL
);

INSERT INTO students (first_name, last_name)
VALUES ('ANNA', 'LEE'), ('MARK', 'STONE');

SELECT * FROM students;

Resultado: dos estudiantes con student_id 1 y 2, generados automáticamente.

Otras bases de datos generan claves de otra manera: PostgreSQL usa GENERATED ALWAYS AS IDENTITY o SERIAL, SQL Server IDENTITY(1, 1).

NOT NULL, UNIQUE y DEFAULT

CREATE TABLE employees (
    employee_id INT AUTO_INCREMENT PRIMARY KEY,
    first_name VARCHAR(50) NOT NULL,
    last_name VARCHAR(50) NOT NULL,
    email VARCHAR(100) UNIQUE,
    hire_date DATE NOT NULL,
    salary DECIMAL(10, 2) NOT NULL DEFAULT 0.00,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

• NOT NULL: la columna debe tener un valor.
• UNIQUE: dos filas no pueden tener el mismo valor. Los valores NULL están permitidos y no cuentan como duplicados.
• DEFAULT: el valor que se usa cuando un INSERT no indica ninguno.

-- Error: Column 'hire_date' cannot be null
INSERT INTO employees (first_name, last_name, hire_date)
VALUES ('JOHN', 'DOE', NULL);

Restricciones CHECK

CHECK define una condición que debe cumplir cada fila:

CREATE TABLE products (
    product_id INT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(100) NOT NULL,
    price DECIMAL(10, 2) NOT NULL CHECK (price >= 0),
    discount_pct INT DEFAULT 0 CHECK (discount_pct BETWEEN 0 AND 90)
);

-- Error: Check constraint 'products_chk_1' is violated
INSERT INTO products (product_name, price) VALUES ('Broken', -5);

MySQL aplica CHECK desde la versión 8.0.16 y MariaDB desde la 10.2; las versiones antiguas de MySQL aceptaban la sintaxis pero ignoraban la condición.

Claves foráneas

Una clave foránea relaciona una columna con la clave primaria de otra tabla. A partir de ahí, la base de datos rechaza valores que no existen en la tabla referenciada:

CREATE TABLE departments (
    department_id INT AUTO_INCREMENT PRIMARY KEY,
    department_name VARCHAR(100) NOT NULL UNIQUE
);

CREATE TABLE staff (
    staff_id INT AUTO_INCREMENT PRIMARY KEY,
    full_name VARCHAR(100) NOT NULL,
    department_id INT NOT NULL,
    FOREIGN KEY (department_id) REFERENCES departments (department_id)
        ON DELETE RESTRICT
        ON UPDATE CASCADE
);

INSERT INTO departments (department_name) VALUES ('Sales');
INSERT INTO staff (full_name, department_id) VALUES ('ANNA LEE', 1);

-- Error: a foreign key constraint fails (el departamento 99 no existe)
INSERT INTO staff (full_name, department_id) VALUES ('MARK STONE', 99);

ON DELETE define qué pasa con las filas hijas cuando se elimina una fila referenciada:

ON UPDATE funciona igual cuando cambia la clave referenciada. En Sakila, la mayoría de las claves foráneas usan ON DELETE RESTRICT; por eso en la lección 8.3 no pudiste eliminar un cliente con alquileres.

IF NOT EXISTS

Crear una tabla que ya existe es un error. IF NOT EXISTS omite la creación en ese caso, lo que es útil en scripts que se ejecutan más de una vez:

CREATE TABLE IF NOT EXISTS departments (
    department_id INT AUTO_INCREMENT PRIMARY KEY,
    department_name VARCHAR(100) NOT NULL
);

Ten en cuenta que no compara estructuras: si ya existe una tabla con ese nombre pero con otras columnas, se queda como está.

Codificación del texto

Para las columnas de texto, MySQL y MariaDB permiten definir el juego de caracteres y la collation:

CREATE TABLE customers (
    customer_id INT AUTO_INCREMENT PRIMARY KEY,
    full_name VARCHAR(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NOT NULL
) DEFAULT CHARSET = utf8mb4;

utf8mb4 guarda cualquier carácter Unicode, incluidos los emoji; la collation define cómo se comparan y ordenan las cadenas. Desde MySQL 8.0, utf8mb4 es el valor por defecto.

Conclusiones clave:

• CREATE TABLE define columnas, tipos de datos y restricciones; la tabla nueva está vacía.
• Elige tipos de datos precisos; usa DECIMAL para el dinero.
• PRIMARY KEY identifica las filas; AUTO_INCREMENT genera los valores de la clave.
• NOT NULL, UNIQUE, DEFAULT y CHECK mantienen los datos válidos.
• FOREIGN KEY relaciona tablas; ON DELETE define qué pasa con las filas hijas.
• IF NOT EXISTS evita un error cuando la tabla ya existe.

Preguntas frecuentes

¿Cómo creo una tabla con clave primaria en SQL?

Agrega PRIMARY KEY a la columna clave: CREATE TABLE students (student_id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(50) NOT NULL);. Para una clave de varias columnas, escribe PRIMARY KEY (col1, col2) después de la lista de columnas.

¿Cuál es la diferencia entre PRIMARY KEY y UNIQUE?

Ambas prohíben duplicados. Una tabla tiene una sola clave primaria, y sus columnas no pueden ser NULL. Una tabla puede tener muchas restricciones UNIQUE, y estas admiten valores NULL.

¿Cómo agrego una clave foránea en CREATE TABLE?

Escribe FOREIGN KEY (column) REFERENCES other_table (key_column) después de las columnas, opcionalmente con las acciones ON DELETE y ON UPDATE. La columna referenciada debe ser clave primaria o única.