SQL · Lección 13 de 15

CREATE TABLE y tipos de datos

Hasta ahora usaste tablas que ya existían. Ahora aprendés a crearlas: elegir tipos de datos, definir restricciones (constraints) que protejan la integridad de los datos, y diseñar esquemas relacionales con claves primarias y foráneas.

80–100 min Prerrequisitos: SQL 12

Concepto teórico

CREATE TABLE — definir la estructura

CREATE TABLE clientes (
    id          INTEGER PRIMARY KEY,
    nombre      TEXT NOT NULL,
    cuit        TEXT UNIQUE NOT NULL,
    ciudad      TEXT DEFAULT 'Buenos Aires',
    score       INTEGER CHECK (score BETWEEN 0 AND 999),
    saldo       REAL DEFAULT 0,
    activo      INTEGER DEFAULT 1,
    fecha_alta  TEXT DEFAULT (date('now'))
);

Tipos de datos principales

Tipo SQLite	Equivalente PostgreSQL	Uso	Ejemplo
`INTEGER`	`INT / BIGINT`	Números enteros, IDs, conteos	42, -5, 0
`REAL`	`FLOAT / NUMERIC`	Decimales, saldos, tasas	3.14, 150000.50
`TEXT`	`VARCHAR / TEXT`	Strings, nombres, descripciones	'García', 'BsAs'
`BLOB`	`BYTEA`	Datos binarios (raro en análisis)	Imágenes, archivos
(no nativo)	`DATE / TIMESTAMP`	Fechas (en SQLite se usa TEXT)	'2025-03-15'
(no nativo)	`BOOLEAN`	Verdadero/Falso (SQLite usa INTEGER 0/1)	0, 1

Constraints — proteger los datos

Constraint	Qué hace	Ejemplo
`PRIMARY KEY`	Identificador único de cada fila (no nulo, no repetido)	`id INTEGER PRIMARY KEY`
`NOT NULL`	No permite valores nulos	`nombre TEXT NOT NULL`
`UNIQUE`	No permite duplicados	`cuit TEXT UNIQUE`
`DEFAULT`	Valor automático si no se especifica	`activo INTEGER DEFAULT 1`
`CHECK`	Validación de rango/condición	`CHECK (score BETWEEN 0 AND 999)`
`FOREIGN KEY`	Referencia a otra tabla	`FOREIGN KEY (cliente_id) REFERENCES clientes(id)`

PRIMARY KEY vs UNIQUE: una tabla tiene UNA sola Primary Key (típicamente el ID). Pero puede tener muchas columnas UNIQUE (CUIT, email). La PK no acepta NULL; UNIQUE sí acepta UN null (en la mayoría de los motores).

FOREIGN KEY — relaciones entre tablas

CREATE TABLE cuentas (
    id INTEGER PRIMARY KEY,
    cliente_id INTEGER NOT NULL,
    tipo TEXT NOT NULL,
    saldo REAL DEFAULT 0,
    FOREIGN KEY (cliente_id) REFERENCES clientes(id)
);

La FK garantiza que cliente_id en cuentas SIEMPRE corresponda a un id válido en clientes. Si intentás insertar un cliente_id que no existe, da error.

ALTER TABLE y DROP TABLE

-- Agregar columna
ALTER TABLE clientes ADD COLUMN email TEXT;

-- Renombrar tabla
ALTER TABLE clientes RENAME TO clientes_backup;

-- Eliminar tabla (IRREVERSIBLE)
DROP TABLE IF EXISTS clientes_temp;

DROP TABLE es IRREVERSIBLE. Elimina la tabla y TODOS sus datos. IF EXISTS evita error si la tabla no existe. En producción, NUNCA hagas DROP sin backup previo.

En el trabajo: como Data Analyst, rara vez creás tablas en producción (eso lo hace el equipo de Data Engineering). Pero sí creás tablas temporales para análisis, tablas de staging para ETL, y necesitás entender el esquema existente para escribir JOINs correctos. Saber leer un CREATE TABLE te dice todo sobre la estructura de datos.

Ejemplos explicados paso a paso

Ejemplo 1: CREATE TABLE con constraints

ejemplo_01_create.sqlSQL

-- Diseño completo de tabla clientes
CREATE TABLE clientes (
    id INTEGER PRIMARY KEY,
    nombre TEXT NOT NULL,
    cuit TEXT UNIQUE NOT NULL,
    ciudad TEXT DEFAULT 'Buenos Aires',
    score INTEGER CHECK (score BETWEEN 0 AND 999),
    saldo REAL DEFAULT 0,
    activo INTEGER DEFAULT 1
);

-- Insertar datos (ciudad y activo usan DEFAULT)
INSERT INTO clientes (id, nombre, cuit, score, saldo)
VALUES (1, 'García', '20-30123456-9', 720, 150000);

INSERT INTO clientes (id, nombre, cuit, score)
VALUES (2, 'López', '27-28765432-1', 680);  -- saldo = 0 (default)

