El N+1 en el log, DataLoader y lo que pasa con la caché
2026-10-30 · 9 min de lectura
Contenido
Tercera y última entrada de la serie. En la primera está la teoría y en la segunda el laboratorio: PostgreSQL con dos tablas, una API REST en FastAPI y una API GraphQL en Strawberry, las dos sobre el mismo db.py, y la base de datos escribiendo en su log cada consulta que recibe.
Allí comparé la ficha de un usuario y GraphQL salía ganando. Ahora cambio la pantalla.
Segunda pantalla: el listado #
El caso de uso: una tabla con cien usuarios, y para cada uno el importe de sus tres últimos pedidos. Es la pantalla de “listado con un poco de detalle” que tiene cualquier aplicación.
En REST #
En REST, para esta pantalla, no tengo nada. /usuarios/{id} y /usuarios/{id}/pedidos me obligan a hacer una petición para la lista y cien más para los pedidos, lo cual es el N+1 en HTTP, que es aún peor que en SQL.
Así que hago lo que hace todo el mundo: un endpoint para la pantalla.
# api_rest/main.py (añadido)
@app.get("/usuarios")
def usuarios(
primeros: int = Query(10, ge=1, le=100),
pedidos: int = Query(3, ge=0, le=10),
):
with conectar() as con:
return con.execute(
"""
SELECT u.id, u.nombre,
COALESCE(
json_agg(
json_build_object('fecha', p.fecha, 'total', p.total)
ORDER BY p.fecha DESC
) FILTER (WHERE p.id IS NOT NULL),
'[]'
) AS pedidos
FROM usuarios u
LEFT JOIN LATERAL (
SELECT * FROM pedidos
WHERE usuario_id = u.id
ORDER BY fecha DESC
LIMIT %s
) p ON true
GROUP BY u.id
ORDER BY u.id
LIMIT %s
""",
(pedidos, primeros),
).fetchall()Una sola consulta. El LATERAL es el truco de PostgreSQL para “los N últimos de cada uno”, y el json_agg monta la lista de pedidos ya en la base de datos. Es un endpoint muy bueno y muy a medida: devuelve exactamente lo que quiere esta pantalla, y si mañana otra pantalla quiere el estado de los pedidos, hay que tocar el SQL.
ignacio@zeus:~$ curl -s 'localhost:8000/usuarios?primeros=100&pedidos=3' | jq '.[0]'
{
"id": 1,
"nombre": "Usuario 1",
"pedidos": [
{ "fecha": "2026-06-02", "total": 44.1 },
{ "fecha": "2025-11-19", "total": 173.25 },
{ "fecha": "2025-03-08", "total": 12.9 }
]
}Y en el log de PostgreSQL:
LOG: statement: SELECT u.id, u.nombre, COALESCE(json_agg(...)) AS pedidos FROM usuarios u LEFT JOIN LATERAL (...) ...Una línea.
En GraphQL, tal cual estaba #
En GraphQL no hay que escribir un endpoint nuevo. Solo necesito una query que devuelva varios usuarios; el campo pedidos ya existe en el tipo Usuario.
# api_graphql/main.py (añadido a Query)
@strawberry.field
def usuarios(self, primeros: int = 10) -> list[Usuario]:
with conectar() as con:
filas = con.execute(
"SELECT * FROM usuarios ORDER BY id LIMIT %s", (primeros,)
).fetchall()
return [Usuario(**f) for f in filas]Y el cliente pide:
ignacio@zeus:~$ curl -s localhost:8001/graphql \
-H 'Content-Type: application/json' \
-d '{"query": "{ usuarios(primeros: 100) { nombre pedidos(ultimos: 3) { total } } }"}' \
| jq '.data.usuarios[0]'
{
"nombre": "Usuario 1",
"pedidos": [
{ "total": "44.10" },
{ "total": "173.25" },
{ "total": "12.90" }
]
}Funciona, la respuesta es perfecta, el cliente ha obtenido exactamente lo que quería sin que yo escribiera un endpoint. Ahora el log:
LOG: statement: SELECT * FROM usuarios ORDER BY id LIMIT 100
LOG: statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id = 1 ORDER BY fecha DESC LIMIT 3
LOG: statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id = 2 ORDER BY fecha DESC LIMIT 3
LOG: statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id = 3 ORDER BY fecha DESC LIMIT 3
...
LOG: statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id = 100 ORDER BY fecha DESC LIMIT 3ignacio@zeus:~/lab-graphql$ podman compose logs db | grep -c 'FROM pedidos WHERE usuario_id'
100Ciento una consultas. Esto es el N+1, y conviene entender por qué ha pasado, porque no es un bug: es el diseño de los resolvers funcionando como se espera. Query.usuarios resolvió la lista con una consulta. Después Strawberry recorrió los cien usuarios, y para cada uno, como el cliente había pedido pedidos, llamó a Usuario.pedidos, que hace su consulta con self.id. Cien veces. El resolver de pedidos no sabe que hay otros noventa y nueve como él en marcha; solo sabe resolver los pedidos de un usuario. (Si quieres ver cómo se lee lo que hace PostgreSQL con cada una de esas consultas, tengo una entrada sobre EXPLAIN ANALYZE.)
En REST esto no me pasó porque yo escribí la consulta para la pantalla. En GraphQL la pantalla la ha inventado el cliente, y el servidor la ha resuelto de la única manera que sabía: campo a campo.
DataLoader #
La solución es un patrón, no una librería concreta, aunque Strawberry trae una implementación. La idea: en vez de que Usuario.pedidos haga su consulta en el acto, le pide los pedidos a un loader y se queda esperando. El loader no consulta nada hasta que todos los resolvers de ese ciclo han hecho su petición; entonces junta las cien claves y lanza una consulta para todas. Después reparte los resultados a cada resolver que esperaba.
Para que eso funcione los resolvers tienen que ser asíncronos (si no, no hay “quedarse esperando”), así que Usuario.pedidos pasa a async.
# api_graphql/main.py (versión con DataLoader)
import datetime
import decimal
import strawberry
from fastapi import FastAPI
from strawberry.dataloader import DataLoader
from strawberry.fastapi import GraphQLRouter
from db import conectar
@strawberry.type
class Pedido:
id: int
fecha: datetime.date
total: decimal.Decimal
estado: str
async def cargar_pedidos(claves: list[tuple[int, int]]) -> list[list[Pedido]]:
"""Recibe pares (usuario_id, ultimos) y devuelve, en el mismo orden,
la lista de pedidos de cada uno."""
ids = [usuario_id for usuario_id, _ in claves]
tope = max(ultimos for _, ultimos in claves)
with conectar() as con:
filas = con.execute(
"""
SELECT id, usuario_id, fecha, total, estado
FROM (
SELECT *,
row_number() OVER (
PARTITION BY usuario_id ORDER BY fecha DESC
) AS n
FROM pedidos
WHERE usuario_id = ANY(%s)
) t
WHERE n <= %s
ORDER BY usuario_id, fecha DESC
""",
(ids, tope),
).fetchall()
por_usuario: dict[int, list[Pedido]] = {}
for f in filas:
uid = f.pop("usuario_id")
por_usuario.setdefault(uid, []).append(Pedido(**f))
return [por_usuario.get(uid, [])[:ultimos] for uid, ultimos in claves]
@strawberry.type
class Usuario:
id: int
nombre: str
email: str
direccion: str | None
telefono: str | None
fecha_alta: datetime.date
@strawberry.field
async def pedidos(self, info: strawberry.Info, ultimos: int = 10) -> list[Pedido]:
return await info.context["pedidos"].load((self.id, ultimos))
@strawberry.type
class Query:
@strawberry.field
def usuario(self, id: int) -> Usuario | None:
with conectar() as con:
fila = con.execute(
"SELECT * FROM usuarios WHERE id = %s", (id,)
).fetchone()
return Usuario(**fila) if fila else None
@strawberry.field
def usuarios(self, primeros: int = 10) -> list[Usuario]:
with conectar() as con:
filas = con.execute(
"SELECT * FROM usuarios ORDER BY id LIMIT %s", (primeros,)
).fetchall()
return [Usuario(**f) for f in filas]
async def contexto():
return {"pedidos": DataLoader(load_fn=cargar_pedidos)}
schema = strawberry.Schema(query=Query)
app = FastAPI()
app.include_router(
GraphQLRouter(schema, context_getter=contexto), prefix="/graphql"
)Tres cosas que mirar:
cargar_pedidosrecibe una lista de claves y devuelve una lista de resultados en el mismo orden. Es el contrato de todo DataLoader. La clave es(usuario_id, ultimos)porque el campo tiene un argumento; si fuera solousuario_id, un cliente que pidieraultimos: 3para unos yultimos: 5para otros rompería el agrupado.- La consulta es la del
LATERALde REST, resuelta con una función de ventana.row_number() OVER (PARTITION BY usuario_id ORDER BY fecha DESC)numera los pedidos de cada usuario del más reciente al más antiguo, yn <= topese queda con los primeros.ANY(%s)recibe la lista de ids como un array de PostgreSQL; psycopg hace la conversión. - El loader se crea en
contexto(), una vez por petición HTTP. Si fuera global, cachearía resultados entre peticiones y servirías datos viejos. Ese es el error típico al empezar con DataLoader.
El cliente no cambia nada. La misma consulta de antes, y el log:
LOG: statement: SELECT * FROM usuarios ORDER BY id LIMIT 100
LOG: statement: SELECT id, usuario_id, fecha, total, estado FROM (SELECT *, row_number() OVER (...) AS n FROM pedidos WHERE usuario_id = ANY('{1,2,3,...,100}')) t WHERE n <= 3 ORDER BY usuario_id, fecha DESCDos consultas. Hemos vuelto al nivel de REST, con una diferencia que vale la pena notar: el endpoint REST servía a esta pantalla, y el loader sirve a cualquier consulta que pase por Usuario.pedidos, venga de donde venga. Es más trabajo la primera vez y menos las siguientes.
Y una pega que no voy a esconder: cargar_pedidos es async pero llama a psycopg en modo síncrono, así que bloquea el bucle de eventos mientras consulta. Para el laboratorio da igual; en un servidor real usarías psycopg.AsyncConnection o un pool. Lo dejo así para que el código sea comparable con el de REST línea a línea.
La caché, en treinta segundos #
Lo último que quedaba pendiente de la primera entrada. En REST, el endpoint de un usuario es un GET a una URL, y cachearlo es una cabecera:
# api_rest/main.py (modificado)
from fastapi import Response
@app.get("/usuarios/{id}")
def usuario(id: int, response: Response):
...
response.headers["Cache-Control"] = "public, max-age=60"
return filaignacio@zeus:~$ curl -sI localhost:8000/usuarios/42 | grep -i cache
cache-control: public, max-age=60A partir de aquí, cualquier proxy inverso, CDN o navegador que haya por el camino puede servir ese usuario durante un minuto sin preguntar al servidor. No has escrito nada.
En GraphQL, la misma ficha es un POST /graphql con la consulta en el cuerpo. Para un proxy, es una petición opaca e idéntica a todas las demás; no hay URL que identifique el recurso ni método que diga que es una lectura. Cache-Control no sirve de nada, y lo que te queda son las alternativas que mencioné en la primera entrada: consultas persistidas (el cliente manda un identificador por GET en vez de la consulta entera, y entonces sí hay algo cacheable), caché normalizada en el cliente, o caché de respuestas en el propio servidor. Todas funcionan; ninguna viene de serie.
Lo que ha enseñado el laboratorio #
Con dos tablas y dos pantallas:
- Para una ficha, GraphQL gana en HTTP (una petición, respuesta a medida) y empata en la base de datos.
- Para un listado, REST gana en la base de datos porque el endpoint lo escribiste tú para esa pantalla; GraphQL pierde de serie (101 consultas) y empata con DataLoader, a cambio de más código en el servidor y de que el patrón se reutilice.
- La caché HTTP la tiene REST gratis y GraphQL no la tiene.
Nada de esto es nuevo si leíste la primera entrada, pero ahora las frases tienen una línea de log detrás. Y la conclusión sigue siendo la misma: GraphQL no es mejor ni peor que REST; mueve el trabajo de sitio. De escribir endpoints a escribir loaders, de la caché HTTP a la caché de aplicación, de decidir tú la forma de los datos a defenderte de la forma que decida el cliente. Si ese cambio te conviene, adelante. Si no, REST sigue estando muy bien.
El código de las tres entradas está en Codeberg: https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql.