Cómo crear tu primera tabla en SQL

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Fundamentos de PostgreSQL

Primeros Pasos con Bases de Datos

Consultas y Manipulación de Datos

Relaciones y Modelado de Datos

Funciones, Operaciones y Vistas

Integraciones

Tomar examen

Cómo crear tu primera tabla en SQL

Resumen

Crear tablas en SQL es el primer paso para diseñar una base de datos funcional. Con la sentencia CREATE TABLE defines la estructura, los campos y las reglas que protegen la integridad de tus datos, algo clave si quieres construir aplicaciones que no fallen al insertar información.

¿Por qué salir de la herramienta de consultas para crear tablas?

Cuando trabajas en la creación de tablas conviene volver al espacio de trabajo por defecto. La razón es práctica: necesitas ver el árbol de visualización con todas las tablas existentes para no perderte.

En el ejemplo se parte de una base con 15 tablas y se busca llegar a 16 tras crear una nueva tabla llamada review, pensada para guardar las opiniones que los usuarios dejan sobre películas.

¿Qué hace la sentencia CREATE TABLE? Crea una nueva tabla dentro de tu base de datos. Defines su nombre, sus campos y los tipos de dato dentro de un paréntesis cerrado con punto y coma.

¿Cómo defino los campos de una nueva tabla en SQL?

La estructura de la tabla review arranca con un identificador único y se conecta con otras tablas existentes mediante llaves foráneas conceptuales. Cada campo cumple una función específica.

¿Qué campos lleva una tabla de reseñas?

review id: llave primaria de tipo serial, es decir, autoincremental. Así cada reseña tiene un número único sin que tengas que asignarlo manualmente.
film id: campo entero que referencia la película opinada. Su tipo se obtiene revisando la tabla film original.
customer id: campo entero que identifica al usuario que escribe la crítica, tomado de la tabla customer.
rating: entero que guarda la calificación del usuario.
description: texto con el contenido de la crítica.
last update: campo timestamp que registra fecha y hora de la inserción.

¿Cómo descubro el tipo de dato correcto sin un esquema impreso?

Un truco útil es comentar temporalmente la sentencia CREATE TABLE y ejecutar un SELECT all FROM film para ver cómo está definido film id. Al presionar F5 confirmas que es entero y replicas ese tipo en la nueva tabla.

Esta práctica evita errores de relación entre tablas y es común cuando no tienes un diagrama de base de datos a la mano.

¿Cómo valido que un campo solo acepte ciertos valores?

Aquí entra en juego una de las protecciones más útiles de SQL: la combinación del operador CHECK con BETWEEN. En el campo rating se aplica una regla que solo permite valores entre 1 y 5, replicando el clásico sistema de estrellas.

Esto aporta dos beneficios concretos:

Tu aplicación puede mandar un 10, 15 o 20 por error y la base de datos lo rechaza.
Previenes inserciones inválidas desde el origen, sin depender solo de validaciones del frontend o del API.

¿Para qué sirve CHECK con BETWEEN? Restringe los valores aceptados en un campo a un rango específico. Si alguien intenta insertar un número fuera del rango, la base de datos bloquea la operación.

¿Cómo registro automáticamente la fecha de inserción?

El campo last update usa el tipo timestamp, que combina fecha y hora. La clave está en configurarlo para que tome el valor del momento exacto en que se inserta el registro.

De esta manera, ni el usuario, ni el API, ni el servicio que conecte con la base de datos tienen que preocuparse por enviar esa fecha. La base de datos la genera sola.

Es el mismo patrón que ves en muchas tablas del esquema, donde last update indica cuándo fue modificado o creado un registro.

¿Cómo confirmo que mi tabla se creó correctamente?

Después de escribir la sentencia completa, presionas F5 para ejecutarla. El mensaje confirma que la consulta se realizó exitosamente, aunque el árbol del lado izquierdo no siempre se actualiza al instante.

