Consultas SQL: cómo se construye y se lee un SELECT
Una consulta es una pregunta escrita en SQL, el idioma con que se le piden datos a una base de datos. Empieza con SELECT (qué columnas) y FROM (de qué tabla), y puede filtrar filas, ordenarlas, quitar las repetidas y limitar cuántas salen. Se escribe en un orden, pero la base la resuelve en otro: primero la tabla y el filtro, después las columnas.
Última actualización: 2026-11-17
Contenido de esta página
- ¿Qué es una consulta SQL?
- La tabla de ejemplo: los pedidos de una tienda de café
- SELECT y FROM: qué columnas y de qué tabla
- WHERE: cómo filtrar filas con condiciones
- ORDER BY: cómo ordenar el resultado de una consulta
- LIMIT, TOP y FETCH FIRST: cómo limitar el número de filas según el motor
- DISTINCT: cómo quitar filas repetidas
- ¿En qué orden se ejecuta una consulta SQL?
- Alias de columna y de tabla: nombres cortos con AS
- Tipos de consultas SQL: de una tabla, de varias, agregadas y anidadas
- Leer una consulta en el orden en que la lee la base
Escena compuesta, con nombre ficticio. Daniela vende por internet el café de la finca de su familia, en Santander. Guarda los pedidos en una base de datos pequeña y aprendió a consultarla en su portátil con SQLite. Es un motor de bases de datos, el programa que guarda los datos y responde las preguntas, y no necesita un servidor aparte [14].
Una noche escribe una consulta para ver los pedidos con un precio por unidad alto. Calcula ese precio en la primera línea, le pone un nombre corto, precio_unidad, y en la línea siguiente filtra por ese nombre. Funciona a la primera.
Meses después el negocio crece y un contratista pasa los datos a PostgreSQL, otro motor, instalado en un servidor. Daniela pega la misma consulta y PostgreSQL la rechaza con un error. Nada cambió en los datos. Cambió quién leía la consulta.
El nombre corto se crea en la parte SELECT, y PostgreSQL resuelve el filtro antes de llegar a ella [4]. SQLite fue permisivo esa noche; PostgreSQL aplicó la regla.
Lo que Daniela escribió tiene nombre: una consulta SQL, escrita en el idioma estándar de las bases de datos. Se arma con piezas fijas, y esas piezas se escriben en un orden pero se procesan en otro.

