Módulo 1.2 - SQL esencial

CREATE TABLE - Creación de estructuras

El comando CREATE TABLE forma parte de la DDL (Data Definition Language), el subconjunto de SQL responsable de definir la estructura de la base de datos. Con él creas tablas y defines columnas, tipos de datos y restricciones. Es el primer paso antes de cualquier operación con datos.

Tipos de datos más usados

TEXT: Texto de longitud variable. Ideal para nombres, correos electrónicos y descripciones.
INT / INTEGER: Números enteros. Ideales para cantidades, ID manuales y contadores.
NUMERIC(p,s): Número con precisión decimal. Ideal para valores monetarios. Ej.: NUMERIC(10,2) = hasta 10 dígitos, 2 decimales.
SERIAL: Entero autoincremental. Se usa como clave primaria automática.
TIMESTAMP: Fecha y hora. Ideal para registrar cuándo ocurrió algo.
BOOLEAN: Verdadero o falso. Ideal para indicadores (activo, verificado, etc.).

Constraints (restricciones)

Al crear una tabla, defines restricciones directamente en las columnas: PRIMARY KEY identifica el registro, NOT NULL impide los valores vacíos, UNIQUE impide los duplicados, REFERENCES crea una clave foránea y DEFAULT define un valor predeterminado.

CREATE TABLE cliente (
  id SERIAL PRIMARY KEY,
  nome TEXT NOT NULL,
  email TEXT UNIQUE
);

CREATE TABLE pedido (
  id SERIAL PRIMARY KEY,
  cliente_id INT REFERENCES cliente(id),
  total NUMERIC(10,2) NOT NULL,
  criado_em TIMESTAMP DEFAULT NOW()
);

INSERT y UPDATE - Manipulación de datos

Después de crear la estructura, necesitas llenar las tablas. El INSERT agrega nuevos registros y el UPDATE modifica registros existentes. Juntos con DELETE, forman las operaciones CRUD (Create, Read, Update, Delete): la base de cualquier aplicación.

Operaciones DML

INSERT INTO ... VALUES: Agrega una o más filas. Especificas las columnas y los valores correspondientes.
INSERT múltiple: Inserta varias filas en un solo comando separando los grupos de valores con comas.
UPDATE ... SET ... WHERE: Modifica los valores de las columnas en los registros que cumplen la condición WHERE.

Cuidado con UPDATE sin WHERE

Un UPDATE sin cláusula WHERE modifica todos los registros de la tabla. Incluye siempre WHERE para limitar el alcance. Antes de ejecutar un UPDATE, ejecuta un SELECT con el mismo WHERE para confirmar qué registros se verán afectados.

-- Inserindo um registro
INSERT INTO cliente (nome, email)
VALUES ('Ana Silva', 'ana@example.com');

-- Inserindo multiplos registros de uma vez
INSERT INTO cliente (nome, email)
VALUES ('Carlos Lima', 'carlos@example.com'),
       ('Maria Santos', 'maria@example.com');

-- Atualizando um registro especifico
UPDATE cliente
SET email = 'ana.silva@example.com'
WHERE id = 1;

SELECT y WHERE - Consultar datos

O SELECT es el comando más usado de SQL. Lee datos de las tablas y devuelve resultados filtrados, ordenados y limitados según lo que necesitas. La cláusula WHERE filtra qué filas deben aparecer en el resultado.

Anatomía de un SELECT

Columnas de SELECT: Qué columnas devolver. Usa * para todas (evítalo en producción).
FROM tabla: De qué tabla obtener los datos.
WHERE condición: Filtra filas. Acepta operadores como =, !=, >, <, LIKE, IS NULL, IN.
ORDER BY: Ordena el resultado. ASC (predeterminado) o DESC.
LIMIT: Limita el número de filas devueltas.

Operadores lógicos

Combina condiciones con AND (ambas deben ser verdaderas), OR (al menos una verdadera) y NOT (invierte la condición). Usa paréntesis para controlar la precedencia cuando combines AND y OR.

-- Selecionar colunas especificas com filtro
SELECT nome, email
FROM cliente
WHERE email IS NOT NULL;

-- Filtrar, ordenar e limitar
SELECT *
FROM pedido
WHERE total > 100
ORDER BY criado_em DESC
LIMIT 10;

-- Combinando condicoes com AND e operadores
SELECT nome
FROM cliente
WHERE email LIKE '%example.com'
  AND nome != 'Ana Silva';

JOINs - Combinación de tablas