El flujo de verificación es este:

Haz clic derecho en el árbol y selecciona refresh para ver la tabla nueva.
Cuenta las tablas: deberías pasar de 15 a 16.
Ejecuta SELECT all FROM review para visualizar los campos definidos.
Confirma que la tabla está vacía y lista para recibir datos con la sentencia INSERT.

Con la tabla creada, el siguiente paso natural es poblarla con registros usando INSERT. Prueba agregar varias reseñas combinando distintos film id y customer id para ver cómo se comporta la validación del rating. ¿Qué otros campos agregarías a tu tabla de reseñas? Cuéntame en los comentarios.

Comentarios

Luis Fernando Chacha Montenegro

Estudiante

Utilizar un tipo de dato INT para el campo rating y aplicar un CHECK (rating BETWEEN 1 AND 5) es una práctica común y eficiente en bases de datos. Usar INT permite almacenar el valor de manera compacta y realizar comparaciones rápidas. Aunque podrías considerar tipos de datos como SMALLINT, la diferencia en rendimiento es mínima para un rango tan pequeño. En general, INT es una buena elección por su balance entre eficiencia y simplicidad, especialmente en entornos donde la escala puede crecer.

Marcos Méndez

Estudiante

Hoy en día SERIAL está siendo desaconsejado en PostgreSQL moderno en favor de la forma estándar de SQL: GENERATED BY DEFAULT AS IDENTITY.

CREATE TABLE usuarios (
    id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY
);

Jesús David Fontalvo Mendoza

Estudiante

Hola, Aqui le dejo para ingresar valores a la tabla creada en la clase 'review' ->


-- Inserta datos de prueba en la tabla 'review'
INSERT INTO review (
    film_id,
    customer_id,
    raiting,
    review_date
)
SELECT
    -- Genera IDs de películas aleatorias entre 1 y 1000
    floor(random() * 1000 + 1)::INT AS film_id,
    
    -- Genera IDs de clientes aleatorias entre 1 y 600
    floor(random() * 600 + 1)::INT AS customer_id,
    
    -- Genera una calificación aleatoria entre 1 y 5
    floor(random() * 5 + 1)::INT AS raiting,
    
    -- Genera una fecha de revisión aleatoria en los últimos 2 años
    -- Asegura que la fecha esté en formato 'YYYY-MM-DD'
    (CURRENT_DATE - (floor(random() * 730) || ' days')::INTERVAL)::TIMESTAMP AS review_date
FROM
    -- Genera 1000 filas para el conjunto de datos de prueba
    generate_series(1, 1000);

	
-- Mostramos los valores generados 
SELECT * FROM review

Juan Diego

Estudiante

Existen varios tipos de fechas y horas en bases de datos, especialmente en PostgreSQL. Los más comunes son:

TIMESTAMP: Representa una fecha y hora sin zona horaria.
TIMESTAMPTZ: Similar al TIMESTAMP, pero incluye información de la zona horaria.
DATE: Solo la fecha, sin información de tiempo.
TIME: Solo la hora, sin información de fecha.
TIME WITH TIME ZONE: Hora con información de la zona horaria.

Cada tipo tiene su uso dependiendo de la necesidad de precisión y contexto en tu aplicación.

Abraham Patricio Muñoz Saez

Estudiante

CREATE TABLE review(

review_id SERIAL PRIMARY KEY,

film_id INT,

customer_id INT,

rating INT CHECK(rating BETWEEN 1 and 5),

review_text TEXT,

review_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP

);

Sandra Pérez Del Rosario

Estudiante

Dejo mi script que me ayudó entender mi pareja, que el estandar de SQL ya no se usa SERIAL y que por experiencias de el siempre debes poner la clausula CREATE TABLE IF NOT EXISTS ya que evita muchos errores, así el me dijo, ahora falta poner mas practica

