<?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>Sql – El blog de Ignacio</title><link>https://www.igalvan.es/tags/sql/</link><description>Entradas de Sql en El blog de Ignacio</description><generator>Hugo -- gohugo.io</generator><language>es</language><copyright>Ignacio Galván Vitas</copyright><lastBuildDate>Wed, 04 Nov 2026 19:30:00 +0000</lastBuildDate><atom:link href="https://www.igalvan.es/tags/sql/index.xml" rel="self" type="application/rss+xml"/><icon>https://www.igalvan.es/logo.svg</icon><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></channel></rss>