En mi día a día con SQL termino volviendo a las mismas construcciones: consultar, filtrar, relacionar tablas y resumir información. En mi publicación en Instagram reuní algunas de ellas. Aquí desarrollo esos ejemplos con un poco más de contexto.
Aunque usamos la palabra “comandos” para agruparlos, no todos son instrucciones independientes. WHERE y GROUP BY son cláusulas, CASE es una expresión y COUNT es una función de agregación. Lo importante es reconocer qué problema resuelve cada uno.
Los ejemplos utilizan datos ficticios de usuarios, pacientes y citas. No representan información de clientes ni una base de datos real. Para las consultas ampliadas de este artículo supongo que id identifica de forma única cada usuario o paciente.
SELECT y WHERE: consultar lo que necesito
SELECT permite elegir las columnas que quiero obtener. FROM indica de qué tabla salen y WHERE establece una condición para seleccionar las filas.
SELECT nombre, correo
FROM usuarios
WHERE estado = 1;
Esta consulta devuelve el nombre y el correo de los usuarios cuyo estado sea 1. Que ese valor signifique “activo” es una convención del ejemplo, no una regla de SQL.
Sin WHERE, la consulta no restringe las filas por estado. Prefiero dejar claras las columnas que necesito en lugar de usar SELECT * por costumbre: así también queda más explícito qué información espera recibir quien utiliza la consulta.
JOIN: relacionar información entre tablas
En mi publicación en Instagram usé pacientes y citas para mostrar una relación sencilla. Una cita tiene un paciente_id que corresponde al id de un paciente.
SELECT p.nombre, c.fecha
FROM pacientes p
INNER JOIN citas c
ON c.paciente_id = p.id;
p y c son alias: nombres cortos para referenciar las tablas. La condición de ON indica cómo se relacionan sus filas.
Con INNER JOIN aparecen las coincidencias entre ambas tablas. Si un paciente tiene dos citas, puede aparecer dos veces, una por cada cita. Eso no significa necesariamente que la consulta esté duplicando datos por error.
La diferencia con LEFT JOIN es útil: este conserva todas las filas de la tabla izquierda, aunque no encuentre coincidencia en la derecha. En ese caso, las columnas de la tabla derecha aparecen como NULL.
Datos ficticios · Ana tiene dos citas; Luis no tiene citas. Comparamos p.id = c.paciente_id.
| id | nombre |
|---|---|
| 1 | Ana |
| 2 | Luis |
| cita | paciente_id | fecha |
|---|---|---|
| A | 1 | 2026-01-12 |
| B | 1 | 2026-01-19 |
Resultado completo
Ana aparece dos veces: su id coincide con el paciente_id de ambas citas. Luis no aparece porque no tiene coincidencias.
Resultado 2 filas
| nombre | fecha |
|---|---|
| Las coincidencias aparecerán aquí. | |
| Ana | 2026-01-12 |
| Ana | 2026-01-19 |
Movimiento reducido activo: recorre la explicación con Anterior y Siguiente.
La secuencia ilustra las coincidencias y su resultado; no representa el orden interno de ejecución del motor SQL.
Antes de cambiar un JOIN, reviso qué relación espero encontrar: una coincidencia, varias o ninguna. Una condición incompleta puede combinar muchas más filas de las previstas.
CASE: interpretar un valor en el resultado
Cuando un código necesita una descripción legible, puedo usar CASE.
SELECT nombre,
CASE estado
WHEN 1 THEN 'Activo'
WHEN 0 THEN 'Inactivo'
END AS estado_desc
FROM usuarios;
En este ejemplo, 1 se presenta como Activo y 0 como Inactivo. Si no coincide ninguna condición y no escribo ELSE, el resultado de la expresión es NULL. Esa es también la lógica del fragmento de mi publicación en Instagram.
Esto cambia la representación del dato en la consulta, no el valor almacenado en la tabla. No equivale a actualizar los registros.
GROUP BY y COUNT: pasar de filas a totales
Si necesito saber cuántas citas hay por especialidad, agrupo las filas y cuento cada grupo.
SELECT especialidad,
COUNT(*) AS total
FROM citas
GROUP BY especialidad;
GROUP BY especialidad reúne las filas de cada especialidad. COUNT(*) cuenta las filas que componen cada grupo.
Conviene distinguirlo de COUNT(columna): esa forma cuenta los valores que no son NULL en la columna indicada. Si hay valores nulos, ambos conteos pueden ser diferentes. Documentación de MySQL sobre COUNT.
WHERE filtra filas antes de agrupar. Si después necesito filtrar los grupos por su total, corresponde utilizar HAVING. Son momentos distintos de la consulta.
EXISTS: comprobar si hay alguna coincidencia
A veces no necesito traer los datos de las citas. Solo quiero obtener los pacientes que tengan al menos una.
SELECT p.id, p.nombre
FROM pacientes p
WHERE EXISTS (
SELECT 1
FROM citas c
WHERE c.paciente_id = p.id
);
La subconsulta relaciona las citas con el paciente de la consulta exterior. EXISTS comprueba si esa subconsulta devuelve alguna fila; el 1 no es un conteo.
Frente al JOIN anterior, aquí no selecciono una fila por cada cita: selecciono cada fila de pacientes que cumpla la condición de existencia. La elección depende del resultado que necesito. No afirmo que una forma sea siempre más rápida que otra; eso requiere revisar el caso y el plan de ejecución.
Limitar filas: la misma intención, distinta sintaxis
La última comparación técnica de mi publicación en Instagram mostraba cómo limitar una consulta a diez registros en tres motores. En estos ejemplos añado ORDER BY id para definir qué filas quiero obtener. Supongo que id es único.
SQL Server
SELECT TOP (10) id, nombre
FROM usuarios
ORDER BY id;
TOP limita las filas devueltas. Sin un orden explícito no puedo dar por hecho cuáles serán esas diez. Documentación de Microsoft sobre TOP.
Oracle
SELECT id, nombre
FROM usuarios
ORDER BY id
FETCH FIRST 10 ROWS ONLY;
FETCH FIRST forma parte de la cláusula de limitación disponible desde Oracle Database 12c. Si trabajo con una versión anterior, necesito revisar una alternativa compatible. Referencia de SELECT de Oracle.
MySQL
SELECT id, nombre
FROM usuarios
ORDER BY id
LIMIT 10;
En MySQL, LIMIT establece el máximo de filas que devuelve la consulta. El orden sigue siendo una decisión separada. Referencia de SELECT de MySQL.
Una precaución adicional al modificar datos
Mi publicación original en Instagram trataba consultas de lectura; no incluía ejemplos de UPDATE ni DELETE. Añado esta nota porque cambiar información requiere otras comprobaciones.
Antes de una actualización o un borrado, reviso con una consulta de lectura qué filas cumplen la condición y cuántas son. Si falta el filtro que esperaba usar, puedo afectar toda la tabla. También compruebo el entorno y los permisos, y pruebo la operación con datos de desarrollo.
Cuando corresponde usar una transacción, necesito saber cómo funciona en ese motor y qué sucede con el autocommit. No doy por hecho que siempre podré deshacer una operación después de confirmarla. Para datos importantes, una transacción no reemplaza una estrategia de respaldo y recuperación. Documentación de MySQL sobre transacciones y autocommit.
Con qué me quedo
Estas construcciones siguen apareciendo en mis consultas porque resuelven necesidades concretas. Antes de combinarlas, intento precisar qué filas espero obtener y qué representa cada una. Esa comprobación suele ser más útil que empezar por una consulta más complicada.
Este artículo desarrolla mi publicación en Instagram el 20 de octubre de 2026. La fecha corresponde a la publicación original en redes.