CREATE TABLE IF NOT EXISTS review ( 
    review_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, 
    film_id INT NOT NULL REFERENCES film(film_id),
    customer_id INT NOT NULL REFERENCES customer(customer_id),
    rating INT NOT NULL CHECK (rating BETWEEN 1 AND 5),
    review_text TEXT,
    review_date TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);
-- Corremos un SELECT para corroborar que la tabla ya existe dentro de la base
SELECT * FROM review

También dejo estos dos scripts para poblar Datos a la tabla recién creada.

-- Inserta datos de prueba en la tabla 'review'
INSERT INTO review (
    film_id,
    customer_id,
    rating,
    review_date
)
SELECT
    -- Genera IDs de películas aleatorias entre 1 y 1000 (dvd_rental tiene 1000 películas)
    floor(random() * 1000 + 1)::INT AS film_id,
    
    -- Genera IDs de clientes aleatorias entre 1 y 599 (dvd_rental tiene 599 clientes)
    floor(random() * 599 + 1)::INT AS customer_id,
    
    -- Genera una calificación aleatoria entre 1 y 5
    floor(random() * 5 + 1)::INT AS rating,
    
    -- Genera una fecha de revisión aleatoria en los últimos 2 años
    (CURRENT_DATE - (floor(random() * 730) || ' days')::INTERVAL)::TIMESTAMP AS review_date
FROM
    -- Genera 1000 filas para el conjunto de datos de prueba
    generate_series(1, 1000);

-- Mostramos los valores generados
SELECT * FROM review;

Y como justo no pusimos nada a los comentarios, los llene así con un UPDATE

-- Actualizamos Tabla para poblar datos
UPDATE review
SET review_text = '¡Uff, joya cinematográfica! 10/10.' 
WHERE rating = 5;

-- A las de 3 y 4 estrellas las dejamos neutrales
UPDATE review 
SET review_text = 'Estuvo pasable, buena para dominguear.' 
WHERE rating IN (3, 4);

-- Y a las de 1 y 2 estrellas las destruimos
UPDATE review 
SET review_text = 'Pésima, me quedé dormido a la mitad.' 
WHERE rating IN (1, 2);

Espero que les sirva, y espero seguir aportando y aprendiendo de este mundo maravillos de los datos.

Jilber Ronaldy Vicos Pajuelo

Estudiante

Una recomendacion es que film_id y customer_id, ahora son solo números "sueltos". Para que SQL sea realmente potente, debes decirle que esos números pertenecen a otras tablas. se usa REFERENCES

