Resumen ejecutivo

• Con seis comandos resolvés la mayor parte del trabajo diario en SQL: SELECT para consultar, INSERT para agregar, UPDATE para modificar, DELETE para borrar, JOIN para combinar tablas y GROUP BY para resumir.

• UPDATE y DELETE sin WHERE afectan todas las filas de la tabla: es el error más caro de quien empieza.

• Los JOIN más usados son INNER, LEFT, RIGHT y FULL; elegir mal cambia el resultado sin que aparezca ningún error.

• Cada comando de esta guía tiene una consulta y su resultado sobre la misma tabla de ejemplo, para que puedas practicar.

Cuando aprendés SQL, lo que más buscás no es teoría: es "¿cómo era el UPDATE?" o "¿qué JOIN tengo que usar acá?". El ángulo de esta guía es ser tu referencia por comando, con una tabla de ejemplo y el resultado de cada consulta. ¿Por qué ahora? Porque búsquedas como "update sql", "join sql", "insert into sql" y "delete sql" suman miles de consultas por mes y hasta ahora teníamos guías para aprender SQL, pero ninguna de referencia rápida. Si estás empezando de cero, primero mirá cómo aprender SQL desde cero para análisis de datos.

Las tablas de ejemplo

Vamos a usar dos tablas de una tienda online. Si necesitás repasar por qué los datos se organizan así, leé qué son las bases de datos relacionales.

clientes (id, nombre, ciudad):

• 1, Ana, Córdoba

• 2, Bruno, Rosario

• 3, Carla, Mendoza

• 4, Diego, (sin ciudad: NULL)

pedidos (id, cliente_id, monto):

• 101, 1, 5000

• 102, 1, 12000

• 103, 2, 8000

• 104, 5, 3000 (cliente que no existe en la tabla clientes)

SELECT: consultar datos

Consulta: SELECT nombre, ciudad FROM clientes WHERE ciudad IS NOT NULL ORDER BY nombre;

Resultado: Ana (Córdoba), Bruno (Rosario), Carla (Mendoza).

• WHERE filtra filas. Para valores vacíos se usa IS NULL o IS NOT NULL, nunca = NULL.

• ORDER BY ordena; agregá DESC para orden descendente.

• Evitá SELECT * en consultas que vas a reutilizar: pedí solo las columnas que necesitás.

INSERT INTO: agregar filas

Consulta: INSERT INTO clientes (id, nombre, ciudad) VALUES (5, 'Eva', 'Salta');

Resultado: la tabla clientes pasa a tener cinco filas. Ahora el pedido 104 ya tiene un cliente asociado.

Listá siempre las columnas explícitamente: si mañana alguien agrega una columna a la tabla, tu INSERT sigue funcionando.

UPDATE: modificar filas (siempre con WHERE)

Consulta: UPDATE clientes SET ciudad = 'Buenos Aires' WHERE id = 4;

Resultado: Diego pasa a tener ciudad "Buenos Aires". Las demás filas no cambian.

Si te olvidás del WHERE, el UPDATE modifica todas las filas. La documentación oficial de PostgreSQL lo define así: UPDATE cambia los valores de las columnas indicadas en todas las filas que cumplen la condición; sin condición, las cumplen todas. Un buen hábito es correr antes un SELECT con el mismo WHERE para ver qué filas vas a tocar.

DELETE: borrar filas (también con WHERE)

Consulta: DELETE FROM pedidos WHERE monto < 4000;

Resultado: se borra el pedido 104. Quedan 101, 102 y 103.

Igual que con UPDATE, un DELETE sin WHERE borra todo el contenido de la tabla, como indica la referencia de DELETE en PostgreSQL. En bases de producción, trabajá dentro de una transacción (BEGIN… COMMIT) para poder deshacer con ROLLBACK si algo sale mal.

JOIN: combinar tablas

Partimos de nuevo de las tablas originales (con el pedido 104 de un cliente inexistente y sin Eva). El JOIN une filas usando una condición, normalmente la clave que relaciona ambas tablas.

INNER JOIN: solo lo que coincide

Consulta: SELECT c.nombre, p.monto FROM clientes c INNER JOIN pedidos p ON p.cliente_id = c.id;

Resultado: Ana 5000, Ana 12000, Bruno 8000. Carla y Diego no aparecen porque no tienen pedidos; el pedido 104 tampoco, porque no tiene cliente.

LEFT JOIN: todo lo de la izquierda

Consulta: SELECT c.nombre, p.monto FROM clientes c LEFT JOIN pedidos p ON p.cliente_id = c.id;

Resultado: Ana 5000, Ana 12000, Bruno 8000, Carla NULL, Diego NULL. Ideal para encontrar clientes sin pedidos.

RIGHT JOIN y FULL JOIN

• RIGHT JOIN conserva todo lo de la tabla de la derecha: aparecería el pedido 104 con nombre NULL.

• FULL JOIN conserva todo de ambos lados: clientes sin pedidos y pedidos sin cliente.

Pensalo como dos círculos: INNER es la intersección; LEFT es el círculo izquierdo completo; RIGHT, el derecho; FULL, ambos. El tutorial de joins de PostgreSQL muestra estos casos con más ejemplos.

GROUP BY y COALESCE: resumir y completar vacíos

Consulta: SELECT c.nombre, COALESCE(SUM(p.monto), 0) AS total FROM clientes c LEFT JOIN pedidos p ON p.cliente_id = c.id GROUP BY c.nombre;

Resultado: Ana 17000, Bruno 8000, Carla 0, Diego 0.

• GROUP BY agrupa filas para aplicar funciones como SUM, COUNT o AVG.

• COALESCE devuelve el primer valor no nulo de su lista: acá reemplaza el NULL por 0. Está explicado en las funciones condicionales de PostgreSQL.

• Para filtrar después de agrupar, usá HAVING (por ejemplo, HAVING SUM(p.monto) > 10000).

Errores frecuentes con estos comandos

• UPDATE o DELETE sin WHERE.

• Comparar con = NULL en lugar de IS NULL.

• Usar INNER JOIN cuando necesitabas LEFT JOIN y "perder" filas sin darte cuenta.

• Olvidar columnas en el GROUP BY que sí aparecen en el SELECT.

Tenemos una lista más completa en los errores más comunes al aprender SQL.

Cursos recomendados de Coderhouse

Si querés practicar estos comandos con casos reales, el Curso de SQL es el paso directo. Si tu objetivo es trabajar como analista, la Carrera de Data Analytics combina SQL con Excel y Power BI, y el Curso de Data Analytics te enseña a convertir consultas en análisis.

CTA: creá las dos tablas de esta guía en una base gratuita (PostgreSQL, MySQL o SQLite), corré cada consulta y cambiá un detalle por vez para ver qué pasa. Y si querés hacerlo con mentoría, sumate al Curso de SQL de Coderhouse.

Preguntas frecuentes

¿Cuál es la diferencia entre DELETE y TRUNCATE? DELETE borra filas (todas o las que cumplan el WHERE); TRUNCATE vacía la tabla completa de forma más rápida y no admite WHERE.

¿Qué JOIN conviene usar por defecto? Depende de la pregunta. Si necesitás solo coincidencias, INNER; si no querés perder filas de la tabla principal, LEFT.

¿Estos comandos funcionan igual en MySQL, PostgreSQL y SQL Server? La base es la misma en todos; cambian detalles de sintaxis y funciones específicas de cada motor.

¿Cómo evito borrar datos por error? Corré antes un SELECT con el mismo WHERE, trabajá en transacciones y practicá en una base de prueba.