<?xml version="1.0" encoding="utf-8" standalone="yes"?><?xml-stylesheet href="/feed_style.xsl" type="text/xsl"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:media="https://www.rssboard.org/media-rss"><channel><title>Postgresql – El blog de Ignacio</title><link>https://www.igalvan.es/tags/postgresql/</link><description>Entradas de Postgresql en El blog de Ignacio</description><generator>Hugo -- gohugo.io</generator><language>es</language><copyright>Ignacio Galván Vitas</copyright><lastBuildDate>Fri, 06 Nov 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://www.igalvan.es/tags/postgresql/index.xml" rel="self" type="application/rss+xml"/><icon>https://www.igalvan.es/logo.svg</icon><item><title>Al menos una vez, y lo que eso te obliga a hacer</title><link>https://www.igalvan.es/posts/2026/colas-al-menos-una-vez-idempotencia/</link><pubDate>Fri, 06 Nov 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/colas-al-menos-una-vez-idempotencia/</guid><description><![CDATA[<p>Tercera y última entrada. En la <a href="/posts/2026/colas-de-mensajes-para-gente-de-sincrono/">primera</a> saqué el correo del endpoint a una cola; en la <a href="/posts/2026/colas-cuando-el-consumidor-se-cae/">segunda</a> rompí el consumidor de cuatro formas y acabé con ack manual, reintentos con espera y una cola de fallidos. El sistema ya no pierde mensajes.</p>
<p>Lo que hace ahora, en cambio, es repetirlos. Y eso no es un bug: es la única garantía que una cola puede darte de verdad.</p>
<h2 id="fallo-5-el-correo-se-envía-dos-veces">Fallo 5: el correo se envía dos veces <a class="ancla" href="#fallo-5-el-correo-se-env%c3%ada-dos-veces" aria-label="Enlace a esta sección">#</a></h2>
<p>Vuelve al worker de la segunda entrada y fíjate en el orden de las cosas dentro de <code>procesar</code>: primero <code>enviar_correo</code>, después <code>basic_ack</code>. Entre una y otra hay un hueco. Lo voy a hacer más ancho para poder meter el dedo:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># worker.py (modificado solo para el experimento)</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">procesar</span>(canal, metodo, propiedades, cuerpo: bytes) <span style="color:#f92672">-&gt;</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>    pedido <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>loads(cuerpo)
</span></span><span style="display:flex;"><span>    intento <span style="color:#f92672">=</span> intentos_previos(propiedades) <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span>    print(<span style="color:#e6db74">f</span><span style="color:#e6db74">&#34;[worker] pedido </span><span style="color:#e6db74">{</span>pedido[<span style="color:#e6db74">&#39;id&#39;</span>]<span style="color:#e6db74">}</span><span style="color:#e6db74">, intento </span><span style="color:#e6db74">{</span>intento<span style="color:#e6db74">}</span><span style="color:#e6db74">, redelivered=</span><span style="color:#e6db74">{</span>metodo<span style="color:#f92672">.</span>redelivered<span style="color:#e6db74">}</span><span style="color:#e6db74">&#34;</span>, flush<span style="color:#f92672">=</span><span style="color:#66d9ef">True</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">try</span>:
</span></span><span style="display:flex;"><span>        enviar_correo(pedido)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">except</span> <span style="color:#a6e22e">Exception</span> <span style="color:#66d9ef">as</span> e:
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">...</span>
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>    time<span style="color:#f92672">.</span>sleep(<span style="color:#ae81ff">3</span>)  <span style="color:#75715e"># el hueco entre hacer el trabajo y confirmarlo</span>
</span></span><span style="display:flex;"><span>    canal<span style="color:#f92672">.</span>basic_ack(delivery_tag<span style="color:#f92672">=</span>metodo<span style="color:#f92672">.</span>delivery_tag)</span></span></code></pre></div>
</div>
<p>Lanza un pedido, espera a ver la línea de <code>[correo] ... enviada</code>, y en los tres segundos siguientes, <code>pkill -9</code>:</p>
<div class="codeblock"><pre tabindex="0"><code>ignacio@zeus:~/lab-colas$ python worker.py
[worker] esperando mensajes
[worker] pedido 520, intento 1, redelivered=False
[correo] confirmación del pedido 520 enviada
Killed</code></pre>
</div>
<p>El correo ha salido. El ack no. RabbitMQ ve caer la conexión y devuelve el mensaje a la cola, como debe. Arranca el worker:</p>
<div class="codeblock"><pre tabindex="0"><code>[worker] pedido 520, intento 1, redelivered=True
[correo] confirmación del pedido 520 enviada</code></pre>
</div>
<p>Dos correos de confirmación del mismo pedido. El usuario tiene dos mensajes en su bandeja y, si en vez de un correo fuera un cargo en la tarjeta, dos cargos.</p>
<p>Y aquí va la frase que cuesta aceptar viniendo del mundo síncrono: <strong>esto no tiene arreglo en la cola.</strong> Si haces ack antes de enviar, el fallo 1 de la entrada anterior vuelve (el worker muere después del ack y antes del envío: correo perdido). Si haces ack después, el worker puede morir entre el envío y el ack: correo duplicado. No hay un tercer sitio donde poner el ack. Puedes elegir entre <em>como mucho una vez</em> (ack antes) y <em>al menos una vez</em> (ack después), y para un correo de confirmación, o un cargo, o cualquier cosa que no quieras perder, eliges al menos una vez y asumes el duplicado.</p>
<p>Hay brókers que anuncian &ldquo;exactamente una vez&rdquo;. Lo que dan, cuando lo dan, es exactamente una vez <em>dentro del bróker</em>; en cuanto el consumidor hace algo fuera (un correo, una llamada HTTP, un <code>INSERT</code> en otra base de datos), vuelves a tener el hueco.</p>
<h2 id="arreglo-5-que-repetir-no-haga-daño">Arreglo 5: que repetir no haga daño <a class="ancla" href="#arreglo-5-que-repetir-no-haga-da%c3%b1o" aria-label="Enlace a esta sección">#</a></h2>
<p>Si no puedes evitar que un mensaje llegue dos veces, haz que la segunda vez no haga nada. Eso es idempotencia, y se consigue apuntando lo que ya has hecho en un sitio que sobreviva a la muerte del worker. Tengo un PostgreSQL al lado; sirve.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#75715e">-- añadido a init.sql
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">CREATE</span> <span style="color:#66d9ef">TABLE</span> correos_enviados (
</span></span><span style="display:flex;"><span>  pedido_id  int <span style="color:#66d9ef">PRIMARY</span> <span style="color:#66d9ef">KEY</span> <span style="color:#66d9ef">REFERENCES</span> pedidos(id),
</span></span><span style="display:flex;"><span>  enviado_en timestamptz <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span> <span style="color:#66d9ef">DEFAULT</span> now()
</span></span><span style="display:flex;"><span>);</span></span></code></pre></div>
</div>
<p>Y el worker, antes de enviar, intenta reservar el pedido:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># worker.py (versión final)</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">reservar</span>(pedido_id: int) <span style="color:#f92672">-&gt;</span> bool:
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;&#34;&#34;True si somos los primeros en ocuparnos de este pedido.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            INSERT INTO correos_enviados (pedido_id) VALUES (</span><span style="color:#e6db74">%s</span><span style="color:#e6db74">)
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ON CONFLICT (pedido_id) DO NOTHING
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            RETURNING pedido_id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (pedido_id,),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> fila <span style="color:#f92672">is</span> <span style="color:#f92672">not</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">procesar</span>(canal, metodo, propiedades, cuerpo: bytes) <span style="color:#f92672">-&gt;</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>    pedido <span style="color:#f92672">=</span> json<span style="color:#f92672">.</span>loads(cuerpo)
</span></span><span style="display:flex;"><span>    intento <span style="color:#f92672">=</span> intentos_previos(propiedades) <span style="color:#f92672">+</span> <span style="color:#ae81ff">1</span>
</span></span><span style="display:flex;"><span>    print(<span style="color:#e6db74">f</span><span style="color:#e6db74">&#34;[worker] pedido </span><span style="color:#e6db74">{</span>pedido[<span style="color:#e6db74">&#39;id&#39;</span>]<span style="color:#e6db74">}</span><span style="color:#e6db74">, intento </span><span style="color:#e6db74">{</span>intento<span style="color:#e6db74">}</span><span style="color:#e6db74">, redelivered=</span><span style="color:#e6db74">{</span>metodo<span style="color:#f92672">.</span>redelivered<span style="color:#e6db74">}</span><span style="color:#e6db74">&#34;</span>, flush<span style="color:#f92672">=</span><span style="color:#66d9ef">True</span>)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> <span style="color:#f92672">not</span> reservar(pedido[<span style="color:#e6db74">&#34;id&#34;</span>]):
</span></span><span style="display:flex;"><span>        print(<span style="color:#e6db74">f</span><span style="color:#e6db74">&#34;[worker] pedido </span><span style="color:#e6db74">{</span>pedido[<span style="color:#e6db74">&#39;id&#39;</span>]<span style="color:#e6db74">}</span><span style="color:#e6db74"> ya tratado, ignoro&#34;</span>, flush<span style="color:#f92672">=</span><span style="color:#66d9ef">True</span>)
</span></span><span style="display:flex;"><span>        canal<span style="color:#f92672">.</span>basic_ack(delivery_tag<span style="color:#f92672">=</span>metodo<span style="color:#f92672">.</span>delivery_tag)
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">try</span>:
</span></span><span style="display:flex;"><span>        enviar_correo(pedido)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">except</span> <span style="color:#a6e22e">Exception</span> <span style="color:#66d9ef">as</span> e:
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">...</span>  <span style="color:#75715e"># igual que en la segunda entrada</span>
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span>
</span></span><span style="display:flex;"><span>    canal<span style="color:#f92672">.</span>basic_ack(delivery_tag<span style="color:#f92672">=</span>metodo<span style="color:#f92672">.</span>delivery_tag)</span></span></code></pre></div>
</div>
<p>El <code>INSERT ... ON CONFLICT DO NOTHING RETURNING</code> es el truco: si la fila no existía, la inserta y devuelve el id; si existía, no hace nada y no devuelve nada. Atómico, en una sola sentencia, sin ventana para que dos workers se cuelen. Repite el experimento del <code>pkill -9</code> tras el envío:</p>
<div class="codeblock"><pre tabindex="0"><code>[worker] pedido 521, intento 1, redelivered=True
[worker] pedido 521 ya tratado, ignoro</code></pre>
</div>
<p>Un correo. La reentrega llega, la reserva falla porque ya está hecha, y el worker se limita a confirmar el mensaje para que RabbitMQ lo olvide.</p>
<h3 id="el-hueco-se-ha-movido-no-ha-desaparecido">El hueco se ha movido, no ha desaparecido <a class="ancla" href="#el-hueco-se-ha-movido-no-ha-desaparecido" aria-label="Enlace a esta sección">#</a></h3>
<p>Sé honesto con esto o el lector lo descubrirá solo. Ahora el orden es: reservar, enviar, ack. Si el worker muere <strong>entre reservar y enviar</strong>, el pedido queda marcado como tratado y el correo no sale nunca. He cambiado un duplicado por una pérdida, en una ventana mucho más pequeña (unos milisegundos frente a los dos segundos del envío) y, sobre todo, <strong>detectable</strong>: la fila en <code>correos_enviados</code> existe, y el correo no. Un trabajo de limpieza que compare esa tabla con el registro del servidor de correo, o una columna <code>estado</code> (<code>reservado</code> → <code>enviado</code>) con un reintento para los que llevan demasiado tiempo en <code>reservado</code>, lo cierra del todo. Lo dejo fuera porque ya no es sobre colas, pero que conste que el circuito completo tiene una pieza más.</p>
<p>La regla general, que vale para cualquier cosa que haga efectos fuera de la base de datos: <strong>o la operación es naturalmente idempotente</strong> (poner <code>estado = 'enviado'</code> lo es; <code>saldo = saldo - 10</code> no), <strong>o le pones una clave que lo haga idempotente</strong> (el id del pedido, un UUID generado por el productor y viajando en el mensaje). Si no hay ninguna de las dos, el duplicado acabará ocurriendo.</p>
<h2 id="lo-mismo-del-lado-del-productor">Lo mismo, del lado del productor <a class="ancla" href="#lo-mismo-del-lado-del-productor" aria-label="Enlace a esta sección">#</a></h2>
<p>He hablado todo el rato del consumidor, pero el endpoint de la primera entrada tiene exactamente el mismo problema al revés:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        pedido <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(<span style="color:#e6db74">&#34;INSERT INTO pedidos ... RETURNING ...&#34;</span>)<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>    publicar(pedido)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> pedido</span></span></code></pre></div>
</div>
<p>Si <code>publicar</code> falla (RabbitMQ caído, un corte de red), el pedido está en la base de datos y el mensaje no existe: un pedido sin correo. Si inviertes el orden y publicas antes de insertar, puedes tener un correo de un pedido que nunca se guardó. Es el mismo hueco de siempre, entre dos sistemas que no comparten transacción.</p>
<p>La solución tiene nombre, <em>transactional outbox</em>, y es más sencilla de lo que suena: en la misma transacción que inserta el pedido, insertas también una fila en una tabla <code>mensajes_pendientes</code>. Las dos filas se guardan o ninguna. Y un proceso aparte lee esa tabla, publica en RabbitMQ y borra la fila al conseguirlo. Ese proceso vuelve a ser un &ldquo;al menos una vez&rdquo; (puede publicar y morir antes de borrar), así que el consumidor tiene que ser idempotente. Que ya lo es. Todo encaja.</p>
<p>No lo implemento aquí porque son treinta líneas más y la entrada ya va larga, pero es la pieza que convierte el laboratorio en algo que pondrías en producción.</p>
<h2 id="cuándo-una-cola-es-demasiado">Cuándo una cola es demasiado <a class="ancla" href="#cu%c3%a1ndo-una-cola-es-demasiado" aria-label="Enlace a esta sección">#</a></h2>
<p>Tres entradas después, la pregunta que debería ir antes de instalar RabbitMQ: ¿lo necesito?</p>
<p>Un bróker de mensajes es un sistema más que mantener, monitorizar, actualizar y que puede caerse. Antes de meterlo, dos alternativas que resuelven una parte sorprendente de los casos:</p>
<ul>
<li><strong>Una tarea en segundo plano en el propio servidor web.</strong> FastAPI tiene <code>BackgroundTasks</code>: el endpoint responde y el correo se envía después en el mismo proceso. Resuelve el problema de la latencia (el primero de la serie) y nada más: si el proceso muere, la tarea se pierde, y no hay reintentos ni cola de fallidos. Para cosas que da igual perder, sobra.</li>
<li><strong>Una tabla de tareas en PostgreSQL.</strong> <code>INSERT INTO tareas</code> en la misma transacción que el pedido, y un worker que hace <code>SELECT ... FOR UPDATE SKIP LOCKED</code> para cogerlas de una en una. Tienes persistencia, reintentos (una columna <code>intentos</code>), fallidos (una columna <code>estado</code>), varios workers en paralelo, y la transacción con el pedido gratis, que es justo lo que el outbox intentaba conseguir. Lo que no tienes es un bróker que empuje los mensajes: el worker sondea cada segundo o cada cinco. Para la inmensa mayoría de sistemas que no son de alta frecuencia es más que suficiente, y es una dependencia menos.</li>
</ul>
<p>RabbitMQ (o cualquier bróker) empieza a compensar cuando hay varios productores y consumidores que son sistemas distintos, cuando el volumen hace que sondear una tabla sea un problema, cuando quieres enrutar un mismo mensaje a varios consumidores que no se conocen, o cuando necesitas que el bróker esté entre dos sistemas que no deben compartir una base de datos.</p>
<p>Y aun entonces, la cola es la fontanería. Lo que se ha visto en esta serie (ack, reintentos, fallidos, idempotencia, outbox) no lo resuelve el bróker: lo resuelves tú en el diseño de lo que viaja por la cola y de lo que hace quien lo recibe. Cambiar RabbitMQ por otro producto cambia los nombres de las piezas, no el trabajo.</p>
<h2 id="lo-que-ha-enseñado-la-serie">Lo que ha enseñado la serie <a class="ancla" href="#lo-que-ha-ense%c3%b1ado-la-serie" aria-label="Enlace a esta sección">#</a></h2>
<ul>
<li>Una cola desacopla en el tiempo: el productor termina sin esperar al consumidor, y el consumidor puede no existir en ese momento.</li>
<li><code>auto_ack</code> pierde mensajes; el ack manual los conserva, pero convierte las caídas en reentregas.</li>
<li>Reencolar a la misma cola es un bucle; rechazar hacia un DLX con una cola de espera son reintentos con pausa, y una cola de fallidos aparta lo irrecuperable.</li>
<li>Al menos una vez es lo único que hay. Idempotencia en el consumidor, con una clave en una tabla, es el precio.</li>
<li>El productor tiene el hueco simétrico; el outbox lo cierra.</li>
<li>Antes de un bróker, una tabla de tareas en la base de datos que ya tienes resuelve más de lo que parece.</li>
</ul>
<p>El código de las tres entradas está en Codeberg: <a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-colas" target="_blank" rel="noopener">https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-colas</a>.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_1ce61963e9c4a93f.png"/></item><item><title>EXPLAIN ANALYZE para humanos: leer un plan de PostgreSQL sin sufrir</title><link>https://www.igalvan.es/posts/2026/explain-analyze-para-humanos/</link><pubDate>Wed, 04 Nov 2026 19:30:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/explain-analyze-para-humanos/</guid><description><![CDATA[<p>Hay una pregunta que todos hemos hecho alguna vez, normalmente con cara de
funeral: <em>«el índice existe, ¿por qué PostgreSQL pasa de él?»</em>.</p>
<p>Mira estas dos consultas sobre la misma tabla de un millón de filas. Devuelven
exactamente las mismas 726 filas:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>-- Consulta A
</span></span><span style="display:flex;"><span>Seq Scan on pedidos  (cost=0.00..24853.00 rows=5000 width=27) (actual time=0.104..459.164 rows=726 loops=1)
</span></span><span style="display:flex;"><span>Execution Time: 459.294 ms
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>-- Consulta B
</span></span><span style="display:flex;"><span>Bitmap Heap Scan on pedidos  (cost=9.94..2118.47 rows=712 width=27) (actual time=0.235..1.202 rows=726 loops=1)
</span></span><span style="display:flex;"><span>Execution Time: 1.272 ms</span></span></code></pre></div>
</div>
<p>459 milisegundos frente a 1,2. La diferencia entre una y otra es una sola
línea de SQL, y está justo ahí, en el plan. Al final de la entrada vuelvo a
ellas. Antes toca aprender a leer lo que PostgreSQL nos cuenta, que parece un
volcado ilegible pero se lee con cuatro reglas.</p>
<p>Todo lo que ves aquí sale de un laboratorio que puedes reproducir en tu
máquina. Las salidas están capturadas con <strong>PostgreSQL 16.15</strong>; más abajo
cuento qué cambia en versiones más nuevas.</p>
<h2 id="el-laboratorio">El laboratorio <a class="ancla" href="#el-laboratorio" aria-label="Enlace a esta sección">#</a></h2>
<p>Tres tablas sintéticas, generadas con <code>generate_series()</code> y <code>random()</code>, para no
descargar nada:</p>
<table>
  <thead>
      <tr>
          <th>Tabla</th>
          <th>Filas</th>
          <th>Tamaño total</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>clientes</code></td>
          <td>10 000</td>
          <td>1,3 MB</td>
      </tr>
      <tr>
          <td><code>pedidos</code></td>
          <td>1 000 000</td>
          <td>79 MB</td>
      </tr>
      <tr>
          <td><code>lineas_pedido</code></td>
          <td>3 000 000</td>
          <td>261 MB</td>
      </tr>
  </tbody>
</table>
<p>Cada pedido tiene exactamente 3 líneas y cada cliente unos 100 pedidos. El 90 %
de los pedidos están en estado <code>entregado</code> y sólo el 0,5 % en <code>devuelto</code>; lo
usaremos a propósito. Además, <code>provincia</code>, <code>municipio</code> y <code>codigo_postal</code> de los
clientes están fuertemente correlacionados, y eso también tiene su historia.</p>
<p>El código está en el repositorio público de laboratorios, en la carpeta
<a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-explain" target="_blank" rel="noopener"><code>lab-explain/</code></a>,
autosuficiente como las de las otras series. Con Podman:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-console" data-lang="console"><span style="display:flex;"><span>ignacio@zeus:~$ git clone https://codeberg.org/igalvan/blog-public-code.git
</span></span><span style="display:flex;"><span>ignacio@zeus:~$ cd blog-public-code/lab-explain
</span></span><span style="display:flex;"><span>ignacio@zeus:~/blog-public-code/lab-explain$ ./lab.sh up      # PostgreSQL en un contenedor
</span></span><span style="display:flex;"><span>ignacio@zeus:~/blog-public-code/lab-explain$ ./lab.sh init    # crea y carga las tablas (~20 s)
</span></span><span style="display:flex;"><span>ignacio@zeus:~/blog-public-code/lab-explain$ ./lab.sh run      # ejecuta las consultas
</span></span></code></pre></div>
</div>
<p><code>./lab.sh run</code> guarda cada salida en <code>salidas/</code>. Si prefieres usar un
PostgreSQL que ya tengas instalado, basta con definir <code>PSQL_CMD</code> (el README lo
explica).</p>
<p>Una decisión de laboratorio: todas las consultas empiezan con
<code>SET max_parallel_workers_per_gather = 0;</code> y <code>SET jit = off;</code>. El paralelismo
añade nodos <code>Gather</code> y <code>Workers</code> que son muy interesantes, pero estorban cuando
estás aprendiendo a leer. En producción lo normal es tenerlos activados.</p>
<h2 id="explain-y-explain-analyze-no-son-lo-mismo">EXPLAIN y EXPLAIN ANALYZE no son lo mismo <a class="ancla" href="#explain-y-explain-analyze-no-son-lo-mismo" aria-label="Enlace a esta sección">#</a></h2>
<ul>
<li><code>EXPLAIN consulta</code> <strong>estima</strong>: muestra el plan que PostgreSQL elegiría y lo
que <em>cree</em> que va a costar, sin ejecutar nada.</li>
<li><code>EXPLAIN ANALYZE consulta</code> <strong>ejecuta de verdad</strong> la consulta y añade lo que
pasó realmente: tiempos y filas reales.</li>
<li><code>EXPLAIN (ANALYZE, BUFFERS) consulta</code> añade cuántas páginas de memoria o disco
tocó cada nodo. Es la forma que uso casi siempre.</li>
</ul>
<p>Un aviso que conviene tatuarse: como <code>ANALYZE</code> ejecuta la consulta, con un
<code>UPDATE</code>, <code>DELETE</code> o <code>INSERT</code> <strong>modifica los datos</strong>. Si quieres ver el plan sin
consecuencias:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#66d9ef">BEGIN</span>;
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">EXPLAIN</span> (<span style="color:#66d9ef">ANALYZE</span>, BUFFERS) <span style="color:#66d9ef">UPDATE</span> pedidos <span style="color:#66d9ef">SET</span> estado <span style="color:#f92672">=</span> <span style="color:#e6db74">&#39;enviado&#39;</span> <span style="color:#66d9ef">WHERE</span> id <span style="color:#f92672">=</span> <span style="color:#ae81ff">1</span>;
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">ROLLBACK</span>;</span></span></code></pre></div>
</div>
<h2 id="regla-1-el-plan-es-un-árbol-y-se-lee-de-dentro-hacia-fuera">Regla 1: el plan es un árbol y se lee de dentro hacia fuera <a class="ancla" href="#regla-1-el-plan-es-un-%c3%a1rbol-y-se-lee-de-dentro-hacia-fuera" aria-label="Enlace a esta sección">#</a></h2>
<p>Cada línea con <code>-&gt;</code> es un <strong>nodo</strong>. Los nodos más indentados se ejecutan
primero y pasan sus filas al nodo de encima. Este es el plan de una unión
sencilla, recortado:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Nested Loop  (cost=5.49..380.77 rows=100 width=22) (actual time=0.075..0.299 rows=103 loops=1)
</span></span><span style="display:flex;"><span>  -&gt;  Index Scan using clientes_pkey on clientes c  (cost=0.29..8.30 rows=1 width=16) (actual time=0.026..0.027 rows=1 loops=1)
</span></span><span style="display:flex;"><span>        Index Cond: (id = 4242)
</span></span><span style="display:flex;"><span>  -&gt;  Bitmap Heap Scan on pedidos p  (cost=5.20..371.46 rows=100 width=14) (actual time=0.043..0.254 rows=103 loops=1)
</span></span><span style="display:flex;"><span>        Recheck Cond: (cliente_id = 4242)
</span></span><span style="display:flex;"><span>        -&gt;  Bitmap Index Scan on idx_pedidos_cliente  (cost=0.00..5.17 rows=100 width=0) (actual time=0.024..0.024 rows=103 loops=1)
</span></span><span style="display:flex;"><span>              Index Cond: (cliente_id = 4242)
</span></span><span style="display:flex;"><span>Execution Time: 0.400 ms</span></span></code></pre></div>
</div>
<p>Primero se busca el cliente por clave primaria, luego se buscan sus pedidos
con el índice de <code>cliente_id</code>, y arriba el <code>Nested Loop</code> los combina.</p>
<p>Y cada nodo trae dos paréntesis con casi el mismo formato:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>(cost=5.20..371.46 rows=100 width=14)              &lt;- lo que PostgreSQL ESTIMA
</span></span><span style="display:flex;"><span>(actual time=0.043..0.254 rows=103 loops=1)        &lt;- lo que PASÓ DE VERDAD</span></span></code></pre></div>
</div>
<ul>
<li><strong><code>cost=arranque..total</code></strong>: coste estimado en unidades arbitrarias. El primer
número es lo que cuesta producir la primera fila; el segundo, la última. No
son milisegundos: es una moneda interna que sirve para comparar planes.</li>
<li><strong><code>rows</code></strong>: filas que se estiman (o que salieron de verdad, en el segundo
paréntesis).</li>
<li><strong><code>width</code></strong>: ancho medio de la fila, en bytes.</li>
<li><strong><code>actual time=arranque..total</code></strong>: milisegundos reales, <strong>por cada vuelta</strong>.</li>
<li><strong><code>loops</code></strong>: cuántas veces se ejecutó este nodo.</li>
</ul>
<p>Esa última pareja es la trampa más habitual y nos lleva a la regla 2.</p>
<h2 id="regla-2-el-tiempo-real-es-por-vuelta-multiplica-por-loops">Regla 2: el tiempo real es por vuelta, multiplica por <code>loops</code> <a class="ancla" href="#regla-2-el-tiempo-real-es-por-vuelta-multiplica-por-loops" aria-label="Enlace a esta sección">#</a></h2>
<p>Esta unión devuelve los pedidos de todos los clientes de un municipio:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Nested Loop  (cost=5.13..15440.31 rows=5400 width=22) (actual time=0.070..29.251 rows=5425 loops=1)
</span></span><span style="display:flex;"><span>  -&gt;  Seq Scan on clientes c  (cost=0.00..259.00 rows=54 width=16) (actual time=0.027..1.476 rows=54 loops=1)
</span></span><span style="display:flex;"><span>        Filter: (municipio = &#39;Municipio 7&#39;::text)
</span></span><span style="display:flex;"><span>        Rows Removed by Filter: 9946
</span></span><span style="display:flex;"><span>  -&gt;  Bitmap Heap Scan on pedidos p  (cost=5.13..280.13 rows=101 width=14) (actual time=0.026..0.496 rows=100 loops=54)
</span></span><span style="display:flex;"><span>        Recheck Cond: (c.id = cliente_id)
</span></span><span style="display:flex;"><span>        -&gt;  Bitmap Index Scan on idx_pedidos_cliente  (cost=0.00..5.11 rows=101 width=0) (actual time=0.011..0.011 rows=100 loops=54)
</span></span><span style="display:flex;"><span>              Index Cond: (cliente_id = c.id)
</span></span><span style="display:flex;"><span>Execution Time: 29.613 ms</span></span></code></pre></div>
</div>
<p>Mira el nodo <code>Bitmap Heap Scan on pedidos</code>: <code>actual time=0.026..0.496</code>,
parece que medio milisegundo. Pero tiene <code>loops=54</code>: se ejecutó 54 veces, una
por cada cliente del municipio. 0,496 ms × 54 ≈ <strong>27 ms</strong>, casi todo el tiempo
de la consulta (29,6 ms). Si no multiplicas, te vas a poner a optimizar el nodo
equivocado.</p>
<p>Un detalle más: cuando <code>loops</code> es mayor que 1, <code>rows</code> es la <strong>media por vuelta</strong>
(100 filas × 54 vueltas ≈ las 5 425 del nodo de arriba).</p>
<p>Para ver que los costes no son magia, tomemos el <code>Seq Scan</code> de más abajo
(<code>cost=0.00..19853.00</code>). La tabla <code>pedidos</code> ocupa 7 353 páginas y tiene
1 000 000 de filas. Con los parámetros por defecto, leer una página
secuencialmente cuesta 1, procesar una fila 0,01 y evaluar una condición 0,0025:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>7353 × 1  +  1 000 000 × 0,01  +  1 000 000 × 0,0025  =  19 853</span></span></code></pre></div>
</div>
<p>Cuadra exactamente. Un plan es aritmética, no un oráculo.</p>
<h2 id="regla-3-cómo-accede-a-los-datos">Regla 3: cómo accede a los datos <a class="ancla" href="#regla-3-c%c3%b3mo-accede-a-los-datos" aria-label="Enlace a esta sección">#</a></h2>
<p>Probemos con la consulta <code>SELECT * FROM pedidos WHERE cliente_id = 4242</code>, en
varias situaciones.</p>
<p><strong>Seq Scan.</strong> Sin índice sobre <code>cliente_id</code>, no hay otra opción que leer la
tabla entera:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Seq Scan on pedidos  (cost=0.00..19853.00 rows=100 width=27) (actual time=5.110..63.057 rows=103 loops=1)
</span></span><span style="display:flex;"><span>  Filter: (cliente_id = 4242)
</span></span><span style="display:flex;"><span>  Rows Removed by Filter: 999897
</span></span><span style="display:flex;"><span>  Buffers: shared read=7353
</span></span><span style="display:flex;"><span>Execution Time: 63.135 ms</span></span></code></pre></div>
</div>
<p>La línea clave es <code>Rows Removed by Filter: 999897</code>: leyó un millón de filas
para quedarse con 103.</p>
<p><strong>Bitmap Heap Scan.</strong> Con un índice sobre <code>cliente_id</code>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Bitmap Heap Scan on pedidos  (cost=5.20..371.46 rows=100 width=27) (actual time=0.071..0.700 rows=103 loops=1)
</span></span><span style="display:flex;"><span>  Recheck Cond: (cliente_id = 4242)
</span></span><span style="display:flex;"><span>  Heap Blocks: exact=102
</span></span><span style="display:flex;"><span>  -&gt;  Bitmap Index Scan on idx_pedidos_cliente  (cost=0.00..5.17 rows=100 width=0) (actual time=0.048..0.048 rows=103 loops=1)
</span></span><span style="display:flex;"><span>        Index Cond: (cliente_id = 4242)
</span></span><span style="display:flex;"><span>Execution Time: 0.728 ms</span></span></code></pre></div>
</div>
<p>De 63 ms a 0,7 ms. Primero se recorre el índice y se construye un «mapa» de qué
páginas de la tabla contienen filas buscadas (<code>Bitmap Index Scan</code>); luego se
leen esas 102 páginas una sola vez y en orden (<code>Bitmap Heap Scan</code>). Es la
elección típica cuando salen unas decenas o cientos de filas dispersas por la
tabla.</p>
<p><strong>Index Scan.</strong> Para una sola fila por clave primaria, PostgreSQL va y vuelve
por el índice sin mapa intermedio:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Index Scan using pedidos_pkey on pedidos  (cost=0.42..8.44 rows=1 width=27) (actual time=0.042..0.042 rows=1 loops=1)
</span></span><span style="display:flex;"><span>  Index Cond: (id = 777777)
</span></span><span style="display:flex;"><span>Execution Time: 0.052 ms</span></span></code></pre></div>
</div>
<p><strong>Index Only Scan.</strong> Si sólo pides columnas que están en el propio índice, ni
siquiera toca la tabla:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Index Only Scan using idx_pedidos_cliente on pedidos  (cost=0.42..6.17 rows=100 width=4) (actual time=0.011..0.018 rows=103 loops=1)
</span></span><span style="display:flex;"><span>  Index Cond: (cliente_id = 4242)
</span></span><span style="display:flex;"><span>  Heap Fetches: 0
</span></span><span style="display:flex;"><span>Execution Time: 0.031 ms</span></span></code></pre></div>
</div>
<p>Ojo con <code>Heap Fetches: 0</code>. Un Index Only Scan necesita que el <em>mapa de
visibilidad</em> de la tabla esté al día, algo que mantiene <code>VACUUM</code>. Si
<code>Heap Fetches</code> es alto, el «only» es mentira: está yendo a la tabla igualmente.
En el laboratorio hago un <code>VACUUM pedidos;</code> justo antes para que salga limpio.</p>
<p><strong>El mito del Seq Scan malo.</strong> Cuando la condición se lleva casi media tabla:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Seq Scan on pedidos  (cost=0.00..22353.00 rows=598275 width=27) (actual time=0.011..83.618 rows=599873 loops=1)
</span></span><span style="display:flex;"><span>  Filter: ((cliente_id &gt;= 1) AND (cliente_id &lt;= 6000))
</span></span><span style="display:flex;"><span>Execution Time: 108.245 ms</span></span></code></pre></div>
</div>
<p>Aquí PostgreSQL <strong>tiene el índice a mano y decide no usarlo</strong>, y hace bien:
para devolver el 60 % de la tabla, leerla de principio a fin es más barato que
saltar del índice a la tabla seiscientas mil veces. Un Seq Scan no es un fallo:
es la herramienta correcta cuando se devuelve mucha parte de la tabla (o la
tabla es diminuta).</p>
<p>(Con un 30 % de la tabla, por cierto, PostgreSQL seguía eligiendo
<code>Bitmap Heap Scan</code>. El punto de cruce depende de los datos; lo que importa es
que lo calcula él y que puedes comprobarlo en el plan.)</p>
<h2 id="regla-3-segunda-parte-cómo-une-tablas">Regla 3, segunda parte: cómo une tablas <a class="ancla" href="#regla-3-segunda-parte-c%c3%b3mo-une-tablas" aria-label="Enlace a esta sección">#</a></h2>
<p>Los tres algoritmos de unión que vas a ver siempre son estos, y PostgreSQL elige
según cuántas filas cree que entran.</p>
<p><strong>Nested Loop</strong> (bucle anidado): para cada fila de la tabla externa busca en la
interna. Ideal con pocas filas externas y un índice en la interna. Es lo que
vimos en la regla 2.</p>
<p><strong>Hash Join</strong>: construye una tabla hash con la tabla más pequeña y recorre la
grande una sola vez consultándola. Es el rey cuando se unen muchas filas. Aquí,
todos los clientes contra todos los pedidos:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>HashAggregate  (cost=27838.11..27838.21 rows=8 width=52) (actual time=533.080..533.087 rows=8 loops=1)
</span></span><span style="display:flex;"><span>  -&gt;  Hash Join  (cost=359.00..20338.11 rows=1000000 width=18) (actual time=2.681..341.616 rows=1000000 loops=1)
</span></span><span style="display:flex;"><span>        Hash Cond: (p.cliente_id = c.id)
</span></span><span style="display:flex;"><span>        -&gt;  Seq Scan on pedidos p  (cost=0.00..17353.00 rows=1000000 width=10) (actual time=0.006..128.027 rows=1000000 loops=1)
</span></span><span style="display:flex;"><span>        -&gt;  Hash  (cost=234.00..234.00 rows=10000 width=16) (actual time=2.593..2.595 rows=10000 loops=1)
</span></span><span style="display:flex;"><span>              Buckets: 16384  Batches: 1  Memory Usage: 597kB
</span></span><span style="display:flex;"><span>              -&gt;  Seq Scan on clientes c  (cost=0.00..234.00 rows=10000 width=16) (actual time=0.003..0.890 rows=10000 loops=1)
</span></span><span style="display:flex;"><span>Execution Time: 533.194 ms</span></span></code></pre></div>
</div>
<p>Se construye el hash con los 10 000 clientes (597 kB) y se recorren los
pedidos una vez. Fíjate en <code>Batches: 1</code>: significa que el hash cabió en memoria
(<code>work_mem</code>). Si ves <code>Batches</code> mayor que 1, el hash se ha desbordado a disco y
la unión se vuelve bastante más lenta.</p>
<p><strong>Merge Join</strong>: une dos entradas ya ordenadas por la clave de unión, avanzando
en paralelo por ambas. Es una buena opción cuando las dos entradas vienen
ordenadas «gratis», por ejemplo desde índices.</p>
<p>Una forma muy instructiva de aprender es <em>forzar</em> a PostgreSQL a elegir otro
algoritmo y comparar. En el laboratorio lo hago con
<code>SET enable_hashjoin = off;</code> y compañía (sólo para experimentar, nunca como
solución en producción). La misma consulta, tres algoritmos:</p>
<table>
  <thead>
      <tr>
          <th>Algoritmo</th>
          <th>Coste estimado</th>
          <th>Tiempo real</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Hash Join (elección de PostgreSQL)</td>
          <td>27 838</td>
          <td>533 ms</td>
      </tr>
      <tr>
          <td>Nested Loop (con <code>Memoize</code>)</td>
          <td>52 868</td>
          <td>664 ms</td>
      </tr>
      <tr>
          <td>Merge Join</td>
          <td>68 320</td>
          <td>887 ms</td>
      </tr>
  </tbody>
</table>
<p>El orden de los costes estimados coincide con el de los tiempos reales. Cuando
eso pasa, el planificador está bien informado. Cuando no, mira la regla 4.</p>
<p>El Nested Loop merece una mención: PostgreSQL 14 y posteriores colocan un nodo
<code>Memoize</code> delante del índice interno, que recuerda resultados ya buscados:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>-&gt;  Memoize  (cost=0.30..0.31 rows=1 width=16) (actual time=0.000..0.000 rows=1 loops=1000000)
</span></span><span style="display:flex;"><span>      Cache Key: p.cliente_id
</span></span><span style="display:flex;"><span>      Hits: 990000  Misses: 10000  Evictions: 0  Overflows: 0  Memory Usage: 1133kB</span></span></code></pre></div>
</div>
<p>Un millón de vueltas, 990 000 aciertos de caché y sólo 10 000 búsquedas reales
en el índice. Por eso un Nested Loop sobre un millón de filas no salió
catastrófico. Mira el <code>loops=1000000</code> y recuerda la regla 2.</p>
<p>El Merge Join, por su parte, necesita las dos entradas ordenadas. Aquí las
obtiene de dos <code>Index Scan</code>, y el de <code>pedidos</code> salta de una página a otra de la
tabla siguiendo el índice, lo que se nota en los casi un millón de accesos a
buffers (<code>shared hit=990160</code>).</p>
<h2 id="regla-4-compara-siempre-estimado-y-real">Regla 4: compara siempre estimado y real <a class="ancla" href="#regla-4-compara-siempre-estimado-y-real" aria-label="Enlace a esta sección">#</a></h2>
<p>Esta es la regla que más tiempo me ha ahorrado. En cada nodo tienes el <code>rows=</code>
que PostgreSQL <em>esperaba</em> y el <code>rows=</code> que <em>salió</em>. Si difieren en uno o dos
órdenes de magnitud, el problema no es el índice ni el algoritmo: es que el
planificador decide a ciegas con información equivocada.</p>
<p>Un ejemplo con tres filtros sobre <code>clientes</code> (provincia, municipio y código
postal):</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Seq Scan on clientes  (cost=0.00..309.00 rows=1 width=74) (actual time=0.015..0.749 rows=23 loops=1)
</span></span><span style="display:flex;"><span>  Filter: ((provincia = &#39;Provincia 1&#39;::text) AND (municipio = &#39;Municipio 7&#39;::text) AND (codigo_postal = &#39;00070&#39;::text))
</span></span><span style="display:flex;"><span>  Rows Removed by Filter: 9977</span></span></code></pre></div>
</div>
<p>Estimó 1 fila, salieron 23. Por qué: PostgreSQL asume que las columnas son
<strong>independientes</strong> y multiplica sus selectividades. Pero aquí cada código
postal pertenece a un único municipio y cada municipio a una única provincia,
así que los tres filtros dicen lo mismo y la selectividad real es mucho mayor
que el producto.</p>
<p>Dentro de una unión con <code>pedidos</code> y <code>lineas_pedido</code>, el error se arrastra y se
amplifica:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Aggregate  ...
</span></span><span style="display:flex;"><span>  -&gt;  Nested Loop  (cost=5.64..746.27 rows=286 width=10) (actual time=0.137..55.855 rows=6735 loops=1)
</span></span><span style="display:flex;"><span>        -&gt;  Nested Loop  (cost=5.21..684.97 rows=100 width=4) (actual time=0.048..5.643 rows=2245 loops=1)
</span></span><span style="display:flex;"><span>              -&gt;  Seq Scan on clientes c  (cost=0.00..309.00 rows=1 width=4) (actual time=0.014..1.071 rows=23 loops=1)</span></span></code></pre></div>
</div>
<p>Estimado 286 filas en la unión, reales 6 735: <strong>23 veces menos</strong>. En este caso
el plan sigue siendo razonable, pero con una estimación así de mala el
planificador puede elegir un Nested Loop donde un Hash Join sería mucho mejor.
Aquí hemos tenido suerte.</p>
<p>El arreglo no es un índice, sino darle al planificador información sobre la
correlación con <strong>estadísticas extendidas</strong>:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#66d9ef">CREATE</span> <span style="color:#66d9ef">STATISTICS</span> clientes_geo (dependencies, ndistinct)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">ON</span> provincia, municipio, codigo_postal <span style="color:#66d9ef">FROM</span> clientes;
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">ANALYZE</span> clientes;</span></span></code></pre></div>
</div>
<p><code>dependencies</code> es la que corrige los filtros de igualdad como este;
<code>ndistinct</code> ayuda con los <code>GROUP BY</code> sobre varias columnas. El resultado:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Seq Scan on clientes  (cost=0.00..309.00 rows=23 width=74) (actual time=0.024..1.043 rows=23 loops=1)
</span></span><span style="display:flex;"><span>...
</span></span><span style="display:flex;"><span>Nested Loop  (cost=5.64..9322.65 rows=6573 width=10) (actual time=0.060..14.631 rows=6735 loops=1)</span></span></code></pre></div>
</div>
<p>Estimado 23, real 23. En la unión, 6 573 estimadas frente a 6 735 reales.</p>
<p>Una advertencia de honestidad: en este laboratorio la <strong>forma</strong> del plan no
cambió, así que la consulta no mejora «gracias» a la estadística. Si compruebas
los números verás que pasa de 58 ms a 17 ms, pero eso es sobre todo caché: en
la primera salida el último nodo lee de fuera de <code>shared_buffers</code>
(<code>read=4047</code>) y en la segunda no. Estimar bien no garantiza un plan distinto;
lo que garantiza es que, cuando el plan <em>tenga</em> que cambiar, tome la decisión
con datos correctos.</p>
<h2 id="buffers-lenta-por-leer-o-lenta-por-trabajar">BUFFERS: ¿lenta por leer o lenta por trabajar? <a class="ancla" href="#buffers-lenta-por-leer-o-lenta-por-trabajar" aria-label="Enlace a esta sección">#</a></h2>
<p><code>BUFFERS</code> cuenta las páginas (de 8 kB) que toca cada nodo:</p>
<ul>
<li><strong><code>shared hit</code></strong>: la página ya estaba en la caché de PostgreSQL
(<code>shared_buffers</code>).</li>
<li><strong><code>shared read</code></strong>: no estaba y hubo que pedirla fuera. Ojo, «fuera» puede ser
la caché del sistema operativo y no necesariamente el disco.</li>
</ul>
<p>El mismo <code>Seq Scan</code> sobre <code>pedidos</code>, recién arrancado el servidor y luego con
la tabla ya caliente:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>-- Frío (recién reiniciado)
</span></span><span style="display:flex;"><span>Seq Scan on pedidos ...
</span></span><span style="display:flex;"><span>  Buffers: shared read=7353
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>-- Caliente
</span></span><span style="display:flex;"><span>Seq Scan on pedidos ...
</span></span><span style="display:flex;"><span>  Buffers: shared hit=7353</span></span></code></pre></div>
</div>
<p>Siempre las mismas 7 353 páginas, que son las que ocupa la tabla. Lo que cambia
es de dónde salen. Esto te ayuda a distinguir dos tipos de lentitud: la que
viene de <strong>leer</strong> mucho (muchos <code>read</code>) y la que viene de <strong>trabajar</strong> mucho
(muchos <code>hit</code> y mucho tiempo de CPU). Y te avisa de un clásico: la consulta que
«va rápido la segunda vez» no está arreglada, está en caché.</p>
<h2 id="el-n1-visto-en-un-plan">El N+1, visto en un plan <a class="ancla" href="#el-n1-visto-en-un-plan" aria-label="Enlace a esta sección">#</a></h2>
<p>Si vienes de ORMs, el N+1 es el patrón de ejecutar una consulta por cada fila
de otra. Dentro de PostgreSQL tiene su versión: la subconsulta correlacionada.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span> p.id,
</span></span><span style="display:flex;"><span>       (<span style="color:#66d9ef">SELECT</span> <span style="color:#66d9ef">sum</span>(l.cantidad <span style="color:#f92672">*</span> l.precio)
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">FROM</span> lineas_pedido l
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">WHERE</span> l.pedido_id <span style="color:#f92672">=</span> p.id) <span style="color:#66d9ef">AS</span> importe
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">FROM</span> pedidos p
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">WHERE</span> p.cliente_id <span style="color:#66d9ef">BETWEEN</span> <span style="color:#ae81ff">4242</span> <span style="color:#66d9ef">AND</span> <span style="color:#ae81ff">4261</span>;</span></span></code></pre></div>
</div>
<p>El plan:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Bitmap Heap Scan on pedidos p  (cost=28.27..20915.11 rows=1936 width=36) (actual time=0.629..43.262 rows=2000 loops=1)
</span></span><span style="display:flex;"><span>  SubPlan 1
</span></span><span style="display:flex;"><span>    -&gt;  Aggregate  (cost=8.51..8.52 rows=1 width=32) (actual time=0.018..0.018 rows=1 loops=2000)
</span></span><span style="display:flex;"><span>          -&gt;  Index Scan using idx_lineas_pedido on lineas_pedido l  (cost=0.43..8.48 rows=3 width=10) (actual time=0.016..0.017 rows=3 loops=2000)
</span></span><span style="display:flex;"><span>Execution Time: 43.501 ms</span></span></code></pre></div>
</div>
<p><code>loops=2000</code>: el <code>SubPlan</code> se ejecuta una vez por pedido. Cada vuelta cuesta
0,018 ms, que parece nada, pero 0,018 × 2000 = <strong>36 ms</strong> de los 43,5 totales.
Es la regla 2 en acción. La versión con <code>JOIN</code> y <code>GROUP BY</code> hace el mismo
trabajo en 11,6 ms.</p>
<p>Dentro de la base de datos la diferencia es moderada porque no hay red entre
medias. El N+1 «de verdad» es el que hace la aplicación: una consulta por
pedido, cada una con su viaje de ida y vuelta al servidor. El laboratorio lo
mide con <code>n_mas_1.sh</code>, que lanza 2 000 consultas sueltas y luego una sola con
<code>JOIN</code>, ambas desde una única sesión de <code>psql</code> y por socket Unix local (la red
más rápida que existe):</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-console" data-lang="console"><span style="display:flex;"><span>ignacio@zeus:~/blog-public-code/lab-explain$ ./n_mas_1.sh
</span></span><span style="display:flex;"><span>Pedidos a calcular: 2000
</span></span><span style="display:flex;"><span><span style="color:#960050;background-color:#1e0010">
</span></span></span><span style="display:flex;"><span>== N+1: 2000 consultas sueltas
</span></span><span style="display:flex;"><span>real	0m0.226s
</span></span><span style="display:flex;"><span><span style="color:#960050;background-color:#1e0010">
</span></span></span><span style="display:flex;"><span>== Una sola consulta con JOIN
</span></span><span style="display:flex;"><span>real	0m0.056s
</span></span></code></pre></div>
</div>
<p>En cinco ejecuciones, el N+1 tardó entre 226 y 256 ms y el <code>JOIN</code> entre 51 y
93 ms: entre 2,5 y 4,5 veces más lento, <strong>sin red de por medio</strong>. Con un servidor remoto,
cada viaje cuesta además la latencia de red, y la diferencia crece a base de
bien.</p>
<p>Si leíste la serie de GraphQL, ya me has visto dar la lata con el N+1 y con
<code>DataLoader</code>. Aquí lo único que cambia es dónde mirar: en el plan, un <code>loops</code>
enorme.</p>
<h2 id="tres-autopsias-el-índice-existe-y-postgresql-pasa-de-él">Tres autopsias: el índice existe y PostgreSQL pasa de él <a class="ancla" href="#tres-autopsias-el-%c3%adndice-existe-y-postgresql-pasa-de-%c3%a9l" aria-label="Enlace a esta sección">#</a></h2>
<p>Volvamos a la pregunta del principio.</p>
<h3 id="1-función-aplicada-a-la-columna-indexada">1. Función aplicada a la columna indexada <a class="ancla" href="#1-funci%c3%b3n-aplicada-a-la-columna-indexada" aria-label="Enlace a esta sección">#</a></h3>
<p>Hay un índice sobre <code>pedidos.fecha</code>. Esta consulta busca los pedidos de un día:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span> <span style="color:#f92672">*</span> <span style="color:#66d9ef">FROM</span> pedidos <span style="color:#66d9ef">WHERE</span> to_char(fecha, <span style="color:#e6db74">&#39;YYYY-MM-DD&#39;</span>) <span style="color:#f92672">=</span> <span style="color:#e6db74">&#39;2024-03-15&#39;</span>;</span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Seq Scan on pedidos  (cost=0.00..24853.00 rows=5000 width=27) (actual time=0.104..459.164 rows=726 loops=1)
</span></span><span style="display:flex;"><span>  Filter: (to_char((fecha)::timestamp with time zone, &#39;YYYY-MM-DD&#39;::text) = &#39;2024-03-15&#39;::text)
</span></span><span style="display:flex;"><span>  Rows Removed by Filter: 999274
</span></span><span style="display:flex;"><span>Execution Time: 459.294 ms</span></span></code></pre></div>
</div>
<p>El índice está ordenado por <code>fecha</code>, no por <code>to_char(fecha, ...)</code>. Para
PostgreSQL esa función es una caja negra: no puede deducir en qué parte del
índice caería el resultado, así que no tiene más remedio que calcularla fila a
fila sobre el millón de filas.</p>
<p>Fíjate también en <code>rows=5000</code> frente a 726 reales: ante una expresión opaca
PostgreSQL no tiene estadísticas y usa una estimación por defecto (un 0,5 % de
la tabla).</p>
<p>La solución es escribir la condición sobre la columna «desnuda»:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span> <span style="color:#f92672">*</span> <span style="color:#66d9ef">FROM</span> pedidos <span style="color:#66d9ef">WHERE</span> fecha <span style="color:#f92672">=</span> DATE <span style="color:#e6db74">&#39;2024-03-15&#39;</span>;</span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Bitmap Heap Scan on pedidos  (cost=9.94..2118.47 rows=712 width=27) (actual time=0.235..1.202 rows=726 loops=1)
</span></span><span style="display:flex;"><span>  Recheck Cond: (fecha = &#39;2024-03-15&#39;::date)
</span></span><span style="display:flex;"><span>  -&gt;  Bitmap Index Scan on idx_pedidos_fecha  (cost=0.00..9.77 rows=712 width=0) (actual time=0.141..0.141 rows=726 loops=1)
</span></span><span style="display:flex;"><span>Execution Time: 1.272 ms</span></span></code></pre></div>
</div>
<p>459 ms → 1,3 ms, y además la estimación (712) ya se parece a la realidad (726).
Es la misma regla para <code>date_trunc</code>, <code>lower()</code>, <code>extract()</code> o un cast sobre la
columna: si la envuelves en una función, el índice normal no la entiende. O
reescribes la condición, o creas un índice sobre la expresión.</p>
<h3 id="2-tipos-que-no-encajan">2. Tipos que no encajan <a class="ancla" href="#2-tipos-que-no-encajan" aria-label="Enlace a esta sección">#</a></h3>
<p><code>pedidos.cliente_id</code> es un <code>integer</code> con índice. ¿Y si lo comparamos con un
número con decimales, como hacen algunos drivers o ORMs al enviar parámetros?</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span> <span style="color:#f92672">*</span> <span style="color:#66d9ef">FROM</span> pedidos <span style="color:#66d9ef">WHERE</span> cliente_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">4242</span>.<span style="color:#ae81ff">0</span>;</span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Seq Scan on pedidos  (cost=0.00..22353.00 rows=5000 width=27) (actual time=12.194..114.285 rows=103 loops=1)
</span></span><span style="display:flex;"><span>  Filter: ((cliente_id)::numeric = 4242.0)
</span></span><span style="display:flex;"><span>  Rows Removed by Filter: 999897
</span></span><span style="display:flex;"><span>Execution Time: 114.316 ms</span></span></code></pre></div>
</div>
<p>La pista está en el <code>Filter</code>: <code>(cliente_id)::numeric</code>. Como <code>4242.0</code> es un
<code>numeric</code>, PostgreSQL convierte la <strong>columna</strong> a <code>numeric</code> para poder comparar,
y un índice sobre <code>integer</code> no sirve para una comparación sobre <code>numeric</code>.
Misma consulta con el literal correcto:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-text" data-lang="text"><span style="display:flex;"><span>Bitmap Heap Scan on pedidos  (cost=5.20..371.46 rows=100 width=27) (actual time=0.032..0.138 rows=103 loops=1)
</span></span><span style="display:flex;"><span>  -&gt;  Bitmap Index Scan on idx_pedidos_cliente  (cost=0.00..5.17 rows=100 width=0) (actual time=0.015..0.015 rows=103 loops=1)
</span></span><span style="display:flex;"><span>Execution Time: 0.161 ms</span></span></code></pre></div>
</div>
<p>114 ms → 0,16 ms. Cuando un índice «no se usa» y no sabes por qué, lee el
<code>Filter</code> con atención: un <code>::tipo</code> pegado a tu columna delata este problema.</p>
<h3 id="3-poca-selectividad">3. Poca selectividad <a class="ancla" href="#3-poca-selectividad" aria-label="Enlace a esta sección">#</a></h3>
<p>Con un índice sobre <code>estado</code>, la misma columna con tres valores distintos
produce tres comportamientos distintos:</p>
<table>
  <thead>
      <tr>
          <th>Condición</th>
          <th>Filas</th>
          <th>Plan elegido</th>
          <th>Tiempo</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><code>estado = 'entregado'</code></td>
          <td>899 663 (90 %)</td>
          <td>Seq Scan</td>
          <td>128 ms</td>
      </tr>
      <tr>
          <td><code>estado = 'pendiente'</code></td>
          <td>25 177 (2,5 %)</td>
          <td>Bitmap Heap Scan</td>
          <td>17 ms</td>
      </tr>
      <tr>
          <td><code>estado = 'devuelto'</code></td>
          <td>4 895 (0,5 %)</td>
          <td>Index Scan</td>
          <td>2,9 ms</td>
      </tr>
  </tbody>
</table>
<p>No hay nada roto. El mismo índice sirve muy bien para el 0,5 % y es inútil
para el 90 %, y PostgreSQL decide en cada consulta comparando costes con las
estadísticas de la columna. Si alguna vez te preguntas por qué el índice de
una columna con pocos valores distintos «no funciona», probablemente sí
funciona, pero para los valores raros.</p>
<h2 id="herramientas-para-no-leer-planes-a-mano">Herramientas para no leer planes a mano <a class="ancla" href="#herramientas-para-no-leer-planes-a-mano" aria-label="Enlace a esta sección">#</a></h2>
<p>Cuando el plan es largo, lo cómodo es visualizarlo:</p>
<ul>
<li><a href="https://explain.depesz.com/" target="_blank" rel="noopener">explain.depesz.com</a>: pegas el plan y marca en
colores los nodos que más tiempo consumen.</li>
<li><a href="https://explain.dalibo.com/" target="_blank" rel="noopener">explain.dalibo.com</a>: visualización en forma de
árbol y diagrama. Está construido sobre
<a href="https://github.com/dalibo/pev2" target="_blank" rel="noopener">PEV2</a>, que es software libre.</li>
</ul>
<p>Un consejo de higiene antes de pegar nada en un servicio público: el plan
contiene nombres de tablas, de columnas e incluso valores literales de tus
consultas. Si trabajas con datos internos, anonimiza el plan o usa una
herramienta que puedas alojar tú.</p>
<h2 id="qué-cambia-en-postgresql-18">Qué cambia en PostgreSQL 18 <a class="ancla" href="#qu%c3%a9-cambia-en-postgresql-18" aria-label="Enlace a esta sección">#</a></h2>
<p>Todas las salidas de esta entrada son de PostgreSQL 16.15. Las versiones
recientes mejoran <code>EXPLAIN</code>: en PostgreSQL 18, <code>EXPLAIN ANALYZE</code> incluye
<code>BUFFERS</code> por defecto, y los nodos de índice muestran una línea
<code>Index Searches</code> con el número de recorridos que hizo el índice (más detalle en
<a href="https://www.pgmustard.com/blog/what-do-index-searches-in-explain-mean" target="_blank" rel="noopener">el artículo de pgMustard</a>).
La forma de leer el plan es la misma; sólo verás alguna línea más.</p>
<h2 id="checklist-de-cinco-preguntas">Checklist de cinco preguntas <a class="ancla" href="#checklist-de-cinco-preguntas" aria-label="Enlace a esta sección">#</a></h2>
<p>Ante cualquier plan, en este orden:</p>
<ol>
<li><strong>¿Dónde está el tiempo?</strong> Busca el nodo con mayor <code>actual time</code>
<strong>multiplicado por <code>loops</code></strong>. Ahí es donde optimizar.</li>
<li><strong>¿Coinciden <code>rows</code> estimado y real?</strong> Si difieren por órdenes de magnitud,
revisa estadísticas (<code>ANALYZE</code>, <code>CREATE STATISTICS</code>) antes de tocar índices.</li>
<li><strong>¿Cómo accede a la tabla?</strong> Un <code>Seq Scan</code> con un <code>Rows Removed by Filter</code>
enorme y pocas filas devueltas pide un índice. Con muchas filas devueltas,
está bien.</li>
<li><strong>¿Hay algo raro pegado a mi columna en el <code>Filter</code>/<code>Index Cond</code>?</strong> Una
función, un <code>::cast</code>&hellip; eso explica un índice ignorado.</li>
<li><strong>¿Es lectura o trabajo?</strong> Mira <code>BUFFERS</code>: muchos <code>read</code> indican que hay
que traer datos de fuera; muchos <code>hit</code> con mucho tiempo, que la CPU está
trabajando de más.</li>
</ol>
<h2 id="para-quedarte-con-algo">Para quedarte con algo <a class="ancla" href="#para-quedarte-con-algo" aria-label="Enlace a esta sección">#</a></h2>
<ul>
<li><code>EXPLAIN</code> estima, <code>EXPLAIN ANALYZE</code> ejecuta. Usa <code>BEGIN</code>/<code>ROLLBACK</code> con DML.</li>
<li>El plan se lee de dentro hacia fuera y el tiempo real es <strong>por vuelta</strong>.</li>
<li>Compara siempre estimado con real: ahí se esconde la mitad de los problemas.</li>
<li>Un <code>Seq Scan</code> no es malo por sí mismo.</li>
<li>Si un índice no se usa, mira el <code>Filter</code>: tipos, funciones y selectividad.</li>
</ul>
<p>Todo el código está en
<a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-explain" target="_blank" rel="noopener"><code>lab-explain/</code></a>
con las salidas de referencia en <code>salidas/</code>. Si lo ejecutas y te salen planes
distintos, fíjate en la forma, no en los milisegundos, y cuéntamelo: es la mejor
manera de aprender cuál fue la decisión del planificador.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_89956f4fb17100b7.png"/></item><item><title>El N+1 en el log, DataLoader y lo que pasa con la caché</title><link>https://www.igalvan.es/posts/2026/graphql-n-mas-1-dataloader-cache/</link><pubDate>Fri, 30 Oct 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/graphql-n-mas-1-dataloader-cache/</guid><description><![CDATA[<p>Tercera y última entrada de la serie. En la <a href="/posts/2026/graphql-para-gente-de-rest/">primera</a> está la teoría y en la <a href="/posts/2026/graphql-laboratorio-rest-vs-graphql/">segunda</a> el laboratorio: PostgreSQL con dos tablas, una API REST en FastAPI y una API GraphQL en Strawberry, las dos sobre el mismo <code>db.py</code>, y la base de datos escribiendo en su log cada consulta que recibe.</p>
<p>Allí comparé la ficha de un usuario y GraphQL salía ganando. Ahora cambio la pantalla.</p>
<h2 id="segunda-pantalla-el-listado">Segunda pantalla: el listado <a class="ancla" href="#segunda-pantalla-el-listado" aria-label="Enlace a esta sección">#</a></h2>
<p>El caso de uso: una tabla con cien usuarios, y para cada uno el importe de sus tres últimos pedidos. Es la pantalla de &ldquo;listado con un poco de detalle&rdquo; que tiene cualquier aplicación.</p>
<h3 id="en-rest">En REST <a class="ancla" href="#en-rest" aria-label="Enlace a esta sección">#</a></h3>
<p>En REST, para esta pantalla, no tengo nada. <code>/usuarios/{id}</code> y <code>/usuarios/{id}/pedidos</code> me obligan a hacer una petición para la lista y cien más para los pedidos, lo cual es el N+1 <strong>en HTTP</strong>, que es aún peor que en SQL.</p>
<p>Así que hago lo que hace todo el mundo: un endpoint para la pantalla.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_rest/main.py (añadido)</span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuarios</span>(
</span></span><span style="display:flex;"><span>    primeros: int <span style="color:#f92672">=</span> Query(<span style="color:#ae81ff">10</span>, ge<span style="color:#f92672">=</span><span style="color:#ae81ff">1</span>, le<span style="color:#f92672">=</span><span style="color:#ae81ff">100</span>),
</span></span><span style="display:flex;"><span>    pedidos: int <span style="color:#f92672">=</span> Query(<span style="color:#ae81ff">3</span>, ge<span style="color:#f92672">=</span><span style="color:#ae81ff">0</span>, le<span style="color:#f92672">=</span><span style="color:#ae81ff">10</span>),
</span></span><span style="display:flex;"><span>):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            SELECT u.id, u.nombre,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                   COALESCE(
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     json_agg(
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                       json_build_object(&#39;fecha&#39;, p.fecha, &#39;total&#39;, p.total)
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                       ORDER BY p.fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     ) FILTER (WHERE p.id IS NOT NULL),
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     &#39;[]&#39;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                   ) AS pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            FROM usuarios u
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            LEFT JOIN LATERAL (
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              SELECT * FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              WHERE usuario_id = u.id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ) p ON true
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            GROUP BY u.id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ORDER BY u.id
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (pedidos, primeros),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchall()</span></span></code></pre></div>
</div>
<p>Una sola consulta. El <code>LATERAL</code> es el truco de PostgreSQL para &ldquo;los N últimos de cada uno&rdquo;, y el <code>json_agg</code> 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 <code>estado</code> de los pedidos, hay que tocar el SQL.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~$ curl -s <span style="color:#e6db74">&#39;localhost:8000/usuarios?primeros=100&amp;pedidos=3&#39;</span> | jq <span style="color:#e6db74">&#39;.[0]&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;id&#34;</span>: 1,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 1&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;pedidos&#34;</span>: <span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-06-02&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: 44.1 <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2025-11-19&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: 173.25 <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2025-03-08&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: 12.9 <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">]</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span></span></span></code></pre></div>
</div>
<p>Y en el log de PostgreSQL:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT u.id, u.nombre, COALESCE<span style="color:#f92672">(</span>json_agg<span style="color:#f92672">(</span>...<span style="color:#f92672">))</span> AS pedidos FROM usuarios u LEFT JOIN LATERAL <span style="color:#f92672">(</span>...<span style="color:#f92672">)</span> ...</span></span></code></pre></div>
</div>
<p>Una línea.</p>
<h3 id="en-graphql-tal-cual-estaba">En GraphQL, tal cual estaba <a class="ancla" href="#en-graphql-tal-cual-estaba" aria-label="Enlace a esta sección">#</a></h3>
<p>En GraphQL no hay que escribir un endpoint nuevo. Solo necesito una query que devuelva varios usuarios; el campo <code>pedidos</code> ya existe en el tipo <code>Usuario</code>.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_graphql/main.py (añadido a Query)</span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuarios</span>(self, primeros: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Usuario]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios ORDER BY id LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (primeros,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> [Usuario(<span style="color:#f92672">**</span>f) <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas]</span></span></code></pre></div>
</div>
<p>Y el cliente pide:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~$ curl -s localhost:8001/graphql <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -H <span style="color:#e6db74">&#39;Content-Type: application/json&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -d <span style="color:#e6db74">&#39;{&#34;query&#34;: &#34;{ usuarios(primeros: 100) { nombre pedidos(ultimos: 3) { total } } }&#34;}&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  | jq <span style="color:#e6db74">&#39;.data.usuarios[0]&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 1&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;pedidos&#34;</span>: <span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;44.10&#34;</span> <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;173.25&#34;</span> <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;12.90&#34;</span> <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">]</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span></span></span></code></pre></div>
</div>
<p>Funciona, la respuesta es perfecta, el cliente ha obtenido exactamente lo que quería sin que yo escribiera un endpoint. Ahora el log:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios ORDER BY id LIMIT <span style="color:#ae81ff">100</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">1</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">2</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">3</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>...
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">100</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span></span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~/lab-graphql$ podman compose logs db | grep -c <span style="color:#e6db74">&#39;FROM pedidos WHERE usuario_id&#39;</span>
</span></span><span style="display:flex;"><span><span style="color:#ae81ff">100</span></span></span></code></pre></div>
</div>
<p>Ciento 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. <code>Query.usuarios</code> resolvió la lista con una consulta. Después Strawberry recorrió los cien usuarios, y para cada uno, como el cliente había pedido <code>pedidos</code>, llamó a <code>Usuario.pedidos</code>, que hace su consulta con <code>self.id</code>. Cien veces. El resolver de <code>pedidos</code> 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 <a href="/posts/2026/explain-analyze-para-humanos/">una entrada sobre EXPLAIN ANALYZE</a>.)</p>
<p>En REST esto no me pasó porque <strong>yo</strong> 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.</p>
<h2 id="dataloader">DataLoader <a class="ancla" href="#dataloader" aria-label="Enlace a esta sección">#</a></h2>
<p>La solución es un patrón, no una librería concreta, aunque Strawberry trae una implementación. La idea: en vez de que <code>Usuario.pedidos</code> haga su consulta en el acto, le pide los pedidos a un <em>loader</em> 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 <strong>una</strong> consulta para todas. Después reparte los resultados a cada resolver que esperaba.</p>
<p>Para que eso funcione los resolvers tienen que ser asíncronos (si no, no hay &ldquo;quedarse esperando&rdquo;), así que <code>Usuario.pedidos</code> pasa a <code>async</code>.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_graphql/main.py (versión con DataLoader)</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> datetime
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> decimal
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> strawberry
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> FastAPI
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> strawberry.dataloader <span style="color:#f92672">import</span> DataLoader
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> strawberry.fastapi <span style="color:#f92672">import</span> GraphQLRouter
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Pedido</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    fecha: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>    total: decimal<span style="color:#f92672">.</span>Decimal
</span></span><span style="display:flex;"><span>    estado: str
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">cargar_pedidos</span>(claves: list[tuple[int, int]]) <span style="color:#f92672">-&gt;</span> list[list[Pedido]]:
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;&#34;&#34;Recibe pares (usuario_id, ultimos) y devuelve, en el mismo orden,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">    la lista de pedidos de cada uno.&#34;&#34;&#34;</span>
</span></span><span style="display:flex;"><span>    ids <span style="color:#f92672">=</span> [usuario_id <span style="color:#66d9ef">for</span> usuario_id, _ <span style="color:#f92672">in</span> claves]
</span></span><span style="display:flex;"><span>    tope <span style="color:#f92672">=</span> max(ultimos <span style="color:#66d9ef">for</span> _, ultimos <span style="color:#f92672">in</span> claves)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            SELECT id, usuario_id, fecha, total, estado
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            FROM (
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              SELECT *,
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     row_number() OVER (
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                       PARTITION BY usuario_id ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                     ) AS n
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">              WHERE usuario_id = ANY(</span><span style="color:#e6db74">%s</span><span style="color:#e6db74">)
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ) t
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            WHERE n &lt;= </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ORDER BY usuario_id, fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (ids, tope),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    por_usuario: dict[int, list[Pedido]] <span style="color:#f92672">=</span> {}
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas:
</span></span><span style="display:flex;"><span>        uid <span style="color:#f92672">=</span> f<span style="color:#f92672">.</span>pop(<span style="color:#e6db74">&#34;usuario_id&#34;</span>)
</span></span><span style="display:flex;"><span>        por_usuario<span style="color:#f92672">.</span>setdefault(uid, [])<span style="color:#f92672">.</span>append(Pedido(<span style="color:#f92672">**</span>f))
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> [por_usuario<span style="color:#f92672">.</span>get(uid, [])[:ultimos] <span style="color:#66d9ef">for</span> uid, ultimos <span style="color:#f92672">in</span> claves]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Usuario</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    nombre: str
</span></span><span style="display:flex;"><span>    email: str
</span></span><span style="display:flex;"><span>    direccion: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    telefono: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    fecha_alta: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pedidos</span>(self, info: strawberry<span style="color:#f92672">.</span>Info, ultimos: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Pedido]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> <span style="color:#66d9ef">await</span> info<span style="color:#f92672">.</span>context[<span style="color:#e6db74">&#34;pedidos&#34;</span>]<span style="color:#f92672">.</span>load((self<span style="color:#f92672">.</span>id, ultimos))
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Query</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(self, id: int) <span style="color:#f92672">-&gt;</span> Usuario <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios WHERE id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (id,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> Usuario(<span style="color:#f92672">**</span>fila) <span style="color:#66d9ef">if</span> fila <span style="color:#66d9ef">else</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuarios</span>(self, primeros: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Usuario]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios ORDER BY id LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (primeros,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> [Usuario(<span style="color:#f92672">**</span>f) <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">async</span> <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">contexto</span>():
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> {<span style="color:#e6db74">&#34;pedidos&#34;</span>: DataLoader(load_fn<span style="color:#f92672">=</span>cargar_pedidos)}
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>schema <span style="color:#f92672">=</span> strawberry<span style="color:#f92672">.</span>Schema(query<span style="color:#f92672">=</span>Query)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>app <span style="color:#f92672">=</span> FastAPI()
</span></span><span style="display:flex;"><span>app<span style="color:#f92672">.</span>include_router(
</span></span><span style="display:flex;"><span>    GraphQLRouter(schema, context_getter<span style="color:#f92672">=</span>contexto), prefix<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;/graphql&#34;</span>
</span></span><span style="display:flex;"><span>)</span></span></code></pre></div>
</div>
<p>Tres cosas que mirar:</p>
<ul>
<li><strong><code>cargar_pedidos</code> recibe una lista de claves y devuelve una lista de resultados en el mismo orden.</strong> Es el contrato de todo DataLoader. La clave es <code>(usuario_id, ultimos)</code> porque el campo tiene un argumento; si fuera solo <code>usuario_id</code>, un cliente que pidiera <code>ultimos: 3</code> para unos y <code>ultimos: 5</code> para otros rompería el agrupado.</li>
<li><strong>La consulta es la del <code>LATERAL</code> de REST, resuelta con una función de ventana.</strong> <code>row_number() OVER (PARTITION BY usuario_id ORDER BY fecha DESC)</code> numera los pedidos de cada usuario del más reciente al más antiguo, y <code>n &lt;= tope</code> se queda con los primeros. <code>ANY(%s)</code> recibe la lista de ids como un array de PostgreSQL; psycopg hace la conversión.</li>
<li><strong>El loader se crea en <code>contexto()</code>, una vez por petición HTTP.</strong> Si fuera global, cachearía resultados entre peticiones y servirías datos viejos. Ese es el error típico al empezar con DataLoader.</li>
</ul>
<p>El cliente no cambia nada. La misma consulta de antes, y el log:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios ORDER BY id LIMIT <span style="color:#ae81ff">100</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, usuario_id, fecha, total, estado FROM <span style="color:#f92672">(</span>SELECT *, row_number<span style="color:#f92672">()</span> OVER <span style="color:#f92672">(</span>...<span style="color:#f92672">)</span> AS n FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> ANY<span style="color:#f92672">(</span><span style="color:#e6db74">&#39;{1,2,3,...,100}&#39;</span><span style="color:#f92672">))</span> t WHERE n &lt;<span style="color:#f92672">=</span> <span style="color:#ae81ff">3</span> ORDER BY usuario_id, fecha DESC</span></span></code></pre></div>
</div>
<p>Dos consultas. Hemos vuelto al nivel de REST, con una diferencia que vale la pena notar: el endpoint REST servía a <em>esta</em> pantalla, y el loader sirve a cualquier consulta que pase por <code>Usuario.pedidos</code>, venga de donde venga. Es más trabajo la primera vez y menos las siguientes.</p>
<p>Y una pega que no voy a esconder: <code>cargar_pedidos</code> es <code>async</code> 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 <code>psycopg.AsyncConnection</code> o un <em>pool</em>. Lo dejo así para que el código sea comparable con el de REST línea a línea.</p>
<h2 id="la-caché-en-treinta-segundos">La caché, en treinta segundos <a class="ancla" href="#la-cach%c3%a9-en-treinta-segundos" aria-label="Enlace a esta sección">#</a></h2>
<p>Lo último que quedaba pendiente de la primera entrada. En REST, el endpoint de un usuario es un <code>GET</code> a una URL, y cachearlo es una cabecera:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_rest/main.py (modificado)</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> Response
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios/</span><span style="color:#e6db74">{id}</span><span style="color:#e6db74">&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(id: int, response: Response):
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">...</span>
</span></span><span style="display:flex;"><span>    response<span style="color:#f92672">.</span>headers[<span style="color:#e6db74">&#34;Cache-Control&#34;</span>] <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;public, max-age=60&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> fila</span></span></code></pre></div>
</div>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@zeus:~$ curl -sI localhost:8000/usuarios/42 | grep -i cache
</span></span><span style="display:flex;"><span>cache-control: public, max-age<span style="color:#f92672">=</span><span style="color:#ae81ff">60</span></span></span></code></pre></div>
</div>
<p>A 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.</p>
<p>En GraphQL, la misma ficha es un <code>POST /graphql</code> 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. <code>Cache-Control</code> 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 <code>GET</code> 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.</p>
<h2 id="lo-que-ha-enseñado-el-laboratorio">Lo que ha enseñado el laboratorio <a class="ancla" href="#lo-que-ha-ense%c3%b1ado-el-laboratorio" aria-label="Enlace a esta sección">#</a></h2>
<p>Con dos tablas y dos pantallas:</p>
<ul>
<li>Para una ficha, GraphQL gana en HTTP (una petición, respuesta a medida) y empata en la base de datos.</li>
<li>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.</li>
<li>La caché HTTP la tiene REST gratis y GraphQL no la tiene.</li>
</ul>
<p>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.</p>
<p>El código de las tres entradas está en Codeberg: <a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql" target="_blank" rel="noopener">https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql</a>.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_8d929e04e945a9b.png"/></item><item><title>Un laboratorio para comparar REST y GraphQL con los mismos datos</title><link>https://www.igalvan.es/posts/2026/graphql-laboratorio-rest-vs-graphql/</link><pubDate>Thu, 29 Oct 2026 00:00:00 +0000</pubDate><guid>https://www.igalvan.es/posts/2026/graphql-laboratorio-rest-vs-graphql/</guid><description><![CDATA[<p>En la <a href="/posts/2026/graphql-para-gente-de-rest/">entrada anterior</a> conté la teoría. Ahora toca verla. Voy a montar una base de datos pequeña, exponer los mismos datos con una API REST y con una API GraphQL, y comparar lo que pide el cliente, lo que recibe y lo que le llega a PostgreSQL por detrás.</p>
<p>Esta entrada es el montaje y la primera comparación, la amable. En la siguiente viene el N+1, que es donde se pone interesante.</p>
<p>El código completo está en Codeberg: <a href="https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql" target="_blank" rel="noopener">https://codeberg.org/igalvan/blog-public-code/src/branch/main/lab-graphql</a>.</p>
<h2 id="los-datos">Los datos <a class="ancla" href="#los-datos" aria-label="Enlace a esta sección">#</a></h2>
<p>Dos tablas: usuarios y pedidos. Nada más, porque con dos tablas ya se ven todos los problemas que quiero enseñar.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-sql" data-lang="sql"><span style="display:flex;"><span><span style="color:#75715e">-- init.sql
</span></span></span><span style="display:flex;"><span><span style="color:#66d9ef">CREATE</span> <span style="color:#66d9ef">TABLE</span> usuarios (
</span></span><span style="display:flex;"><span>  id         serial <span style="color:#66d9ef">PRIMARY</span> <span style="color:#66d9ef">KEY</span>,
</span></span><span style="display:flex;"><span>  nombre     text <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  email      text <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  direccion  text,
</span></span><span style="display:flex;"><span>  telefono   text,
</span></span><span style="display:flex;"><span>  fecha_alta date <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>
</span></span><span style="display:flex;"><span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">CREATE</span> <span style="color:#66d9ef">TABLE</span> pedidos (
</span></span><span style="display:flex;"><span>  id         serial <span style="color:#66d9ef">PRIMARY</span> <span style="color:#66d9ef">KEY</span>,
</span></span><span style="display:flex;"><span>  usuario_id int <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span> <span style="color:#66d9ef">REFERENCES</span> usuarios(id),
</span></span><span style="display:flex;"><span>  fecha      date <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  total      numeric(<span style="color:#ae81ff">10</span>,<span style="color:#ae81ff">2</span>) <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>,
</span></span><span style="display:flex;"><span>  estado     text <span style="color:#66d9ef">NOT</span> <span style="color:#66d9ef">NULL</span>
</span></span><span style="display:flex;"><span>);
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">INSERT</span> <span style="color:#66d9ef">INTO</span> usuarios (nombre, email, direccion, telefono, fecha_alta)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;Usuario &#39;</span> <span style="color:#f92672">||</span> i,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;usuario&#39;</span> <span style="color:#f92672">||</span> i <span style="color:#f92672">||</span> <span style="color:#e6db74">&#39;@example.org&#39;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;Calle Mayor, &#39;</span> <span style="color:#f92672">||</span> i,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#39;600&#39;</span> <span style="color:#f92672">||</span> lpad(i::text, <span style="color:#ae81ff">6</span>, <span style="color:#e6db74">&#39;0&#39;</span>),
</span></span><span style="display:flex;"><span>  date <span style="color:#e6db74">&#39;2024-01-01&#39;</span> <span style="color:#f92672">+</span> i <span style="color:#f92672">*</span> <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">FROM</span> generate_series(<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">100</span>) <span style="color:#66d9ef">AS</span> i;
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">INSERT</span> <span style="color:#66d9ef">INTO</span> pedidos (usuario_id, fecha, total, estado)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">SELECT</span>
</span></span><span style="display:flex;"><span>  <span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> (random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">99</span>)::int,
</span></span><span style="display:flex;"><span>  date <span style="color:#e6db74">&#39;2025-01-01&#39;</span> <span style="color:#f92672">+</span> (random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">600</span>)::int,
</span></span><span style="display:flex;"><span>  round((<span style="color:#ae81ff">5</span> <span style="color:#f92672">+</span> random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">200</span>)::numeric, <span style="color:#ae81ff">2</span>),
</span></span><span style="display:flex;"><span>  (ARRAY[<span style="color:#e6db74">&#39;pendiente&#39;</span>, <span style="color:#e6db74">&#39;enviado&#39;</span>, <span style="color:#e6db74">&#39;entregado&#39;</span>])[<span style="color:#ae81ff">1</span> <span style="color:#f92672">+</span> (random() <span style="color:#f92672">*</span> <span style="color:#ae81ff">2</span>)::int]
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">FROM</span> generate_series(<span style="color:#ae81ff">1</span>, <span style="color:#ae81ff">500</span>);</span></span></code></pre></div>
</div>
<p>Cien usuarios y quinientos pedidos repartidos al azar. Los usuarios tienen seis columnas a propósito: la gracia del over-fetching es que haya cosas que sobren.</p>
<h2 id="postgresql-en-podman">PostgreSQL en Podman <a class="ancla" href="#postgresql-en-podman" aria-label="Enlace a esta sección">#</a></h2>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-yaml" data-lang="yaml"><span style="display:flex;"><span><span style="color:#75715e"># compose.yaml</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">services</span>:
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">db</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">image</span>: <span style="color:#ae81ff">docker.io/library/postgres:17</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">environment</span>:
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">POSTGRES_USER</span>: <span style="color:#ae81ff">lab</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">POSTGRES_PASSWORD</span>: <span style="color:#ae81ff">lab</span>
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">POSTGRES_DB</span>: <span style="color:#ae81ff">tienda</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">ports</span>:
</span></span><span style="display:flex;"><span>      - <span style="color:#e6db74">&#34;5432:5432&#34;</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">volumes</span>:
</span></span><span style="display:flex;"><span>      - <span style="color:#ae81ff">./init.sql:/docker-entrypoint-initdb.d/init.sql:Z</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">command</span>: [<span style="color:#e6db74">&#34;postgres&#34;</span>, <span style="color:#e6db74">&#34;-c&#34;</span>, <span style="color:#e6db74">&#34;log_statement=all&#34;</span>]</span></span></code></pre></div>
</div>
<p>Dos detalles. El <code>:Z</code> del volumen es para que SELinux deje al contenedor leer el fichero; si no usas SELinux, no estorba. Y <code>log_statement=all</code> hace que PostgreSQL escriba en su log <strong>todas</strong> las consultas que recibe. En producción es una barbaridad; aquí es el instrumento de medida de toda la serie.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ podman compose up -d
</span></span><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ podman compose logs db | tail -n <span style="color:#ae81ff">3</span>
</span></span><span style="display:flex;"><span>db  | 2026-10-27 18:02:11.431 UTC <span style="color:#f92672">[</span>1<span style="color:#f92672">]</span> LOG:  database system is ready to accept connections</span></span></code></pre></div>
</div>
<p>Si en algún momento quieres empezar de cero, <code>podman compose down -v</code> borra también el volumen de datos y el <code>init.sql</code> se vuelve a ejecutar al arrancar.</p>
<h2 id="el-acceso-a-datos-compartido">El acceso a datos, compartido <a class="ancla" href="#el-acceso-a-datos-compartido" aria-label="Enlace a esta sección">#</a></h2>
<p>Las dos APIs van a usar exactamente el mismo módulo para hablar con la base de datos. Si no, la comparación está trucada.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># db.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> psycopg
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> psycopg.rows <span style="color:#f92672">import</span> dict_row
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>DSN <span style="color:#f92672">=</span> <span style="color:#e6db74">&#34;postgresql://lab:lab@localhost:5432/tienda&#34;</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">conectar</span>():
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> psycopg<span style="color:#f92672">.</span>connect(DSN, row_factory<span style="color:#f92672">=</span>dict_row)</span></span></code></pre></div>
</div>
<p><code>dict_row</code> hace que cada fila venga como un diccionario con el nombre de las columnas, que es lo que FastAPI y Strawberry quieren recibir.</p>
<p>La estructura del repositorio queda así:</p>
<div class="codeblock"><pre tabindex="0"><code>lab-graphql/
├── compose.yaml
├── init.sql
├── db.py
├── api_rest/
│   └── main.py
└── api_graphql/
    └── main.py</code></pre>
</div>
<p>Un aviso que me costó un rato: la carpeta del servidor GraphQL <strong>no</strong> puede llamarse <code>graphql</code>. Strawberry depende de una librería que se llama exactamente así, y un directorio con ese nombre en el directorio de trabajo la tapa. De ahí el <code>api_graphql</code>.</p>
<p>Dependencias, en un entorno virtual:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ python3 -m venv .venv <span style="color:#f92672">&amp;&amp;</span> source .venv/bin/activate
</span></span><span style="display:flex;"><span><span style="color:#f92672">(</span>.venv<span style="color:#f92672">)</span> ignacio@milab:~/lab-graphql$ pip install fastapi <span style="color:#e6db74">&#34;uvicorn[standard]&#34;</span> <span style="color:#e6db74">&#34;psycopg[binary]&#34;</span> strawberry-graphql</span></span></code></pre></div>
</div>
<h2 id="la-api-rest">La API REST <a class="ancla" href="#la-api-rest" aria-label="Enlace a esta sección">#</a></h2>
<p>Dos endpoints, los dos de la entrada anterior. FastAPI porque es lo que menos ruido mete.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_rest/main.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> FastAPI, HTTPException, Query
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>app <span style="color:#f92672">=</span> FastAPI()
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios/</span><span style="color:#e6db74">{id}</span><span style="color:#e6db74">&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(id: int):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;SELECT * FROM usuarios WHERE id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (id,)
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">if</span> fila <span style="color:#f92672">is</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">raise</span> HTTPException(<span style="color:#ae81ff">404</span>, <span style="color:#e6db74">&#34;Usuario no encontrado&#34;</span>)
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">return</span> fila
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@app.get</span>(<span style="color:#e6db74">&#34;/usuarios/</span><span style="color:#e6db74">{id}</span><span style="color:#e6db74">/pedidos&#34;</span>)
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pedidos</span>(id: int, ultimos: int <span style="color:#f92672">=</span> Query(<span style="color:#ae81ff">10</span>, ge<span style="color:#f92672">=</span><span style="color:#ae81ff">1</span>, le<span style="color:#f92672">=</span><span style="color:#ae81ff">100</span>)):
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>            <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            SELECT * FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            WHERE usuario_id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">            &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>            (id, ultimos),
</span></span><span style="display:flex;"><span>        )<span style="color:#f92672">.</span>fetchall()</span></span></code></pre></div>
</div>
<p><code>/usuarios/42</code> devuelve el usuario entero, con sus seis campos, porque así es como se diseñan los endpoints REST: el servidor decide la forma. <code>/usuarios/42/pedidos?ultimos=3</code> devuelve los pedidos enteros, cuatro campos cada uno.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">(</span>.venv<span style="color:#f92672">)</span> ignacio@milab:~/lab-graphql$ uvicorn api_rest.main:app --port <span style="color:#ae81ff">8000</span></span></span></code></pre></div>
</div>
<h2 id="la-api-graphql">La API GraphQL <a class="ancla" href="#la-api-graphql" aria-label="Enlace a esta sección">#</a></h2>
<p>Strawberry define el esquema con clases de Python y anotaciones de tipo. Compáralo con el SDL de la entrada anterior: es lo mismo, escrito en otro sitio.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-python" data-lang="python"><span style="display:flex;"><span><span style="color:#75715e"># api_graphql/main.py</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> datetime
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> decimal
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">import</span> strawberry
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> fastapi <span style="color:#f92672">import</span> FastAPI
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> strawberry.fastapi <span style="color:#f92672">import</span> GraphQLRouter
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">from</span> db <span style="color:#f92672">import</span> conectar
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Pedido</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    fecha: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>    total: decimal<span style="color:#f92672">.</span>Decimal
</span></span><span style="display:flex;"><span>    estado: str
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Usuario</span>:
</span></span><span style="display:flex;"><span>    id: int
</span></span><span style="display:flex;"><span>    nombre: str
</span></span><span style="display:flex;"><span>    email: str
</span></span><span style="display:flex;"><span>    direccion: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    telefono: str <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>    fecha_alta: datetime<span style="color:#f92672">.</span>date
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">pedidos</span>(self, ultimos: int <span style="color:#f92672">=</span> <span style="color:#ae81ff">10</span>) <span style="color:#f92672">-&gt;</span> list[Pedido]:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            filas <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;&#34;&#34;
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                SELECT id, fecha, total, estado FROM pedidos
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                WHERE usuario_id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                ORDER BY fecha DESC
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                LIMIT </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">
</span></span></span><span style="display:flex;"><span><span style="color:#e6db74">                &#34;&#34;&#34;</span>,
</span></span><span style="display:flex;"><span>                (self<span style="color:#f92672">.</span>id, ultimos),
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchall()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> [Pedido(<span style="color:#f92672">**</span>f) <span style="color:#66d9ef">for</span> f <span style="color:#f92672">in</span> filas]
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span><span style="color:#a6e22e">@strawberry.type</span>
</span></span><span style="display:flex;"><span><span style="color:#66d9ef">class</span> <span style="color:#a6e22e">Query</span>:
</span></span><span style="display:flex;"><span>    <span style="color:#a6e22e">@strawberry.field</span>
</span></span><span style="display:flex;"><span>    <span style="color:#66d9ef">def</span> <span style="color:#a6e22e">usuario</span>(self, id: int) <span style="color:#f92672">-&gt;</span> Usuario <span style="color:#f92672">|</span> <span style="color:#66d9ef">None</span>:
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">with</span> conectar() <span style="color:#66d9ef">as</span> con:
</span></span><span style="display:flex;"><span>            fila <span style="color:#f92672">=</span> con<span style="color:#f92672">.</span>execute(
</span></span><span style="display:flex;"><span>                <span style="color:#e6db74">&#34;SELECT * FROM usuarios WHERE id = </span><span style="color:#e6db74">%s</span><span style="color:#e6db74">&#34;</span>, (id,)
</span></span><span style="display:flex;"><span>            )<span style="color:#f92672">.</span>fetchone()
</span></span><span style="display:flex;"><span>        <span style="color:#66d9ef">return</span> Usuario(<span style="color:#f92672">**</span>fila) <span style="color:#66d9ef">if</span> fila <span style="color:#66d9ef">else</span> <span style="color:#66d9ef">None</span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>schema <span style="color:#f92672">=</span> strawberry<span style="color:#f92672">.</span>Schema(query<span style="color:#f92672">=</span>Query)
</span></span><span style="display:flex;"><span>
</span></span><span style="display:flex;"><span>app <span style="color:#f92672">=</span> FastAPI()
</span></span><span style="display:flex;"><span>app<span style="color:#f92672">.</span>include_router(GraphQLRouter(schema), prefix<span style="color:#f92672">=</span><span style="color:#e6db74">&#34;/graphql&#34;</span>)</span></span></code></pre></div>
</div>
<p>Fíjate en dónde está cada consulta SQL. <code>Query.usuario</code> es un resolver: va a por el usuario. <code>Usuario.pedidos</code> es <strong>otro</strong> resolver, que se ejecuta solo si el cliente pide el campo <code>pedidos</code>, y que va a por los pedidos de ese usuario concreto (<code>self.id</code>). Los campos simples (<code>nombre</code>, <code>email</code>…) no tienen resolver: Strawberry los lee directamente del objeto.</p>
<p>Esto es exactamente la estructura que en la entrada anterior llamé &ldquo;un controlador por campo&rdquo;. Guárdate la imagen para la siguiente entrada.</p>
<p>Dos cosas de Strawberry que conviene saber: convierte los nombres a <em>camelCase</em> en el esquema, así que <code>fecha_alta</code> se pide como <code>fechaAlta</code>; y los tipos <code>date</code> y <code>Decimal</code> de Python los expone como escalares <code>Date</code> y <code>Decimal</code> sin que haya que hacer nada.</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span><span style="color:#f92672">(</span>.venv<span style="color:#f92672">)</span> ignacio@milab:~/lab-graphql$ uvicorn api_graphql.main:app --port <span style="color:#ae81ff">8001</span></span></span></code></pre></div>
</div>
<p>Con el servidor levantado, <code>http://localhost:8001/graphql</code> en el navegador abre GraphiQL, una consola para escribir consultas con autocompletado contra el esquema. Es lo que en REST sería el Swagger UI de FastAPI (<code>http://localhost:8000/docs</code>), con la diferencia de que aquí el autocompletado sale del esquema real, no de una descripción paralela.</p>
<h2 id="primera-pantalla-la-ficha-de-un-usuario">Primera pantalla: la ficha de un usuario <a class="ancla" href="#primera-pantalla-la-ficha-de-un-usuario" aria-label="Enlace a esta sección">#</a></h2>
<p>El caso de uso: una pantalla que muestra el nombre de un usuario y la fecha e importe de sus tres últimos pedidos. Nada más.</p>
<h3 id="en-rest">En REST <a class="ancla" href="#en-rest" aria-label="Enlace a esta sección">#</a></h3>
<p>Dos peticiones, porque son dos recursos:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~$ curl -s localhost:8000/usuarios/42 | jq
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;id&#34;</span>: 42,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 42&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;email&#34;</span>: <span style="color:#e6db74">&#34;usuario42@example.org&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;direccion&#34;</span>: <span style="color:#e6db74">&#34;Calle Mayor, 42&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;telefono&#34;</span>: <span style="color:#e6db74">&#34;600000042&#34;</span>,
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;fecha_alta&#34;</span>: <span style="color:#e6db74">&#34;2024-05-06&#34;</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>ignacio@milab:~$ curl -s <span style="color:#e6db74">&#39;localhost:8000/usuarios/42/pedidos?ultimos=3&#39;</span> | jq
</span></span><span style="display:flex;"><span><span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;id&#34;</span>: 317,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;usuario_id&#34;</span>: 42,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-07-14&#34;</span>,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;total&#34;</span>: 118.4,
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;estado&#34;</span>: <span style="color:#e6db74">&#34;entregado&#34;</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>  ...
</span></span><span style="display:flex;"><span><span style="color:#f92672">]</span></span></span></code></pre></div>
</div>
<p>De los seis campos del usuario, la pantalla usa uno. De los cinco de cada pedido, dos. Y el <code>usuario_id</code> de cada pedido es información que el cliente ya tenía: lo puso él en la URL.</p>
<h3 id="en-graphql">En GraphQL <a class="ancla" href="#en-graphql" aria-label="Enlace a esta sección">#</a></h3>
<p>Una petición, y el cliente escribe la forma de la respuesta:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~$ curl -s localhost:8001/graphql <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -H <span style="color:#e6db74">&#39;Content-Type: application/json&#39;</span> <span style="color:#ae81ff">\
</span></span></span><span style="display:flex;"><span>  -d <span style="color:#e6db74">&#39;{&#34;query&#34;: &#34;{ usuario(id: 42) { nombre pedidos(ultimos: 3) { fecha total } } }&#34;}&#39;</span> | jq
</span></span><span style="display:flex;"><span><span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>  <span style="color:#e6db74">&#34;data&#34;</span>: <span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>    <span style="color:#e6db74">&#34;usuario&#34;</span>: <span style="color:#f92672">{</span>
</span></span><span style="display:flex;"><span>      <span style="color:#e6db74">&#34;nombre&#34;</span>: <span style="color:#e6db74">&#34;Usuario 42&#34;</span>,
</span></span><span style="display:flex;"><span>      <span style="color:#e6db74">&#34;pedidos&#34;</span>: <span style="color:#f92672">[</span>
</span></span><span style="display:flex;"><span>        <span style="color:#f92672">{</span> <span style="color:#e6db74">&#34;fecha&#34;</span>: <span style="color:#e6db74">&#34;2026-07-14&#34;</span>, <span style="color:#e6db74">&#34;total&#34;</span>: <span style="color:#e6db74">&#34;118.40&#34;</span> <span style="color:#f92672">}</span>,
</span></span><span style="display:flex;"><span>        ...
</span></span><span style="display:flex;"><span>      <span style="color:#f92672">]</span>
</span></span><span style="display:flex;"><span>    <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span>  <span style="color:#f92672">}</span>
</span></span><span style="display:flex;"><span><span style="color:#f92672">}</span></span></span></code></pre></div>
</div>
<p>Ni un campo de más. Si mañana la pantalla necesita también el <code>estado</code>, el cliente lo añade a la consulta y ya está; nadie toca el servidor.</p>
<p>Si quieres medir el tamaño, es un <code>wc -c</code> al final de cada <code>curl</code>. Los números exactos dependen de los datos que haya generado el <code>random()</code>, pero la proporción es la que esperas: la respuesta GraphQL ocupa bastante menos de la mitad que las dos respuestas REST juntas.</p>
<h2 id="lo-que-ve-postgresql">Lo que ve PostgreSQL <a class="ancla" href="#lo-que-ve-postgresql" aria-label="Enlace a esta sección">#</a></h2>
<p>Aquí es donde el <code>log_statement=all</code> empieza a pagar el alquiler. Deja el log abierto en otra terminal:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>ignacio@milab:~/lab-graphql$ podman compose logs -f db</span></span></code></pre></div>
</div>
<p>Lanza las dos peticiones REST:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios WHERE id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT * FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span></span></span></code></pre></div>
</div>
<p>Y ahora la de GraphQL:</p>
<div class="codeblock"><div class="highlight"><pre tabindex="0" style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;"><code class="language-bash" data-lang="bash"><span style="display:flex;"><span>LOG:  statement: SELECT * FROM usuarios WHERE id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span>
</span></span><span style="display:flex;"><span>LOG:  statement: SELECT id, fecha, total, estado FROM pedidos WHERE usuario_id <span style="color:#f92672">=</span> <span style="color:#ae81ff">42</span> ORDER BY fecha DESC LIMIT <span style="color:#ae81ff">3</span></span></span></code></pre></div>
</div>
<p>Dos consultas en los dos casos. Para esta pantalla, lo único que cambia entre REST y GraphQL es la capa HTTP: una petición en vez de dos, y una respuesta a medida en vez de dos respuestas genéricas. La base de datos trabaja lo mismo.</p>
<p>(Si en el log ves <code>execute &lt;unnamed&gt;</code> en lugar de <code>statement</code>, es porque psycopg puede usar sentencias preparadas del lado del servidor; da igual para lo que estamos midiendo.)</p>
<h2 id="dónde-estamos">Dónde estamos <a class="ancla" href="#d%c3%b3nde-estamos" aria-label="Enlace a esta sección">#</a></h2>
<p>Hasta aquí GraphQL parece ganar sin despeinarse: menos peticiones, menos bytes, el cliente manda. Y para esta pantalla es verdad.</p>
<p>El problema es que la pantalla era de un usuario. En la <a href="/posts/2026/graphql-n-mas-1-dataloader-cache/">tercera entrada</a> pido cien usuarios con sus pedidos, con el mismo log abierto, y el resultado es bastante menos elegante.</p>
]]></description><media:thumbnail url="https://www.igalvan.es/og/base_hu_d7c5d2b15b24bf51.png"/></item></channel></rss>