CREATE TABLE review ( 
    review_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, 
    film_id INT NOT NULL REFERENCES film(film_id),
    customer_id INT NOT NULL REFERENCES customer(customer_id),
    rating INT NOT NULL CHECK (rating BETWEEN 1 AND 5),
    review_text TEXT,
    review_date TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

Gabriel Obregón

Estudiante

📌 Crear Tablas en SQL

🔷 1. ¿Qué es CREATE TABLE?

🛠 Comando para crear tablas en SQL.
Permite:

➡️ Definir columnas

➡️ Asignar claves primarias

➡️ Establecer restricciones

➡️ Relacionar tablas

🔶 2. Antes de empezar

✔️ Sal del entorno de consultas

✔️ Regresa al espacio principal

✔️ Mira las tablas existentes

👉 Te dará contexto visual y simplificará la administración.

🟩 3. Estructura básica

CREATE TABLE nombre_tabla (

campo1 tipo_dato,

campo2 tipo_dato,

...

);

📌 Tips de escritura:

↔️ Usa indentación
📋 Enumera campos claramente
🔑 Define la Primary Key (autoincremental recomendado)

🟪 4. Elementos esenciales

🔑 Primary Key: identificador único
🔗 Campos relacionados: enlazan tablas (ej: film_id)
⚖️ Restricciones: validan datos (CHECK)
🕒 Campos informativos: añaden contexto (timestamp)

🟥 5. Buenas prácticas

👀 Revisa tablas existentes: SELECT * FROM nombre_tabla;

📝 Usa comentarios para aclarar decisiones

🟦 6. Restricciones con CHECK

Ejemplo:

rating INT CHECK(rating BETWEEN 1 AND 5)

✔️ Evita valores fuera de rango

✔️ Mantiene la integridad de datos

🟨 7. Después de crear la tabla

🔄 Refresca la interfaz gráfica

👓 Verifica con: SELECT * FROM review;

✅ Confirma que la tabla y campos estén correctos

Carlos Valero

Estudiante

Dato opcional e incompletamente innecesario, es que tambien lo puedes hacer por la herramiente de pgAdmin usando su interfaz aunque es un poco mas engorroso y en lo personal tardas un poco mas

Por ejemplo para la linea

rating INT CHECK (rating BETWEEN 1 AND 5)

puedes hacerlo de la siguiente forma

En el modal Create - Table (o Table > Properties si ya existe), abre la pestaña: Constraints

Dentro de Constraints, busca Check constraints (en pgAdmin suele aparecer como sección/lista).

Clic en + para crear uno nuevo.

Completa:

En el campo name agrega un nombre por ejemplo: chk_rating_1_5

En check colocas lo siguiente

rating BETWEEN 1 AND 5

Y listo tienes el campo configurado

Juan Diego

Estudiante

El uso de DEFAULT en SQL se aplica al crear o modificar tablas. Permite establecer un valor predeterminado para una columna, que se utilizará si no se especifica otro valor al insertar datos. Por ejemplo, al crear la tabla review, podrías definir el campo rating con DEFAULT 3, de modo que si un nuevo registro no especifica un rating, automáticamente se le asignará 3. Esto es útil para asegurar consistencia en los datos y prevenir errores en inserciones.

Juan Diego

Estudiante

La sentencia CREATE TABLE IF NOT EXISTS se utiliza en SQL para crear una nueva tabla solo si esta no existe en la base de datos. Esto es útil para evitar errores que pueden ocurrir si se intenta crear una tabla que ya está presente. Al usar esta instrucción, garantizas que tu código sea más robusto y libre de errores, facilitando la gestión de datos en escenarios donde puede que no sepas si la tabla ya ha sido definida.

Esta práctica es especialmente importante en entornos colaborativos o de producción, donde múltiples usuarios pueden estar interactuando con la base de datos.

Juan Diego

Estudiante

El operador CHECK en SQL se utiliza para establecer una condición que los datos de una columna deben cumplir al momento de insertar o actualizar registros. Por ejemplo, en la clase se mencionó que se puede usar CHECK para limitar el valor de un campo de calificación a un rango entre 1 y 5. Esto ayuda a mantener la integridad de los datos y prevenir errores en las entradas.

Ronaldo Dylan Flores Soto

Estudiante

Mi aporte practicando con alter table.

CREATE TABLE review(

review_id SERIAL PRIMARY KEY,

film_id INT

--rating INT CHECK(rating BETWEEN 1 and 5),

--review_text TEXT,

--review_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

--FOREIGN KEY(film_id) REFERENCES film(film_id)

);

ALTER TABLE review

ADD CONSTRAINT fk_film_id

FOREIGN KEY(film_id) REFERENCES film(film_id);

ALTER TABLE review

ADD COLUMN rating INT CHECK(rating BETWEEN 1 and 5);

ALTER TABLE review

ADD COLUMN review_text TEXT;

ALTER TABLE review

ADD COLUMN review_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP;

-- Inserta datos de prueba en la tabla 'review'
INSERT INTO review (
    film_id,
    customer_id,
    raiting,
    review_date
)
SELECT
    -- Genera IDs de películas aleatorias entre 1 y 1000
    floor(random() * 1000 + 1)::INT AS film_id,
    
    -- Genera IDs de clientes aleatorias entre 1 y 600
    floor(random() * 600 + 1)::INT AS customer_id,
    
    -- Genera una calificación aleatoria entre 1 y 5
    floor(random() * 5 + 1)::INT AS raiting,
    
    -- Genera una fecha de revisión aleatoria en los últimos 2 años
    -- Asegura que la fecha esté en formato 'YYYY-MM-DD'
    (CURRENT_DATE - (floor(random() * 730) || ' days')::INTERVAL)::TIMESTAMP AS review_date
FROM
    -- Genera 1000 filas para el conjunto de datos de prueba
    generate_series(1, 1000);

	
-- Mostramos los valores generados 
SELECT * FROM review

CREATE TABLE IF NOT EXISTS review ( 
    review_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, 
    film_id INT NOT NULL REFERENCES film(film_id),
    customer_id INT NOT NULL REFERENCES customer(customer_id),
    rating INT NOT NULL CHECK (rating BETWEEN 1 AND 5),
    review_text TEXT,
    review_date TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);
-- Corremos un SELECT para corroborar que la tabla ya existe dentro de la base
SELECT * FROM review

-- Inserta datos de prueba en la tabla 'review'
INSERT INTO review (
    film_id,
    customer_id,
    rating,
    review_date
)
SELECT
    -- Genera IDs de películas aleatorias entre 1 y 1000 (dvd_rental tiene 1000 películas)
    floor(random() * 1000 + 1)::INT AS film_id,
    
    -- Genera IDs de clientes aleatorias entre 1 y 599 (dvd_rental tiene 599 clientes)
    floor(random() * 599 + 1)::INT AS customer_id,
    
    -- Genera una calificación aleatoria entre 1 y 5
    floor(random() * 5 + 1)::INT AS rating,
    
    -- Genera una fecha de revisión aleatoria en los últimos 2 años
    (CURRENT_DATE - (floor(random() * 730) || ' days')::INTERVAL)::TIMESTAMP AS review_date
FROM
    -- Genera 1000 filas para el conjunto de datos de prueba
    generate_series(1, 1000);

-- Mostramos los valores generados
SELECT * FROM review;

-- Actualizamos Tabla para poblar datos
UPDATE review
SET review_text = '¡Uff, joya cinematográfica! 10/10.' 
WHERE rating = 5;

-- A las de 3 y 4 estrellas las dejamos neutrales
UPDATE review 
SET review_text = 'Estuvo pasable, buena para dominguear.' 
WHERE rating IN (3, 4);

-- Y a las de 1 y 2 estrellas las destruimos
UPDATE review 
SET review_text = 'Pésima, me quedé dormido a la mitad.' 
WHERE rating IN (1, 2);

CREATE TABLE review ( 
    review_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, 
    film_id INT NOT NULL REFERENCES film(film_id),
    customer_id INT NOT NULL REFERENCES customer(customer_id),
    rating INT NOT NULL CHECK (rating BETWEEN 1 AND 5),
    review_text TEXT,
    review_date TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

Fundamentos de PostgreSQL

Por qué PostgreSQL supera a otras bases de datos

Instalación y configuración de PostgreSQL en Ubuntu

Instala PgAdmin y conéctalo a PostgreSQL

Qué es SQL y estructura básica del lenguaje

Primeros Pasos con Bases de Datos

Usuarios y permisos mínimos en pgAdmin

Cómo crear tablas en PostgreSQL con pgAdmin

Importar dvdrental en pgAdmin paso a paso

Consultas y Manipulación de Datos

Tu primera consulta SQL con SELECT y WHERE

ORDER BY y BETWEEN para filtrar datos en SQL

LIKE e IN para filtrar datos en SQL

Cómo insertar registros con INSERT INTO

Uso de GROUP BY y HAVING en consultas SQL

Relaciones y Modelado de Datos

Exportar consultas SQL a CSV y PNG en pgAdmin