SQL Server

Orden de una consulta SQL: orden de escritura y orden lógico de procesamiento

Escribes SELECT primero, pero SQL Server empieza lógicamente por FROM. Aprende el orden lógico de procesamiento de una instrucción SELECT y lo que explica sobre alias, WHERE frente a HAVING y GROUP BY.

Por JaviPublicado 10 min de lecturaPrincipiante

En la lección anterior aprendiste las cláusulas de una instrucción SELECT y el orden en que hay que escribirlas. Ese orden empieza por SELECT. Es natural suponer que SQL Server lee la consulta del mismo modo: primero las columnas, después la tabla y luego el filtro.

No es así. Esta lección, el quinto paso de Fundamentos de SQL Server, muestra el orden en que las cláusulas se procesan lógicamente y por qué conocerlo convierte varios errores desconcertantes en algo evidente.

Dos órdenes para la misma consulta

El orden de escritura es la sintaxis: el orden en que las cláusulas deben aparecer en la consulta.

  1. SELECT
  2. FROM
  3. JOIN
  4. WHERE
  5. GROUP BY
  6. HAVING
  7. ORDER BY

El orden lógico de procesamiento es el orden en que las cláusulas se evalúan conceptualmente, cada una trabajando sobre el resultado de la anterior:

  1. FROM
  2. JOIN
  3. WHERE
  4. GROUP BY
  5. HAVING
  6. SELECT
  7. ORDER BY
  • Orden de escrituraCómo escribes la consulta
    1. 1SELECT
    2. 2FROM
    3. 3JOIN
    4. 4WHERE
    5. 5GROUP BY
    6. 6HAVING
    7. 7ORDER BY
  • Procesamiento lógicoCómo se evalúa el significado
    1. 1FROM
    2. 2JOIN
    3. 3WHERE
    4. 4GROUP BY
    5. 5HAVING
    6. 6SELECT
    7. 7ORDER BY
Orden de escritura frente a orden lógico de procesamiento. Las mismas cláusulas en otra secuencia. SELECT se escribe primero, pero se evalúa lógicamente casi al final, cuando las filas ya se han leído, filtrado y agrupado.

Lee el orden lógico como una historia. Primero SQL Server decide de dónde salen las filas (FROM, JOIN). Después descarta las filas que no cumplen (WHERE). Luego agrupa lo que queda (GROUP BY) y descarta los grupos que no cumplen (HAVING). Solo entonces construye las columnas de salida (SELECT) y, por último, las ordena (ORDER BY).

Un modelo lógico, no el plan de ejecución físico

Esta es la advertencia más importante de la lección. El orden lógico de procesamiento describe qué significa una consulta: qué nombres son visibles en cada cláusula y qué recibe cada paso. No describe lo que SQL Server hace físicamente, paso a paso, cuando ejecuta tu consulta.

El trabajo físico lo decide el optimizador de consultas, que puede leer las tablas en otro orden, aplicar filtros antes, usar índices o combinar pasos, siempre que el resultado sea el que dice el modelo lógico. La documentación de Microsoft hace la misma distinción: el orden real de ejecución física lo determina el procesador de consultas y puede variar. Ese es un tema para la parte de Rendimiento y optimización del sitio. Para escribir consultas correctas, el modelo lógico es el que debes tener en la cabeza.

Por qué un alias no funciona en WHERE

En la lección anterior le diste nombre a una columna calculada con AS. Supón que quieres encontrar a un cliente por ese nombre completo:

Consulta SQL: Por qué un alias no funciona en WHERET-SQL
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
WHERE FullName = 'Ana Torres';
T-SQL4 líneasVista de solo lectura. No está conectada a ninguna base de datos.

SQL Server responde «Invalid column name ‘FullName’.»

El orden lógico lo explica. WHERE se evalúa en el paso 3. El alias FullName se crea en SELECT, que es el paso 6. Cuando se ejecuta WHERE, FullName todavía no existe; los únicos nombres disponibles son las columnas de dbo.Customers.

Dos formas correctas de escribirlo:

Consulta SQL: Por qué un alias no funciona en WHERE (2)T-SQL
-- Filter on the real columns.
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
WHERE FirstName = 'Ana'
  AND LastName = 'Torres';

-- Or repeat the expression in WHERE.
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
WHERE FirstName + ' ' + LastName = 'Ana Torres';
T-SQL12 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Las dos devuelven a Ana Torres. La primera suele ser mejor: compara columnas simples, lo que es más fácil de leer y, como verás mucho más adelante en las lecciones de rendimiento, más fácil de aprovechar con índices.

Por qué ORDER BY sí puede usar un alias

Ahora ordena por ese mismo alias:

Consulta SQL: Por qué ORDER BY sí puede usar un aliasT-SQL
SELECT
    FirstName + ' ' + LastName AS FullName
FROM dbo.Customers
ORDER BY FullName;
T-SQL4 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Funciona. ORDER BY es el paso 7, después de que SELECT haya creado FullName, así que el alias es visible. Los diez clientes vuelven ordenados por nombre completo, de Ana Torres a Jonas Weber.

La misma regla explica por qué en SQL Server tampoco GROUP BY puede usar un alias de SELECT: GROUP BY es el paso 4, antes de que el alias exista.

WHERE frente a HAVING

Las dos cláusulas filtran, pero en momentos distintos del orden lógico y sobre cosas distintas.

  • WHERE (paso 3) filtra filas, antes de cualquier agrupación.
  • HAVING (paso 5) filtra grupos, después de que GROUP BY los haya construido.

