Problema N+1: por qué tu API hace 101 consultas a la base
En la práctica/ 13 min de lectura
El problema N+1 en Postgres: cómo verlo en el log y en pg_stat_statements, cómo quitarlo con JOIN, ANY o el with de tu ORM, y cómo medir el cambio.
- Bases de datos
- Node.js
- Rendimiento
En este artículo (9)
El problema N+1 aparece cuando tu API trae una lista con una consulta y luego hace otra consulta por cada elemento: 100 pedidos se convierten en 101 consultas. Se corrige trayendo la relación de una vez, con un JOIN, con WHERE order_id = ANY($1) o con la opción de tu ORM para incluir relaciones.
Aquí lo reproducimos en PostgreSQL con 1,000 pedidos de ejemplo, lo vemos en el log y en pg_stat_statements, y medimos las soluciones. Todo el código se ejecutó contra PGlite (PostgreSQL 18.6 compilado a WebAssembly) por TCP, con el driver postgres.js y con Drizzle ORM.
Qué es el problema N+1
Una pantalla de pedidos necesita cada pedido con sus productos. El código más natural pide la lista y luego recorre los pedidos para pedir los productos de cada uno:
// GET /api/orders (postgres.js)
const orders = await sql`SELECT id, created_at, total FROM orders ORDER BY id DESC LIMIT 100`;
for (const o of orders) {
o.items = await sql`SELECT sku, qty, price FROM order_items WHERE order_id = ${o.id} ORDER BY id`;
}
return orders;
- La primera consulta es el "1": trae 100 pedidos.
- El
forrecorre esos 100 pedidos. - Cada vuelta manda otra consulta con el id de un pedido. Esas son las "N".
- Resultado: 1 + 100 = 101 consultas para una sola petición a tu API.
Cada consulta por separado es rápida, así que nada parece roto. El costo está en las idas y vueltas: tu servidor manda una consulta, espera la respuesta y solo entonces manda la siguiente. Con la base en la misma máquina casi no se nota; con la base en otro servidor, cada viaje suma latencia de red, y son 101 viajes en fila. Además, N crece con los datos: si mañana la página muestra 500 pedidos, son 501 consultas sin cambiar una línea.
El patrón no es exclusivo del SQL escrito a mano. Aparece igual con un ORM cuando lees una relación dentro de un ciclo, en resolvers de GraphQL que cargan un campo por cada elemento y en plantillas que piden datos al pintar cada fila.
Desliza la figura para verla completa
Cómo ver el problema N+1 en los logs
El N+1 se esconde de la configuración habitual de logs. Según la documentación de PostgreSQL, log_min_duration_statement registra las sentencias que tardan al menos el umbral que pongas, por ejemplo 250ms; con -1, el valor por defecto, no registra nada, y con 0 registra la duración de todas. Como cada consulta del N+1 tarda menos de un milisegundo, un umbral de 250 ms nunca la ve. Para cazarlo, ponlo en 0 en desarrollo o en tu sesión de prueba. Esto escribió el servidor mientras corría el código de arriba:
SET log_min_duration_statement = 0;
LOG: duration: 0.000 ms execute 84rutxrwln63: SELECT id, created_at, total FROM orders ORDER BY id DESC LIMIT 100
LOG: duration: 0.000 ms parse 84rutxrwln64: SELECT sku, qty, price FROM order_items WHERE order_id = $1 ORDER BY id
LOG: duration: 1.000 ms bind 84rutxrwln64: SELECT sku, qty, price FROM order_items WHERE order_id = $1 ORDER BY id
DETAIL: Parameters: $1 = '1000'
LOG: duration: 0.000 ms execute 84rutxrwln64: SELECT sku, qty, price FROM order_items WHERE order_id = $1 ORDER BY id
DETAIL: Parameters: $1 = '1000'
LOG: duration: 0.000 ms bind 84rutxrwln64: SELECT sku, qty, price FROM order_items WHERE order_id = $1 ORDER BY id
DETAIL: Parameters: $1 = '999'
LOG: duration: 0.000 ms execute 84rutxrwln64: SELECT sku, qty, price FROM order_items WHERE order_id = $1 ORDER BY id
DETAIL: Parameters: $1 = '999'
SET log_min_duration_statement = 0baja el umbral solo para tu sesión. Cambiarlo requiere ser superusuario o tener el privilegioSETsobre ese parámetro.- La primera línea
LOGes la lista de pedidos. parsesale una sola vez: postgres.js prepara la sentencia y la reutiliza. Con el protocolo extendido, PostgreSQL registra por separado las fases parse, bind y execute.- Después se repiten
bindyexecutecon la misma sentencia y otro$1: 1000, 999, 998 y así hasta 901. Esa repetición es la firma del N+1. - Quitamos la fecha de cada línea. En esta prueba, PGlite redondeó las duraciones a 0.000 o 1.000 ms; un servidor normal muestra fracciones.
El log sirve para una petición. Para ver el patrón en todo el tráfico, pg_stat_statements junta en una sola fila las sentencias que solo cambian en sus valores y cuenta cuántas veces se ejecutó cada una. Se activa con shared_preload_libraries = 'pg_stat_statements' en postgresql.conf, lo que requiere reiniciar el servidor, y con CREATE EXTENSION pg_stat_statements en la base. En una base administrada, revisa en la documentación de tu proveedor cómo se carga.
SELECT calls, rows, query
FROM pg_stat_statements
ORDER BY calls DESC
LIMIT 5;
calls | rows | query
-------+------+------------------------------------------------------------------------
100 | 300 | SELECT sku, qty, price FROM order_items WHERE order_id = $1 ORDER BY id
1 | 100 | SELECT id, created_at, total FROM orders ORDER BY id DESC LIMIT 100
callses cuántas veces se ejecutó la sentencia yrows, cuántas filas devolvió en total.- El id se sustituye por
$1, así que las 100 consultas por pedido son una sola fila concalls = 100. - La pista: una sentencia con muchas más llamadas que la lista que la provoca, y pocas filas por llamada (aquí, 3).
SELECT pg_stat_statements_reset()pone los contadores en cero. Úsalo antes de probar una ruta concreta.
Desliza la figura para verla completa
Solución 1: un JOIN
Un JOIN trae pedidos y productos en una sola consulta. El detalle: si quieres 100 pedidos, limita los pedidos antes de unir. Un LIMIT 100 sobre el resultado del JOIN limita filas, no pedidos; en nuestra prueba devolvió 100 filas que eran solo 33 pedidos.
const rows = await sql`
SELECT o.id, o.created_at, o.total, i.sku, i.qty, i.price
FROM (SELECT * FROM orders ORDER BY id DESC LIMIT 100) o
LEFT JOIN order_items i ON i.order_id = o.id
ORDER BY o.id DESC, i.id`;
const orders = new Map();
for (const r of rows) {
if (!orders.has(r.id)) orders.set(r.id, { id: r.id, created_at: r.created_at, total: r.total, items: [] });
if (r.sku !== null) orders.get(r.id).items.push({ sku: r.sku, qty: r.qty, price: r.price });
}
return [...orders.values()];
- La subconsulta elige los 100 pedidos más recientes, así que el
LIMITcuenta pedidos. LEFT JOINagrega sus productos. Un pedido sin productos sigue apareciendo, con las columnas del producto enNULL.- El resultado es plano: una fila por producto, con los datos del pedido repetidos. El
Maplos vuelve a agrupar por pedido. if (r.sku !== null)evita meter un producto vacío en los pedidos que no tienen ninguno.
El precio del JOIN es esa repetición. Si el pedido tiene muchas columnas y muchos productos, viajan los mismos datos del pedido muchas veces, y con dos relaciones de uno a muchos en el mismo JOIN las filas se multiplican entre sí.
Solución 2: WHERE id = ANY o IN
La otra salida son dos consultas: la lista, y después todos los productos de esos pedidos de una vez. Son 2 consultas aunque la página tenga 10 o 500 pedidos.
const orders = await sql`SELECT id, created_at, total FROM orders ORDER BY id DESC LIMIT 100`;
const ids = orders.map((o) => o.id);
const items = await sql`
SELECT order_id, sku, qty, price FROM order_items
WHERE order_id = ANY(${ids}::bigint[]) ORDER BY id`;
const byOrder = Map.groupBy(items, (i) => i.order_id);
for (const o of orders) o.items = (byOrder.get(o.id) ?? []).map(({ order_id, ...i }) => i);
return orders;
- La primera consulta es la misma lista de pedidos.
idsjunta los 100 ids en un arreglo.order_id = ANY($1)compara contra todos los elementos del arreglo, que viaja como un solo parámetrobigint[].Map.groupBy(Node.js 21 o superior) agrupa los productos por pedido.- El último ciclo le da a cada pedido sus productos, o un arreglo vacío, y quita
order_id, que solo servía para agrupar.
Con IN el resultado es el mismo. En postgres.js se escribe WHERE order_id IN ${sql(ids)} y se expande a IN ($1, $2, …, $100): un parámetro por id. La documentación de PostgreSQL define IN con una lista como comparaciones = unidas con OR, y = ANY como la comparación contra un arreglo. Preferimos ANY por dos cosas que comprobamos: el texto de la consulta no cambia con 10 o con 500 ids, así que en pg_stat_statements sigue siendo una sola fila, y no choca con el límite de parámetros. Con 70,000 ids, la versión con IN falló en postgres.js con MAX_PARAMETERS_EXCEEDED (el máximo es 65,534) y la de ANY respondió.
Las dos soluciones buscan por order_items.order_id. Declarar la llave foránea no crea un índice en esa columna: sin él, nuestro EXPLAIN mostró Seq Scan on order_items, y en el N+1 eso pasa una vez por pedido. Cómo leer el plan y elegir el índice está en EXPLAIN ANALYZE en Postgres.
La opción de tu ORM para incluir relaciones
Un ORM no evita el N+1 por sí solo. Con Drizzle ORM 0.45.4, la versión estable en npm hoy, un ciclo con db.select() por pedido mandó 101 consultas, igual que el SQL a mano. Lo que lo resuelve es la opción para incluir relaciones. En las consultas relacionales de Drizzle declaras la relación una vez y pides los productos con with, según su guía de relaciones v1 y v2:
import { relations, desc } from "drizzle-orm";
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";
import { orders, orderItems } from "./schema.js"; // pgTable(...) de cada tabla
export const ordersRelations = relations(orders, ({ many }) => ({ items: many(orderItems) }));
export const orderItemsRelations = relations(orderItems, ({ one }) => ({
order: one(orders, { fields: [orderItems.orderId], references: [orders.id] }),
}));
const db = drizzle({
client: postgres(process.env.DATABASE_URL),
schema: { orders, orderItems, ordersRelations, orderItemsRelations },
});
const list = await db.query.orders.findMany({
orderBy: [desc(orders.id)],
limit: 100,
with: { items: { columns: { sku: true, qty: true, price: true } } },
});
relations(orders, …)dice que un pedido tiene muchos productos (many).relations(orderItems, …)dice que cada producto pertenece a un pedido (one), unido pororderIdeid.drizzle()recibe el cliente y unschemacon tablas y relaciones; sin las relaciones,db.queryno conoceitems.findManypide 100 pedidos ywithincluye sus productos, solo con tres columnas.
Con el logger de Drizzle encendido, ese findMany mandó una sola consulta: un LEFT JOIN LATERAL que arma los productos de cada pedido con json_agg dentro de PostgreSQL, y el LIMIT se aplica a los pedidos. En Drizzle 1.0, hoy publicado como release candidate (1.0.0-rc.5), las relaciones se declaran con defineRelations y se pasan como { relations }, y orderBy acepta { id: "desc" }; el with no cambia (documentación actual). También lo corrimos: una consulta.
En Prisma, lo equivalente es include: { items: true }. Su documentación de consultas de relaciones describe dos estrategias en relationLoadStrategy: join, una consulta con LATERAL JOIN en PostgreSQL, y query, una consulta por tabla unida en la aplicación; esa opción sigue en Preview (relationJoins). Ninguna de las dos es N+1. Prisma no lo ejecutamos para este artículo.
Desliza la figura para verla completa
Medir antes y después
Dos números importan: cuántas consultas hace la ruta y cuánto tarda. Medimos las cuatro versiones con la misma base, 30 veces cada una, y nos quedamos con la mediana. Primero directo por localhost; después a través de un proxy local que agrega 0.5 ms en cada sentido, para imitar una base en otro servidor de la misma red (un SELECT 1 pasó de 0.47 a 1.51 ms). Las cuatro devolvieron los mismos 100 pedidos y 300 productos. Los tiempos son ilustrativos: dependen de la máquina, y PGlite no es un servidor de producción.
| Versión | Consultas | Localhost | Con ~1.5 ms por viaje |
|---|---|---|---|
| N+1 | 101 | 36.6 ms | 161.5 ms |
| JOIN | 1 | 1.8 ms | 3.5 ms |
= ANY($1) | 2 | 1.8 ms | 4.7 ms |
IN (...) | 2 | 1.8 ms | 4.3 ms |
La lectura: en el N+1, el tiempo es casi todo espera de red. 101 viajes por unos 1.5 ms dan unos 150 ms, cerca de los 161.5 medidos. Con una o dos consultas, la latencia se paga una o dos veces. Por eso el N+1 pasa desapercibido en tu laptop y aparece en producción.
Para medirlo en tu proyecto:
- Cuenta las consultas por petición. postgres.js acepta una función
debugque se llama con cada consulta, y Drizzle, unlogger; súmalas por petición y avisa cuando una ruta pase de un umbral. El contador completo, probado, está en la guía. - En una base de pruebas, corre
SELECT pg_stat_statements_reset(), llama la ruta una vez y leecalls. Antes del cambio verás 100; después, 1. - Mide el tiempo de la ruta antes y después, con la base donde vive en producción, no solo en local.
Si lo que haces por cada elemento no es leer sino un trabajo lento, como mandar un correo o llamar una API externa, ni un JOIN ni ANY lo arreglan: sácalo de la petición con una cola de trabajos en Postgres.
Errores comunes
- Confiar en el log de consultas lentas. Con un umbral de 250 ms, las 100 consultas rápidas nunca aparecen. Usa
0en desarrollo opg_stat_statements. - Poner el
LIMITdespués del JOIN. Limita filas, no pedidos: en la prueba, 100 filas fueron 33 pedidos. - Creer que el ORM lo evita solo. Un ciclo que consulta la relación manda N consultas con o sin ORM; usa
withoinclude. INcon miles de ids. Cada id es un parámetro y el driver tiene un límite; un arreglo conANYes un solo parámetro.- Olvidar el índice de la llave foránea. Sin índice en
order_items.order_id, cada búsqueda recorre la tabla. - Esconderlo con
Promise.all. Mandar las 100 consultas en paralelo baja el tiempo de espera, pero siguen siendo 100 consultas y ocupan más conexiones del pool. - Medir solo en local. Sin latencia de red, 101 consultas parecen baratas.
Preguntas frecuentes
¿Qué conviene más, un JOIN o dos consultas con ANY?
Para una relación de uno a muchos, las dos sirven. El JOIN es un solo viaje, pero repite los datos del padre en cada fila. Dos consultas con ANY no repiten nada y escalan mejor cuando cargas varias relaciones a la vez. En nuestra medición quedaron muy cerca.
¿Por qué no aparece en mi log de consultas lentas?
Porque ninguna consulta es lenta. El problema es la cantidad, no la duración de cada una. log_min_duration_statement solo registra lo que supera el umbral, así que tienes que bajarlo a 0 en desarrollo o mirar calls en pg_stat_statements.
¿El problema N+1 también pasa con GraphQL?
Sí, y es común: cada resolver de un campo relacionado puede hacer su propia consulta por cada elemento de la lista. La solución es la misma idea: juntar los ids de la petición y cargarlos con una sola consulta con ANY, que es lo que hacen las librerías de carga por lotes.
¿Cuántas consultas por petición son demasiadas?
No hay un número oficial. La señal no es el total, sino que crezca con el tamaño de la lista. Si con 10 pedidos ves 11 consultas y con 100 ves 101, tienes un N+1. Un umbral de aviso, por ejemplo 10 por petición, sirve para encontrarlos.
Checklist
- Cuentas las consultas por petición en desarrollo y avisas cuando una ruta pasa de tu umbral.
pg_stat_statementsestá activo y revisas las sentencias con máscalls.- Ninguna ruta hace una consulta dentro de un ciclo sobre una lista.
- Las relaciones se cargan con un JOIN, con
= ANY($1)o conwith/includedel ORM. - Si usas JOIN, el
LIMITse aplica a la tabla principal antes de unir. - Las listas de ids viajan como arreglo, no como miles de parámetros.
- La columna de la llave foránea tiene índice.
- Mediste consultas y tiempo antes y después, con la base de producción en otra máquina.
Con las consultas agrupadas, el siguiente paso es que cada una use su índice: empieza por leer el plan con EXPLAIN ANALYZE.
¿Viste esto en Instagram? Comenta CONSULTAS en el Reel y te mando la guía.
Escrito por

Publicado el 19 de noviembre de 2026