INSERT INTO clientes (id, nombre, cuit, ciudad, score, saldo)
VALUES (3, 'Pérez', '20-40123456-7', 'Córdoba', 810, 890000);

SELECT * FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 2: FOREIGN KEY — relación clientes-cuentas

ejemplo_02_fk.sqlSQL

PRAGMA foreign_keys = ON;  -- Activar FK en SQLite

CREATE TABLE clientes (
    id INTEGER PRIMARY KEY,
    nombre TEXT NOT NULL
);

CREATE TABLE cuentas (
    id INTEGER PRIMARY KEY,
    cliente_id INTEGER NOT NULL,
    tipo TEXT NOT NULL CHECK (tipo IN ('CA$', 'CA USD', 'PF', 'CC$')),
    saldo REAL DEFAULT 0,
    FOREIGN KEY (cliente_id) REFERENCES clientes(id)
);

INSERT INTO clientes VALUES (1, 'García'), (2, 'López');
INSERT INTO cuentas VALUES (101, 1, 'CA$', 150000);
INSERT INTO cuentas VALUES (102, 1, 'PF', 500000);
INSERT INTO cuentas VALUES (103, 2, 'CA$', 320000);

-- Verificar con JOIN
SELECT c.nombre, cu.tipo, cu.saldo
FROM clientes c JOIN cuentas cu ON c.id = cu.cliente_id;

Hacé clic en ▶ Ejecutar

Ejemplo 3: Constraints en acción — rechazar datos inválidos

ejemplo_03_constraints.sqlSQL

CREATE TABLE clientes (
    id INTEGER PRIMARY KEY,
    nombre TEXT NOT NULL,
    cuit TEXT UNIQUE,
    score INTEGER CHECK (score BETWEEN 0 AND 999)
);

-- ✅ Datos válidos
INSERT INTO clientes VALUES (1, 'García', '20-30123456-9', 720);

-- ❌ Probá descomentando cada error:
-- INSERT INTO clientes VALUES (2, NULL, '27-28765432-1', 680);  -- NOT NULL violation
-- INSERT INTO clientes VALUES (3, 'Pérez', '20-30123456-9', 810);  -- UNIQUE violation (CUIT duplicado)
-- INSERT INTO clientes VALUES (4, 'Sosa', '23-25123456-3', 1500);  -- CHECK violation (score > 999)

SELECT * FROM clientes;

Hacé clic en ▶ Ejecutar

Ejemplo 4: Diseño multi-tabla con esquema completo

ejemplo_04_esquema.sqlSQL

-- Esquema bancario simplificado
CREATE TABLE sucursales (
    id INTEGER PRIMARY KEY,
    nombre TEXT NOT NULL UNIQUE,
    ciudad TEXT NOT NULL
);

CREATE TABLE clientes (
    id INTEGER PRIMARY KEY,
    nombre TEXT NOT NULL,
    sucursal_id INTEGER,
    score INTEGER DEFAULT 0,
    FOREIGN KEY (sucursal_id) REFERENCES sucursales(id)
);

CREATE TABLE cuentas (
    id INTEGER PRIMARY KEY,
    cliente_id INTEGER NOT NULL,
    tipo TEXT NOT NULL,
    saldo REAL DEFAULT 0,
    FOREIGN KEY (cliente_id) REFERENCES clientes(id)
);

-- Poblar
INSERT INTO sucursales VALUES (1, 'Centro', 'Buenos Aires'), (2, 'Norte', 'Córdoba');
INSERT INTO clientes VALUES (1, 'García', 1, 720), (2, 'López', 2, 680), (3, 'Pérez', 1, 810);
INSERT INTO cuentas VALUES (101, 1, 'CA$', 150000), (102, 2, 'CA$', 320000), (103, 3, 'CA$', 890000);

-- Consulta de 3 tablas
SELECT s.nombre AS sucursal, c.nombre AS cliente, cu.tipo, cu.saldo
FROM sucursales s
JOIN clientes c ON s.id = c.sucursal_id
JOIN cuentas cu ON c.id = cu.cliente_id
ORDER BY s.nombre, cu.saldo DESC;

Hacé clic en ▶ Ejecutar

Ejemplo 5: ALTER TABLE y CREATE TABLE AS (tabla desde query)

ejemplo_05_alter.sqlSQL

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, score INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García',720,150000),(2,'López',680,320000),(3,'Pérez',810,890000);

-- ALTER TABLE: agregar columna
ALTER TABLE clientes ADD COLUMN categoria TEXT;

-- Actualizar la nueva columna
UPDATE clientes SET categoria = CASE
    WHEN score >= 800 THEN 'Excelente'
    WHEN score >= 700 THEN 'Bueno'
    ELSE 'Regular'
END;

SELECT * FROM clientes;

-- CREATE TABLE AS: crear tabla desde un SELECT
CREATE TABLE resumen_ciudad AS
SELECT 'Buenos Aires' AS ciudad, COUNT(*) AS clientes, SUM(saldo) AS total
FROM clientes;  -- simplificado