Por eso esto falla:

Consulta SQL: WHERE frente a HAVINGT-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
WHERE COUNT(*) > 1
GROUP BY State;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

SQL Server indica que un agregado no puede aparecer en la cláusula WHERE. En el paso 3 todavía no hay grupos, así que no hay nada que contar por estado. Lleva la condición a HAVING, que se ejecuta cuando los grupos ya existen:

Consulta SQL: WHERE frente a HAVING (2)T-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
GROUP BY State
HAVING COUNT(*) > 1;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Devuelve FL con 3 y TX con 2.

Las dos pueden trabajar juntas. Una condición sobre filas individuales va en WHERE; una condición sobre el grupo va en HAVING:

Consulta SQL: WHERE frente a HAVING (3)T-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
WHERE CreatedDate >= '20250201'
GROUP BY State
HAVING COUNT(*) > 1;
T-SQL7 líneasVista de solo lectura. No está conectada a ninguna base de datos.

WHERE elimina primero a Ana Torres, la única clienta creada antes de febrero de 2025. Florida se queda con dos clientes y Texas con dos, así que ambos grupos siguen pasando HAVING. Filtrar filas pronto en WHERE es además lo natural: no tiene sentido agrupar filas que vas a descartar.

GROUP BY va antes que SELECT

Como GROUP BY (paso 4) se ejecuta antes que SELECT (paso 6), cuando SELECT construye la salida ya no hay clientes individuales, solo grupos. Esa es la razón de este error:

Consulta SQL: GROUP BY va antes que SELECTT-SQL
SELECT
    State,
    City,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
GROUP BY State;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

«Column ‘dbo.Customers.City’ is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.» El grupo de Florida contiene Miami, Orlando y Tampa. SELECT recibe un grupo y se le pide una ciudad, y no hay respuesta correcta. Agrupa también por ciudad (GROUP BY State, City, una fila por estado y ciudad) o resúmela con un agregado, como COUNT(DISTINCT City).

El ejemplo completo, en orden lógico

Toma la consulta completa de la lección anterior y síguela a través de los siete pasos lógicos, contando filas por el camino:

Consulta SQL: El ejemplo completo, en orden lógicoT-SQL
SELECT
    State,
    COUNT(*) AS CustomerCount
FROM dbo.Customers
WHERE State IS NOT NULL
GROUP BY State
HAVING COUNT(*) > 1
ORDER BY CustomerCount DESC;
T-SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.
  1. FROM lee dbo.Customers: 10 filas.
  2. JOIN: no hay ninguno, así que siguen siendo 10 filas.
  3. WHERE conserva las filas donde State IS NOT NULL: todos los clientes tienen estado, así que quedan 10 filas.
  4. GROUP BY convierte esas 10 filas en 7 grupos: FL con 3 clientes, TX con 2, y WA, CO, OR, MA e IL con 1 cada uno.
  5. HAVING conserva los grupos donde COUNT(*) > 1: quedan 2 grupos, FL y TX.
  6. SELECT construye la salida de cada grupo: el estado y su recuento, con el nombre CustomerCount.
  7. ORDER BY ordena por CustomerCount, de mayor a menor: FL (3) y después TX (2).

Dos detalles de esa consulta solo tienen sentido en orden lógico. HAVING repite COUNT(*) en lugar de usar el alias: HAVING CustomerCount > 1 falla con «Invalid column name ‘CustomerCount’», porque el paso 5 se ejecuta antes de que el paso 6 cree ese nombre. ORDER BY, en el paso 7, sí puede usar CustomerCount, porque para entonces ya existe. Cuando ves los pasos, la regla deja de ser algo que memorizar: un nombre solo se puede usar en un paso posterior al paso que lo crea.

Juntar los dos órdenes

Cuando una consulta falla o devuelve algo sorprendente, recórrela en orden lógico en lugar de leerla de arriba abajo:

  1. FROM / JOIN: ¿qué filas entran en juego?
  2. WHERE: ¿cuáles de esas filas sobreviven?
  3. GROUP BY: ¿cómo se agrupan las supervivientes?
  4. HAVING: ¿qué grupos sobreviven?
  5. SELECT: ¿qué se calcula y cómo se nombra para cada fila o grupo restante?
  6. ORDER BY: ¿en qué orden se devuelve el resultado?

Dos detalles más encajan en este modelo: DISTINCT se aplica justo después de SELECT, y TOP se aplica al final, después de ORDER BY. Por eso TOP con ORDER BY te da un conjunto de filas predecible.

Siguiente paso

Ya conoces dos órdenes: el que escribes y el que da significado a la consulta. La siguiente lección, Filtrar datos con WHERE en SQL Server, profundiza en el paso 3: comparaciones, AND y OR, IN, BETWEEN, LIKE y NULL.

El recorrido completo está en el centro Fundamentos de SQL Server.

Comprueba lo que has aprendido

2 preguntas rápidas

Pregunta 1 de 2¿Qué cláusula se escribe antes de FROM, pero se procesa lógicamente después?
Pregunta 2 de 2¿Por qué importa el orden lógico de la consulta?

Fundamentos de SQL Server

Lección 5 de 25

Continuar a la siguiente lección

Filtrar datos con WHERE en SQL Server

Continuar a la lección 6

Etiquetas

  • SQL Server
  • Fundamentos de SQL
  • SSMS
  • T-SQL