¿Qué es una consulta SQL?
Con una consulta, usted le pide a una base de datos un pedazo de su información. Se escribe en SQL, el lenguaje con que se le piden datos a las bases de datos relacionales, las que guardan todo en tablas de filas y columnas. La respuesta siempre es otra tabla, aunque tenga una sola fila.
La orden que hace las preguntas es SELECT (seleccionar). El manual de PostgreSQL la define como la orden que recupera filas «de cero o más tablas» [4]. Cada parte de la orden se llama cláusula: un trozo que empieza con una palabra fija y cumple una sola tarea.
No es una orden sencilla. El equipo de SQLite lo dice sin rodeos en su manual: «The SELECT statement is the most complicated command in the SQL language» [10]. Es decir, SELECT es la orden más complicada del lenguaje.
Esta página desarma esa orden pieza por pieza. Qué es SQL en general y de dónde viene está en la guía de SQL. Las órdenes que crean tablas o cambian filas pertenecen a otra familia, explicada en lenguajes de bases de datos.
La tabla de ejemplo: los pedidos de una tienda de café
Todos los ejemplos corren sobre una sola tabla de doce pedidos. Los datos son sintéticos: ciudades reales, pero pedidos, cantidades y valores inventados para esta página. Las dos primeras órdenes solo preparan la tabla.
-- Datos sintéticos: pedidos de una tienda de café en línea (todo inventado).
CREATE TABLE pedido (
id_pedido INTEGER PRIMARY KEY,
ciudad TEXT,
departamento TEXT,
producto TEXT,
unidades INTEGER,
valor INTEGER, -- en pesos
fecha TEXT -- AAAA-MM-DD
);
INSERT INTO pedido VALUES
(1, 'Bucaramanga', 'Santander', 'Grano 500 g', 2, 64000, '2026-10-02'),
(2, 'Floridablanca','Santander', 'Molido 250 g', 1, 18000, '2026-10-03'),
(3, 'Tunja', 'Boyacá', 'Grano 500 g', 4, 128000, '2026-10-05'),
(4, 'Bogotá', 'Bogotá D. C.', 'Molido 500 g', 3, 99000, '2026-10-08'),
(5, 'San Gil', 'Santander', 'Molido 500 g', 1, 33000, '2026-10-11'),
(6, 'Sogamoso', 'Boyacá', 'Molido 250 g', 6, 108000, '2026-10-14'),
(7, 'Bucaramanga', 'Santander', 'Molido 250 g', 2, 36000, '2026-10-17'),
(8, 'Medellín', 'Antioquia', 'Grano 500 g', 5, 160000, '2026-10-20'),
(9, 'Cúcuta', 'Norte de Santander', 'Grano 500 g', 2, 64000, '2026-10-24'),
(10,'Girón', 'Santander', 'Grano 500 g', 3, 96000, '2026-10-27'),
(11,'Bogotá', 'Bogotá D. C.', 'Grano 500 g', 1, 32000, '2026-10-30'),
(12,'Santa Marta', 'Magdalena', 'Molido 500 g', 2, 66000, '2026-11-02');
Las corrí con el módulo sqlite3 de Python, que da acceso a SQLite sin instalar un servidor aparte [14]. La versión fue SQLite 3.53.1. Si quiere practicar con tablas más grandes, hay opciones gratuitas en bases de datos para practicar.
SELECT y FROM: qué columnas y de qué tabla
SELECT dice qué columnas quiere ver y FROM (desde) dice de qué tabla salen. Son las dos piezas de casi toda consulta. Entre SELECT y FROM va la lista de columnas, separadas por comas, y PostgreSQL la llama así: la lista de selección [4].
-- Tres columnas de la tabla pedido, en el orden en que se piden.
SELECT ciudad, producto, valor
FROM pedido;
El resultado trae las doce filas con esas tres columnas, de Bucaramanga con 64.000 pesos a Santa Marta con 66.000. Las demás columnas existen, pero no se piden.
El asterisco es un atajo: SELECT * trae todas las columnas [4]. Sirve para mirar una tabla por primera vez. En un reporte conviene nombrar cada columna, porque así la consulta dice exactamente qué entrega.
FROM, incluso, puede faltar. En SQLite, una consulta sin FROM trabaja sobre una sola fila sin columnas [10], así que SELECT 64000 / 2 devuelve 32000. Sirve como calculadora, no para leer datos.
WHERE: cómo filtrar filas con condiciones
WHERE (donde) deja pasar solo las filas que cumplen una condición. PostgreSQL lo describe así: las filas que no la cumplen se eliminan del resultado [4]. La condición se arma con operadores, los signos que comparan o combinan valores.
Operadores de comparación: igual, distinto, mayor y menor
Los seis básicos son = (igual), <> (distinto), < (menor), > (mayor), <= (menor o igual) y >= (mayor o igual) [7]. Con ellos se compara una columna contra un valor:
-- Pedidos de 100.000 pesos o más.
SELECT id_pedido, ciudad, valor
FROM pedido
WHERE valor >= 100000;
Salen tres pedidos: Tunja con 128.000, Sogamoso con 108.000 y Medellín con 160.000. Los textos y las fechas van entre comillas simples, como en departamento = ‘Santander’.
AND, OR y NOT: por qué los paréntesis cambian el resultado
Los operadores lógicos juntan condiciones. AND (y) exige que se cumplan las dos, OR (o) se conforma con una y NOT (no) invierte la condición [9]. La trampa está en la precedencia, es decir, en cuál se resuelve primero: en la tabla de PostgreSQL, AND va antes que OR [9].
Suponga que Daniela quiere los pedidos de Santander o de Boyacá por más de 100.000 pesos. Lo escribe como lo diría en voz alta:
-- Sin paréntesis: AND se resuelve primero.
SELECT id_pedido, departamento, valor
FROM pedido
WHERE departamento = 'Santander'
OR departamento = 'Boyacá' AND valor > 100000;
-- Con paréntesis: primero el OR, después el filtro de valor.
SELECT id_pedido, departamento, valor
FROM pedido
WHERE (departamento = 'Santander' OR departamento = 'Boyacá')
AND valor > 100000;
La primera versión devuelve siete filas. Trae todos los pedidos de Santander, incluido uno de 18.000 pesos, y solo los de Boyacá superan el filtro de valor. La segunda devuelve dos, los de Tunja y Sogamoso, que es lo que se quería.
Cuando mezcle AND y OR, ponga paréntesis aunque crea que no hacen falta. El manual de PostgreSQL pide agregarlos cuando una expresión deba leerse distinto de lo que dictan las reglas de precedencia [9].
IN, BETWEEN y LIKE: listas, rangos y patrones
Tres operadores ahorran escribir muchas comparaciones seguidas. Cada uno responde a una forma distinta de preguntar.
| Operador | Qué pregunta | Ejemplo sobre la tabla | Filas |
|---|---|---|---|
| IN (en) | ¿El valor está en esta lista? | departamento IN (‘Boyacá’, ‘Antioquia’) | 3: Tunja, Sogamoso y Medellín |
| BETWEEN (entre) | ¿El valor está en este rango, con los extremos incluidos? | fecha BETWEEN ‘2026-10-01’ AND ‘2026-10-14’ | 6: los pedidos 1 a 6 |
| LIKE (como) | ¿El texto sigue este patrón? | ciudad LIKE ‘San%’ | 2: San Gil y Santa Marta |
IN (en) compara contra una lista de valores escrita a mano [11]. BETWEEN (entre) incluye los dos extremos [7]: el pedido de Sogamoso, del 14 de octubre, entra. SQLite lo define como equivalente a un mayor o igual más un menor o igual [11].
LIKE (como) usa dos comodines, caracteres que reemplazan a otros. El signo % vale por cualquier cantidad de caracteres, incluso ninguno, y el guion bajo vale por uno solo [8]. Por eso ‘San%’ atrapó también a Santa Marta. Con ‘San %’, con un espacio, sale solo San Gil.
Las mayúsculas cambian según el motor. En SQLite, LIKE no distingue mayúsculas en las letras del alfabeto inglés, pero sí en las letras con tilde y en la eñe [11]. En la prueba, comparar «Tunja» con su versión en mayúsculas dio verdadero; con «Boyacá», dio falso. Para un país de tildes, ese detalle importa. PostgreSQL ofrece ILIKE, un LIKE que no distingue mayúsculas, una extensión que no está en el estándar [8].
ORDER BY: cómo ordenar el resultado de una consulta
ORDER BY (ordenar por) acomoda las filas según una o varias columnas. ASC (ascendente) las pone de menor a mayor y es el valor por defecto; DESC (descendente), de mayor a menor [4] [10]. Si hay empate en la primera columna, decide la segunda:
-- Del pedido más caro al más barato; si empatan, por ciudad.
SELECT ciudad, valor
FROM pedido
ORDER BY valor DESC, ciudad ASC;
Medellín encabeza con 160.000 pesos y Floridablanca cierra con 18.000. Bucaramanga y Cúcuta empatan en 64.000, y la segunda columna pone primero a Bucaramanga.
Sin ORDER BY no hay orden prometido. PostgreSQL entrega las filas en el orden que le resulte más rápido [4]. Microsoft, que fabrica el motor SQL Server, advierte que el orden no está garantizado [2]. Que hoy salgan en el orden en que se guardaron es una casualidad, no una regla.
Los valores vacíos, que SQL marca como NULL, tampoco caen en el mismo sitio en todos los motores. SQLite y SQL Server los tratan como los más pequeños, así que salen de primeros en un orden ascendente [10] [2]. PostgreSQL, en cambio, los pone de últimos en ese mismo orden [4].
LIMIT, TOP y FETCH FIRST: cómo limitar el número de filas según el motor
Para pedir solo las primeras filas hay tres formas de escribirlo, y cada motor acepta unas y no otras. La tabla compara cuatro: PostgreSQL, MySQL, SQLite (el de los ejemplos) y SQL Server. Las tres hacen lo mismo: cortan el resultado después de un número de filas. Las tres necesitan un ORDER BY para que «las primeras» signifique algo [4] [3].
| Motor (documentación consultada) | Cómo se escribe | Detalle propio |
|---|---|---|
| PostgreSQL 18 | LIMIT 3, o FETCH FIRST 3 ROWS ONLY | Acepta las dos. Llama a LIMIT sintaxis propia, también usada por MySQL, y a FETCH FIRST la forma que introdujo el estándar SQL en su versión de 2008 [4] |
| MySQL 8.4 | LIMIT 3 | Su gramática del SELECT trae LIMIT. Acepta LIMIT 3 OFFSET 3 por compatibilidad con PostgreSQL [12] |
| SQLite 3.53.1 | LIMIT 3 | En la prueba de esta página, TOP y FETCH FIRST dieron error de sintaxis. Su manual desaconseja la forma con coma, LIMIT 3, 3 [10] |
| SQL Server (Microsoft) | SELECT TOP (3) … | TOP va junto a SELECT. Para paginar, Microsoft recomienda OFFSET y FETCH dentro del ORDER BY, disponibles desde SQL Server 2012 [3] [2] |
En SQLite el ejemplo queda así:
-- Los tres pedidos más caros.
SELECT ciudad, valor
FROM pedido
ORDER BY valor DESC
LIMIT 3;
-- Los tres siguientes: salta tres filas y trae tres.
SELECT ciudad, valor
FROM pedido
ORDER BY valor DESC
LIMIT 3 OFFSET 3;
La primera devuelve Medellín, Tunja y Sogamoso. La segunda, Bogotá con 99.000, Girón con 96.000 y Santa Marta con 66.000. OFFSET (desplazamiento) dice cuántas filas saltar antes de empezar a contar [4].
En SQL Server, la misma pregunta se escribe con TOP o con la forma estándar:
-- SQL Server: con TOP.
SELECT TOP (3) ciudad, valor FROM pedido ORDER BY valor DESC;
-- SQL Server y PostgreSQL: forma estándar (SQL Server exige el OFFSET).
SELECT ciudad, valor FROM pedido
ORDER BY valor DESC
OFFSET 0 ROWS FETCH NEXT 3 ROWS ONLY;
Estas dos no las ejecuté: SQLite no las acepta y no tenía un SQL Server a mano. La sintaxis sale de la gramática oficial de Microsoft, donde FETCH (traer) va dentro de un bloque que empieza con OFFSET [2]. Microsoft también advierte que TOP y OFFSET con FETCH no se combinan en una misma consulta [3].
DISTINCT: cómo quitar filas repetidas
DISTINCT (distinto) borra del resultado las filas repetidas. Se escribe justo después de SELECT. Lo contrario es ALL (todos), que conserva los repetidos y es el comportamiento por defecto [5].
-- Sin DISTINCT salen 12 filas, con Santander repetido cinco veces.
SELECT DISTINCT departamento
FROM pedido;
Con DISTINCT salen seis departamentos: Santander, Boyacá, Bogotá D. C., Antioquia, Norte de Santander y Magdalena.
La comparación es por fila completa, no por columna. Dos filas cuentan como distintas si se diferencian en al menos un valor [5]. Por eso SELECT DISTINCT departamento, producto devuelve diez filas: Santander aparece tres veces, una por cada producto que pidió. Los valores vacíos, además, cuentan como iguales entre sí para este fin [5] [10].
Una advertencia práctica. DISTINCT tapa los duplicados, pero no explica de dónde salieron. Si una consulta trae repetidos que no esperaba, antes de borrarlos con DISTINCT conviene averiguar por qué aparecieron.
¿En qué orden se ejecuta una consulta SQL?
Una consulta se escribe empezando por SELECT, pero la base de datos no la procesa en ese orden. Primero arma la tabla de origen y la filtra; las columnas del SELECT se calculan casi al final. Microsoft llama a esto el orden lógico de procesamiento: el orden en que cada cláusula queda disponible para las siguientes [1].
| Paso | Orden en que se procesa | Qué hace | Lugar en que se escribe |
|---|---|---|---|
| 1 | FROM (y sus JOIN) | Arma la tabla de origen | 2.º |
| 2 | WHERE | Descarta las filas que no cumplen la condición | 3.º |
| 3 | GROUP BY | Junta las filas en grupos | 4.º |
| 4 | HAVING | Descarta grupos | 5.º |
| 5 | SELECT | Calcula las columnas y sus alias | 1.º |
| 6 | DISTINCT | Quita filas repetidas | 1.º, junto a SELECT |
| 7 | ORDER BY | Ordena | 6.º |
| 8 | LIMIT, TOP o FETCH | Corta el número de filas | 7.º (TOP va junto a SELECT) |
La secuencia de la tabla resume la de Microsoft para SQL Server, que termina en TOP [1]. La descripción de PostgreSQL sigue la misma ruta, de FROM a LIMIT [4], y SQLite cuenta la versión corta: FROM, WHERE, agrupación y columnas, y DISTINCT [10]. Agrupar con GROUP BY (agrupar por) y filtrar grupos con HAVING (que tenga) es tema de la guía de funciones de agregación, aún no publicada.
Esta consulta usa casi todas las piezas a la vez:
-- Se escribe de arriba abajo; se procesa FROM → WHERE → SELECT → DISTINCT → ORDER BY → LIMIT.
SELECT DISTINCT departamento AS depto -- 3. columnas y 4. sin repetidos
FROM pedido AS p -- 1. la tabla de origen
WHERE p.valor >= 60000 -- 2. solo pedidos de 60.000 o más
ORDER BY depto -- 5. orden alfabético
LIMIT 3; -- 6. los tres primeros
La base parte de los doce pedidos y el WHERE deja ocho. El SELECT se queda con el departamento y DISTINCT reduce las filas a seis. ORDER BY las pone en orden alfabético y LIMIT corta en tres: Antioquia, Bogotá D. C. y Boyacá.
El orden lógico no es el orden real
Ese orden dice qué ve cada cláusula, no qué hace la máquina paso a paso. Microsoft lo aclara en su manual: «The query processor determines the actual physical execution of the statement, and the order might vary from this list» [1]. En español: el procesador de consultas decide cómo se ejecuta en realidad, y el orden puede variar.
SQLite va más lejos. Advierte que su descripción en pasos es solo ilustrativa y que ni SQLite ni ningún otro motor está obligado a seguirla [10]. Y PostgreSQL, por ejemplo, calcula las columnas del SELECT después de ordenar y limitar, siempre que esas columnas no se usen en DISTINCT, ORDER BY ni GROUP BY [4]. Quien decide el camino real es el optimizador, la parte del motor que elige cómo ejecutar cada consulta.
Alias de columna y de tabla: nombres cortos con AS
Un alias es un nombre provisional que vale solo dentro de una consulta. Se escribe con la palabra AS (como). Hay dos clases, y cada una resuelve un problema distinto.
El alias de columna le pone nombre a una columna del resultado, sobre todo a una calculada. En la tabla no existe el precio por unidad, pero se puede calcular:
-- precio_unidad no está en la tabla: lo calcula el SELECT.
SELECT ciudad, valor / unidades AS precio_unidad
FROM pedido
ORDER BY precio_unidad DESC, ciudad
LIMIT 4;
Salen Bogotá, San Gil y Santa Marta con 33.000 pesos por unidad, y Bogotá otra vez con 32.000. El alias funciona en ORDER BY porque esa cláusula se procesa después del SELECT [1].
El alias de tabla abrevia el nombre de una tabla: FROM pedido AS p permite escribir p.valor. Según PostgreSQL, desde ese momento el alias reemplaza al nombre original en toda la consulta [6]. Brilla cuando hay varias tablas en juego, que es el terreno de los JOIN en SQL.
AS se puede omitir en muchos casos, pero conviene escribirlo. MySQL explica por qué: si se olvida una coma entre dos columnas, toma la segunda como alias de la primera, sin avisar [12]. PostgreSQL recomienda escribir siempre AS o poner el nombre entre comillas dobles [4].
¿Se puede usar un alias en WHERE?
En el SQL estándar, no. El manual de MySQL lo explica así: el estándar no permite usar un alias de columna en WHERE. La razón es que, cuando se evalúa el filtro, ese valor puede no estar calculado todavía [13]. PostgreSQL dice lo mismo: el alias sirve en ORDER BY y GROUP BY, pero no en WHERE ni en HAVING [4].
Ese era el error de Daniela. En la prueba de esta página, SQLite 3.53.1 aceptó WHERE precio_unidad > 32000 y devolvió las tres filas de 33.000. Es una tolerancia de ese motor, no una regla del lenguaje. La forma que funciona en todos repite la expresión:
-- Portátil: se repite el cálculo en el WHERE.
SELECT ciudad, valor / unidades AS precio_unidad
FROM pedido
WHERE valor / unidades > 32000;
Devuelve las mismas tres filas en SQLite, y es la forma que pide el manual de PostgreSQL [4].
Tipos de consultas SQL: de una tabla, de varias, agregadas y anidadas
Todo lo anterior es la consulta de una sola tabla. Las demás clases usan las mismas cláusulas y le suman una pieza. Cada una tiene su propia guía.
| Tipo de consulta | Qué hace | Pregunta típica sobre los pedidos | Guía |
|---|---|---|---|
| De una tabla | Lee, filtra, ordena y limita filas de una sola tabla, con las cláusulas de esta página [4] | ¿Qué pedidos de Boyacá pasan de 100.000 pesos? | Consultas básicas en SQL (en preparación) |
| De varias tablas | Combina filas de dos o más tablas que cumplen una condición, con JOIN [6] | ¿Qué cliente hizo cada pedido? | JOIN en SQL |
| Agregadas | Agrupa filas y calcula un resultado por grupo, por ejemplo un conteo [4] | ¿Cuánto vendió cada departamento? | Funciones de agregación en SQL (en preparación) |
| Anidadas | Usa una consulta dentro de otra, por ejemplo como tabla de origen en el FROM [6] | ¿Qué pedidos superan el valor promedio? | Subconsultas en SQL (en preparación) |
Las tres últimas no reemplazan la anatomía del SELECT. La amplían. Una unión entre tablas sigue teniendo su FROM, su WHERE y su ORDER BY, y se procesa en el mismo orden lógico [1].
Leer una consulta en el orden en que la lee la base
A mi juicio, el error más caro con SQL no es de sintaxis. Es leer la consulta como se escribe, de arriba abajo, cuando la base la resuelve empezando por el FROM. Quien interioriza ese orden deja de preguntarse por qué un alias no sirve en el WHERE o por qué un LIMIT sin ORDER BY trae filas distintas.
Por eso recomiendo leer cualquier consulta ajena en el orden lógico: de qué tabla sale, qué filtra, qué calcula y qué corta. Toma diez segundos más y evita el susto de Daniela.
Hay algo más en juego. La sintaxis cambia de motor a motor, y un analista que solo conoce la de su herramienta queda atado a ella. El orden lógico, en cambio, es el mismo en los tres manuales consultados que lo describen: Microsoft, PostgreSQL y SQLite. Para una pyme de Bucaramanga que hoy usa SQLite y mañana un servidor, esa es la parte que no hay que volver a aprender.
Preguntas frecuentes
¿En qué orden se escribe y en qué orden se ejecuta un SELECT? Se escribe SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY y, al final, el límite. Se procesa en otro orden lógico: FROM, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY y el límite [1]. Es un orden de disponibilidad, no de máquina: el motor decide la ejecución real y esa puede seguir otro orden [1] [10].
¿Qué hace DISTINCT en SQL? Quita del resultado las filas idénticas en todas las columnas pedidas y deja una de cada una [5]. Si se piden dos columnas, una fila solo desaparece cuando coincide en las dos. En la tabla de ejemplo, el departamento solo da seis filas; departamento y producto juntos dan diez.
¿Qué uso para limitar filas: LIMIT o TOP? Depende del motor. PostgreSQL, MySQL y SQLite usan LIMIT [4] [12] [10]; SQL Server usa TOP, o bien OFFSET con FETCH dentro del ORDER BY [3] [2]. FETCH FIRST es la forma del estándar, pero no figura en la gramática de MySQL 8.4 y SQLite 3.53.1 la rechazó en la prueba de esta página.
¿Se puede usar un alias de columna en el WHERE? No en el SQL estándar ni en PostgreSQL o MySQL, porque, cuando se evalúa el filtro, el alias puede no estar calculado todavía [4] [13]. SQLite 3.53.1 lo aceptó en la prueba de esta página, pero esa consulta falla al llevarla a otro motor. Repita el cálculo dentro del WHERE o úselo en el ORDER BY, donde sí está disponible.
¿BETWEEN incluye los valores de los extremos? Sí. Un rango del 1 al 14 de octubre trae también los pedidos de esos dos días [7] [11]. Ojo si la fecha lleva hora: en SQLite, un registro del 14 a las diez de la mañana quedó por fuera, porque como texto es mayor que el extremo final.
¿Si no pongo ORDER BY, en qué orden salen las filas? En el que el motor encuentre más rápido, sin ninguna promesa [4]. Puede coincidir con el orden en que se guardaron, pero también puede cambiar de una ejecución a otra si hay un límite de filas [4]. Si el orden importa, escríbalo.
Referencias
Las citas en otro idioma son traducción propia.
- Microsoft. SELECT (Transact-SQL), Microsoft Learn (artículo fechado el 16 de septiembre de 2026), sección «Logical processing order of the SELECT statement» — orden lógico o de enlace: FROM, ON, JOIN, WHERE, GROUP BY, WITH CUBE o WITH ROLLUP, HAVING, SELECT, DISTINCT, ORDER BY, TOP; los alias definidos en el SELECT no se pueden usar en las cláusulas anteriores y sí en las posteriores, como ORDER BY; «The query processor determines the actual physical execution of the statement, and the order might vary from this list»; advertencia de casos poco comunes en que la secuencia difiere. Microsoft Learn: SELECT (Transact-SQL) — Consultada: 2026-11-17.
- Microsoft. SELECT – ORDER BY Clause (Transact-SQL), Microsoft Learn (artículo fechado el 16 de septiembre de 2026) — el orden de las filas no está garantizado sin ORDER BY; ASC es el valor por defecto; los NULL se tratan como los valores más bajos al ordenar; gramática de OFFSET con un FETCH opcional dentro del ORDER BY; OFFSET y FETCH aplican a SQL Server 2012 (11.x) y versiones posteriores; FIRST y NEXT son sinónimos por compatibilidad con ANSI; se puede ordenar por un alias de columna. Microsoft Learn: ORDER BY Clause (Transact-SQL) — Consultada: 2026-11-17.
- Microsoft. TOP (Transact-SQL), Microsoft Learn (artículo fechado el 27 de diciembre de 2024) — TOP limita las filas a un número o porcentaje; sin ORDER BY devuelve las primeras filas en un orden indefinido; buena práctica: usar siempre ORDER BY con TOP; para paginar, usar OFFSET y FETCH en lugar de TOP; WITH TIES exige ORDER BY; TOP no se combina con OFFSET y FETCH en la misma consulta. Microsoft Learn: TOP (Transact-SQL) — Consultada: 2026-11-17.
- The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, referencia de la orden SELECT — SELECT recupera filas de cero o más tablas; procesamiento general: FROM, WHERE, GROUP BY y HAVING, lista de selección, DISTINCT, ORDER BY, LIMIT o FETCH FIRST; sin ORDER BY las filas salen en el orden que el sistema encuentre más rápido; ASC por defecto y NULLS LAST con ASC; el nombre de una columna de salida sirve en ORDER BY y GROUP BY, pero no en WHERE ni HAVING; PostgreSQL evalúa las expresiones de salida después de ordenar y limitar si no se usan en DISTINCT, ORDER BY o GROUP BY; LIMIT y OFFSET son sintaxis propia de PostgreSQL, también usada por MySQL, y SQL:2008 introdujo OFFSET … FETCH FIRST; con LIMIT conviene un ORDER BY y, sin él, ejecuciones repetidas pueden devolver subconjuntos distintos; se recomienda escribir siempre AS. PostgreSQL: Documentation 18, SELECT — Consultada: 2026-11-17.
- The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 7.3 «Select Lists» — DISTINCT elimina filas duplicadas después de procesar la lista de selección; ALL conserva todas; dos filas son distintas si difieren en al menos un valor de columna; los NULL se consideran iguales en esa comparación; DISTINCT ON no es parte del estándar SQL. PostgreSQL: Documentation 18, Select Lists — Consultada: 2026-11-17.
- The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 7.2 «Table Expressions» — un alias de tabla es un nombre provisional que se vuelve el nuevo nombre de la tabla en la consulta, y ya no se puede usar el original; una referencia de tabla puede ser una subconsulta entre paréntesis, con su alias, o una unión de tablas (JOIN) que se deriva de otras dos según las reglas del tipo de unión. PostgreSQL: Documentation 18, Table Expressions — Consultada: 2026-11-17.
- The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 9.2 «Comparison Functions and Operators» — operadores de comparación menor, mayor, menor o igual, mayor o igual, igual y distinto; BETWEEN incluye los extremos del rango. PostgreSQL: Documentation 18, Comparison Functions and Operators — Consultada: 2026-11-17.
- The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 9.7 «Pattern Matching» — en LIKE, el guion bajo equivale a un carácter y el signo de porcentaje a cualquier secuencia de cero o más caracteres; el patrón cubre la cadena completa; ILIKE compara sin distinguir mayúsculas y es una extensión de PostgreSQL que no está en el estándar SQL. PostgreSQL: Documentation 18, Pattern Matching — Consultada: 2026-11-17.
- The PostgreSQL Global Development Group. PostgreSQL 18 Documentation, sección 4.1.6 «Operator Precedence» — en la tabla de precedencia, NOT es la negación lógica, AND la conjunción y OR la disyunción; NOT va antes que AND y AND antes que OR; se recomiendan paréntesis cuando una expresión con varios operadores deba leerse distinto de lo que dictan las reglas de precedencia. PostgreSQL: Documentation 18, Lexical Structure — Consultada: 2026-11-17.
- SQLite. SELECT (página actualizada el 9 de octubre de 2026) — «The SELECT statement is the most complicated command in the SQL language»; la descripción en pasos es solo ilustrativa y ni SQLite ni ningún otro motor está obligado a seguirla; procesamiento de un SELECT simple: FROM, WHERE, agrupación y columnas de resultado, DISTINCT; sin FROM, la entrada es una sola fila sin columnas; DISTINCT compara con IS DISTINCT FROM, así que dos NULL cuentan como iguales; ASC por defecto; los NULL son menores que cualquier otro valor al ordenar; LIMIT y OFFSET; se desaconseja la forma de LIMIT con coma. SQLite: SELECT — Consultada: 2026-11-17.
- SQLite. SQL Language Expressions — LIKE con los comodines % y _; por defecto SQLite solo distingue mayúsculas y minúsculas de los caracteres ASCII y LIKE es sensible a mayúsculas para los caracteres unicode fuera de ese rango; BETWEEN equivale a un par de comparaciones, mayor o igual y menor o igual; IN y NOT IN con una lista de valores o una subconsulta. SQLite: SQL Language Expressions — Consultada: 2026-11-17.
- Oracle Corporation. MySQL 8.4 Reference Manual, sección «SELECT Statement» — gramática con LIMIT {[offset,] row_count | row_count OFFSET offset}; el desplazamiento de la primera fila es 0; MySQL acepta LIMIT row_count OFFSET offset por compatibilidad con PostgreSQL; no se permite usar un alias de columna en WHERE; AS es opcional y, si falta una coma entre dos columnas, MySQL toma la segunda como alias, por lo que conviene escribir AS; ALL y DISTINCT. Leída en la copia de Internet Archive del 16 de noviembre de 2026, porque el sitio de MySQL rechazó la descarga directa. MySQL 8.4 Reference Manual: SELECT Statement — Consultada: 2026-11-17.
- Oracle Corporation. MySQL 8.4 Reference Manual, sección B.3.4.4 «Problems with Column Aliases» — el alias sirve en GROUP BY, ORDER BY y HAVING; «Standard SQL disallows references to column aliases in a WHERE clause», porque al evaluar el WHERE el valor de la columna puede no estar determinado todavía. Leída en la copia de Internet Archive del 12 de agosto de 2026, porque el sitio de MySQL rechazó la descarga directa. MySQL 8.4 Reference Manual: Problems with Column Aliases — Consultada: 2026-11-17.
- Python Software Foundation. sqlite3 — DB-API 2.0 interface for SQLite databases, documentación de Python 3.15 — SQLite es una biblioteca que ofrece una base de datos liviana en disco que no requiere un proceso de servidor aparte; el módulo sqlite3 da acceso a ella desde Python. Python: documentación del módulo sqlite3 — Consultada: 2026-11-17.
Cómo investigamos esta página
- Pregunta que responde: Qué partes tiene una consulta SELECT, en qué orden se escriben y en qué orden las procesa la base de datos.
- Fuentes: identificadas 26 → incluidas 15
- Criterios de inclusión: manuales oficiales de Microsoft, PostgreSQL 18, SQLite, MySQL 8.4 y Python, leídos en su versión vigente; sin tutoriales ni enciclopedias.
- Fecha de corte de los datos: 2026-11-17