Saltar al contenido

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)
  1. Qué es el problema N+1
  2. Cómo ver el problema N+1 en los logs
  3. Solución 1: un JOIN
  4. Solución 2: WHERE id = ANY o IN
  5. La opción de tu ORM para incluir relaciones
  6. Medir antes y después
  7. Errores comunes
  8. Preguntas frecuentes
  9. Checklist

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;
  1. La primera consulta es el "1": trae 100 pedidos.
  2. El for recorre esos 100 pedidos.
  3. Cada vuelta manda otra consulta con el id de un pedido. Esas son las "N".
  4. 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.

una petición a tu API, contada en consultasN+1101 consultas161.5 ms a ~1.5 ms por viajeJOIN o ANY1 o 2 consultasla lista de pedidos+ todos sus productosla misma respuesta3.5 a 4.7 ms, mismo viajeN crece con la lista: 500 pedidos son 501 consultascada consulta es rápida; pesan los viajes100 pedidos, PGlite por TCP, mediana de 30; ilustrativo

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'
  1. SET log_min_duration_statement = 0 baja el umbral solo para tu sesión. Cambiarlo requiere ser superusuario o tener el privilegio SET sobre ese parámetro.
  2. La primera línea LOG es la lista de pedidos.
  3. parse sale 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.
  4. Después se repiten bind y execute con la misma sentencia y otro $1: 1000, 999, 998 y así hasta 901. Esa repetición es la firma del N+1.
  5. 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
  1. calls es cuántas veces se ejecutó la sentencia y rows, cuántas filas devolvió en total.
  2. El id se sustituye por $1, así que las 100 consultas por pedido son una sola fila con calls = 100.
  3. La pista: una sentencia con muchas más llamadas que la lista que la provoca, y pocas filas por llamada (aquí, 3).
  4. SELECT pg_stat_statements_reset() pone los contadores en cero. Úsalo antes de probar una ruta concreta.
log_min_duration_statement = 0execute: SELECT … FROM orders … LIMIT 100execute: SELECT … WHERE order_id = $1 · $1 = '1000'execute: SELECT … WHERE order_id = $1 · $1 = '999'execute: SELECT … WHERE order_id = $1 · $1 = '998'… y 97 más, la misma sentencia con otro $1cada una tarda < 1 ms: un umbral de 250 ms no la vepg_stat_statementscallsrowsquery100300SELECT … FROM order_items WHERE order_id = $11100SELECT … FROM orders … LIMIT 100la firma: una sentencia, cien vecessalida real de PostgreSQL 18.6 (PGlite), sin fechas

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()];
  1. La subconsulta elige los 100 pedidos más recientes, así que el LIMIT cuenta pedidos.
  2. LEFT JOIN agrega sus productos. Un pedido sin productos sigue apareciendo, con las columnas del producto en NULL.
  3. El resultado es plano: una fila por producto, con los datos del pedido repetidos. El Map los vuelve a agrupar por pedido.
  4. 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;
  1. La primera consulta es la misma lista de pedidos.
  2. ids junta los 100 ids en un arreglo.
  3. order_id = ANY($1) compara contra todos los elementos del arreglo, que viaja como un solo parámetro bigint[].
  4. Map.groupBy (Node.js 21 o superior) agrupa los productos por pedido.
  5. 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 } } },
});
  1. relations(orders, …) dice que un pedido tiene muchos productos (many).
  2. relations(orderItems, …) dice que cada producto pertenece a un pedido (one), unido por orderId e id.
  3. drizzle() recibe el cliente y un schema con tablas y relaciones; sin las relaciones, db.query no conoce items.
  4. findMany pide 100 pedidos y with incluye 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.

cómo cargar 100 pedidos con sus productosformaconsultascuándoN+1 (ciclo)101nunca sobre una listaJOIN1una relación; LIMIT antes de unir= ANY($1)2varias relaciones o listas largasIN (...)2listas cortas: un parámetro por idwith / include1si ya usas ORM (Drizzle: 1)las cinco devuelven lo mismo: 100 pedidos, 300 productosíndice en order_items.order_id para todascarga la relación de una vezcontado con pg_stat_statements y el logger de Drizzle

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ónConsultasLocalhostCon ~1.5 ms por viaje
N+110136.6 ms161.5 ms
JOIN11.8 ms3.5 ms
= ANY($1)21.8 ms4.7 ms
IN (...)21.8 ms4.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:

  1. Cuenta las consultas por petición. postgres.js acepta una función debug que se llama con cada consulta, y Drizzle, un logger; súmalas por petición y avisa cuando una ruta pase de un umbral. El contador completo, probado, está en la guía.
  2. En una base de pruebas, corre SELECT pg_stat_statements_reset(), llama la ruta una vez y lee calls. Antes del cambio verás 100; después, 1.
  3. 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 0 en desarrollo o pg_stat_statements.
  • Poner el LIMIT despué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 with o include.
  • IN con miles de ids. Cada id es un parámetro y el driver tiene un límite; un arreglo con ANY es 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_statements está activo y revisas las sentencias con más calls.
  • Ninguna ruta hace una consulta dentro de un ciclo sobre una lista.
  • Las relaciones se cargan con un JOIN, con = ANY($1) o con with / include del ORM.
  • Si usas JOIN, el LIMIT se 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

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

Publicado el 19 de noviembre de 2026

← Blog