En el modelo relacional, los datos se distribuyen en varias tablas. El JOIN combina filas de dos o más tablas según una condición de relación (generalmente clave foránea = clave primaria). Esto es lo que le da poder real a SQL.

Tipos de JOIN

INNER JOIN: Devuelve solo las filas que tienen correspondencia en ambas tablas. Si un cliente no tiene ningún pedido, no aparece.
LEFT JOIN: Devuelve todas las filas de la tabla de la izquierda, aunque no haya correspondencia en la derecha. Las columnas de la derecha quedan en NULL.
RIGHT JOIN: Inverso de LEFT. Todas las de la derecha, incluso sin correspondencia en la izquierda.
FULL JOIN: Devuelve todas las filas de ambos lados, con NULL donde no hay correspondencia.

Los alias hacen que todo sea más legible

Usa alias (nombres alternativos) para las tablas: FROM cliente c permite referenciar como c.nome en lugar de cliente.nome. Esto es especialmente útil cuando unes varias tablas y las columnas tienen nombres ambiguos.

-- INNER JOIN: clientes que TEM pedidos
SELECT c.nome, p.total, p.criado_em
FROM cliente c
INNER JOIN pedido p ON p.cliente_id = c.id
ORDER BY p.total DESC;

-- LEFT JOIN: TODOS os clientes, mesmo sem pedidos
-- COALESCE substitui NULL por 0
SELECT c.nome, COALESCE(SUM(p.total), 0) AS total_gasto
FROM cliente c
LEFT JOIN pedido p ON p.cliente_id = c.id
GROUP BY c.nome;

GROUP BY y agregaciones: resumir datos

Las funciones de agregación transforman muchas filas en un único resultado resumido. El GROUP BY agrupa las filas que comparten un valor en común, y las funciones de agregación operan sobre cada grupo. Así es como generas informes y estadísticas directamente en SQL.

Funciones de agregación

COUNT(*): Cuenta el número de filas del grupo.
SUM(columna): Suma los valores de la columna en el grupo.
AVG(columna): Calcula el promedio de los valores.
MIN(columna) / MAX(columna): Devuelve el valor mínimo/máximo.
HAVING: Filtra grupos después de la agregación (el WHERE de los grupos). A diferencia de WHERE, que filtra filas antes del agrupamiento.

WHERE vs HAVING

WHERE filtra filas individuales antes de la agrupación. HAVING filtra grupos después de la agregación. Ejemplo: "muestra clientes que gastaron más de R$500" usa HAVING, porque el total se calcula con SUM después de GROUP BY.

-- Resumo por cliente: contagem, soma e media
SELECT cliente_id,
       COUNT(*) AS num_pedidos,
       SUM(total) AS total,
       AVG(total) AS media
FROM pedido
GROUP BY cliente_id
HAVING SUM(total) > 500;

DELETE y seguridad: eliminar con cuidado

O DELETE elimina registros permanentemente. Es un comando potente y peligroso: sin WHERE, borra todo de la tabla. En la práctica, muchas aplicaciones prefieren el patrón soft delete, que marca el registro como eliminado en lugar de borrarlo realmente.

Estrategias de eliminación

Hard delete: DELETE FROM tabela WHERE ... Elimina permanentemente. Úsalo para datos temporales o cuando la normativa lo exija.
Soft delete: Agrega una columna deletado_em TIMESTAMP. En lugar de eliminar, haz un UPDATE que marque la fecha. Los datos permanecen en la base de datos para la auditoría.
TRUNCATE: Elimina TODOS los registros de una vez, más rápido que DELETE, pero sin WHERE. Se usa para limpiezas completas.

HAZLO

Siempre usa WHERE en DELETE
Ejecuta SELECT primero para confirmar
Prefiere el borrado lógico en producción
Usa transacciones (BEGIN/ROLLBACK)

NO HAGAS

DELETE sin WHERE
TRUNCATE en tablas de producción
Eliminar sin un backup reciente
Ignorar claves foráneas

-- SEGURO: sempre com WHERE
DELETE FROM pedido WHERE id = 5;

-- SOFT DELETE (recomendado)
-- Passo 1: adicione a coluna de controle
ALTER TABLE cliente ADD COLUMN deletado_em TIMESTAMP;

-- Passo 2: em vez de deletar, marque a data
UPDATE cliente SET deletado_em = NOW() WHERE id = 3;

-- Nas consultas, filtre os "deletados":
-- SELECT * FROM cliente WHERE deletado_em IS NULL;

SQL esencial