SELECT * FROM resumen_ciudad;

Hacé clic en ▶ Ejecutar

Referencia rápida

Sentencia DDL	Acción
`CREATE TABLE t (cols)`	Crear tabla nueva
`CREATE TABLE t AS SELECT ...`	Crear tabla desde query
`ALTER TABLE t ADD COLUMN c tipo`	Agregar columna
`ALTER TABLE t RENAME TO nuevo`	Renombrar tabla
`DROP TABLE IF EXISTS t`	Eliminar tabla (irreversible)

Ejercicios

Nivel 1 · Básico

Ejercicio 1: CREATE TABLE simple

Creá una tabla productos con id (PK), nombre (NOT NULL), precio (REAL) y stock (INTEGER DEFAULT 0). Insertá 2 productos. Debe incluir Notebook.

ejercicio_01.sqlDebe incluir "Notebook"

-- Creá la tabla e insertá:


SELECT * FROM productos;

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: NOT NULL y DEFAULT

Creá tabla clientes donde nombre es NOT NULL y activo tiene DEFAULT 1. Insertá un cliente sin especificar activo. Debe incluir 1.

ejercicio_02.sqlDebe incluir "1" (activo default)

-- Creá tabla con NOT NULL y DEFAULT:


-- Insertá sin especificar activo:

SELECT * FROM clientes;

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: UNIQUE constraint

Creá tabla con CUIT UNIQUE. Insertá 2 clientes con CUITs distintos. Debe incluir UNIQUE (en el CREATE).

ejercicio_03.sqlDebe incluir un CUIT

-- Tabla con CUIT UNIQUE:


SELECT * FROM clientes;

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: CHECK constraint

Creá tabla con CHECK que score esté entre 0 y 999. Insertá un cliente válido. Debe incluir 720.

ejercicio_04.sqlDebe incluir "720"

-- Tabla con CHECK:


SELECT * FROM clientes;

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: FOREIGN KEY

Creá tablas clientes y cuentas con FK. Insertá datos y hacé un JOIN. Debe incluir CA$.

ejercicio_05.sqlDebe incluir "CA$"

-- Creá ambas tablas con FK:


-- Insertá y consultá con JOIN:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: ALTER TABLE

Creá tabla, después agregá columna email con ALTER TABLE. Debe incluir email.

ejercicio_06.sqlDebe incluir "email"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, score INTEGER);
INSERT INTO clientes VALUES (1, 'García', 720);

-- Agregá columna email:


-- Actualizá y verificá:
UPDATE clientes SET email = 'garcia@mail.com' WHERE id = 1;
SELECT * FROM clientes;

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: CREATE TABLE AS SELECT

Creá una tabla resumen a partir de un SELECT agrupado. Debe incluir Buenos Aires.

ejercicio_07.sqlDebe incluir "Buenos Aires"

CREATE TABLE clientes (id INTEGER, nombre TEXT, ciudad TEXT, saldo REAL);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',150000),(2,'López','Córdoba',320000),(3,'Pérez','Buenos Aires',890000);

-- CREATE TABLE AS:


SELECT * FROM resumen;

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Esquema de 3 tablas relacionadas

Diseñá: sucursales → clientes → cuentas con PKs y FKs. Insertá datos y verificá. Debe incluir Centro.

ejercicio_08.sqlDebe incluir "Centro"

-- Diseñá las 3 tablas:


-- Insertá datos y verificá con JOIN de 3 tablas:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: CHECK + tipo restringido con IN

Creá tabla donde tipo solo acepta 'compra', 'venta' o 'transferencia'. Debe incluir compra.

ejercicio_09.sqlDebe incluir "compra"

-- Tabla con CHECK + IN:


INSERT INTO transacciones VALUES (1, 'compra', 15000);
INSERT INTO transacciones VALUES (2, 'venta', 8000);
SELECT * FROM transacciones;

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Diseño completo + poblar + reporte

Diseñá un esquema bancario de 3 tablas con todos los constraints. Poblalo con datos. Generá un reporte con JOINs. Debe incluir ESQUEMA.

ejercicio_10.sqlDebe incluir "ESQUEMA"

-- Diseñá el ESQUEMA completo:
SELECT 'ESQUEMA BANCARIO' AS titulo;

Hacé clic en ▶ Ejecutar

Resumen y conexión

CREATE TABLE define estructura con tipos y constraints.
Constraints: PRIMARY KEY, NOT NULL, UNIQUE, DEFAULT, CHECK, FOREIGN KEY.
FOREIGN KEY conecta tablas garantizando integridad referencial.
ALTER TABLE agrega columnas. DROP TABLE elimina tablas (irreversible).
CREATE TABLE AS SELECT crea tablas desde consultas.

En la siguiente lección (14 · Caso práctico) vas a aplicar TODO lo aprendido en un análisis completo sobre un dataset multi-tabla.

Hecho con ❤️ por Rodri Gonzalez