Las cláusulas básicas y su orden de ejecución

clausulas básicas de SQL

1. Qué es

Una consulta de SQL se arma con un puñado de cláusulas. Son pocas, siempre las mismas, y van en un orden fijo: no puedes poner el WHERE antes del FROM aunque quieras.

Este tema hace dos cosas y ninguna más: presentarte las cláusulas básicas y decirte en qué orden las ejecuta el motor — que no es el orden en que las escribes.

Es un tema de mapa, no de manos. Lleva una sola consulta, y está para recorrer el orden, no para aprender a escribirla: cada cláusula de la lista tiene después su propio tema, con sus ejemplos y sus errores.

2. Las cláusulas básicas

Cláusula	Qué hace	Se ve en
`SELECT`	Elige qué columnas salen, y les pone nombre	select-y-from
`FROM`	Dice de qué tabla salen las filas	select-y-from
`WHERE`	Descarta filas, una por una	where-y-operadores
`GROUP BY`	Junta las filas que sobrevivieron en grupos	group-by
`HAVING`	Descarta grupos	having-vs-where
`ORDER BY`	Ordena el resultado	ordenar-y-limitar

Esas seis son el esqueleto. Hay más —DISTINCT, LIMIT, los JOIN, las funciones de ventana—, y cada una tiene su sitio en el orden que viene abajo; ese sitio te lo señala su propio tema cuando llegues a él. La lista crece contigo.

3. El orden en que se escribe

Siempre este, sin excepción:

SELECT → FROM → WHERE → GROUP BY → HAVING → ORDER BY

Si cambias ese orden al escribir, la consulta ni siquiera arranca: es un error de sintaxis.

4. El orden en que se ejecuta

Otro distinto:

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY

#	Paso	Qué hace	Qué existe ya en ese momento
1	`FROM`	Trae las filas de la tabla	Las columnas de la tabla
2	`WHERE`	Descarta filas	Las columnas de la tabla
3	`GROUP BY`	Colapsa las filas en grupos	Las columnas de la tabla
4	`HAVING`	Descarta grupos	Los grupos y sus totales
5	`SELECT`	Calcula las columnas de salida y crea los nombres nuevos	Todo lo anterior
6	`ORDER BY`	Ordena lo que quedó	El resultado ya construido, nombres nuevos incluidos

SELECT es lo primero que escribes y lo penúltimo que ocurre. Ese desajuste es todo el tema. De él salen unas cuantas reglas que, si no conoces el orden, parecen caprichos del motor — y las irás encontrando cada una en su sitio.

Este orden es lógico, no físico: es el orden en que el motor está obligado a comportarse como si hiciera las cosas. Por dentro puede reorganizarlas mientras el resultado no cambie. Eso se ve al final del curso, en explain-y-explain-analyze.

5. Una consulta, paso a paso

La consulta más corta que usa las seis. Sobre orders, la tabla de pedidos de Northwind:

SELECT
    ship_country,
    sum(freight) AS flete
FROM
    orders
WHERE
    freight > 50
GROUP BY
    ship_country
HAVING
    sum(freight) > 1000
ORDER BY
    flete DESC;

En una línea: de los pedidos caros de enviar, en qué países se gastó más de 1000 en total de flete, del que más gastó al que menos.

No hace falta que entiendas GROUP BY ni HAVING todavía. Lee solo el recorrido:

Paso	Qué hace el motor aquí	Con qué se queda
1. `FROM orders`	Abre la tabla de pedidos y trae todas las filas	Pedidos
2. `WHERE freight > 50`	Va pedido por pedido y descarta los que costaron poco de enviar	Pedidos caros
3. `GROUP BY ship_country`	Junta los que quedan por país. A partir de aquí ya no hay pedidos sueltos: hay países	Países
4. `HAVING sum(freight) > 1000`	Suma el flete de cada país y descarta los que no llegan a 1000	Países con mucho gasto de envío
5. `SELECT ship_country, sum(freight) AS flete`	Recién ahora se decide qué se muestra, y aquí nace el nombre `flete`	Dos columnas
6. `ORDER BY flete DESC`	Ordena el resultado de mayor a menor	El resultado final

Y ahí está lo que hay que llevarse:

La primera línea que escribiste —el SELECT— fue la penúltima en ejecutarse. El motor no leyó tu consulta de arriba abajo. Empezó por el FROM, que está en la segunda línea.

Un detalle que confirma el orden: la última línea ordena por flete, que no es una columna de la tabla — es el nombre que se inventó en el paso 5. El ORDER BY puede usarlo porque va después.

Fíjate también en el paso 2 comparado con el 4: los dos descartan cosas, pero el WHERE tira pedidos y el HAVING tira países. Filtran cosas distintas porque ocurren en momentos distintos, antes y después de agrupar. Esa es toda la diferencia entre los dos, y tiene su propio tema (having-vs-where).

6. Lo que sí puedes usar ya: primero la tabla, después el filtro

De las seis, ahora mismo conoces dos: SELECT y FROM. La siguiente es WHERE, y es el tema que viene en el siguiente capítulo.

Quédate con los tres primeros pasos del recorrido de arriba, porque son la mitad del curso en una línea:

Primero traes la tabla entera (FROM), después descartas las filas que no quieres (WHERE), y solo al final se decide qué columnas se muestran (SELECT).

Por eso el WHERE es la cláusula que más pesa en el rendimiento: todo lo que descartes en el paso 2 es trabajo que los pasos 3, 4, 5 y 6 ya no tienen que hacer.

7. Cómo vuelve este tema a aparecer

No hace falta que memorices la tabla de la sección 4 hoy. Cada tema de una cláusula nueva trae una sección llamada «Dónde encaja en el orden de ejecución» que dice tres cosas: en qué paso entra esa cláusula, qué existe cuando le toca, y qué falla si se ignora.

8. Diferencias con SQL Server

Ninguna. El orden lógico es del estándar SQL, no del motor: es idéntico en PostgreSQL, SQL Server, MySQL, Oracle y BigQuery. Lo que cambia entre motores son cláusulas concretas —cómo se limita el número de filas, por ejemplo—, y eso se ve en el tema de cada una.