{"canonical_url":"https://engineer.company/es/glossary/partitioning/","content_markdown":"# Particionamiento\n\n## Qué es\n\nEl particionamiento, también llamado particionamiento de tablas, almacena las\nfilas de una tabla lógica en varias tablas ordinarias. Cada una contiene las\nfilas cuya clave está dentro de sus límites, mientras las consultas y escrituras\nsiguen usando el mismo nombre de siempre. PostgreSQL, en el que se basa esta\npágina, llama particionamiento declarativo a su modalidad integrada: la tabla se\ndeclara particionada, con un método y una clave de partición, y cada partición\nse crea como una tabla propia.\n\nLa tabla particionada no contiene filas por sí misma. Una inserción se dirige a\nla partición cuyos límites corresponden a la clave, y una actualización que\ncambia la clave mueve la fila a la partición a la que ahora pertenece. Las\nparticiones comparten las columnas de la tabla padre, pero pueden tener sus\npropios índices, ajustes de almacenamiento y espacio de tablas; una partición\npuede, a su vez, particionarse.\n\nHay tres métodos. El particionamiento por rangos asigna a cada partición un\nintervalo de valores, normalmente fechas; el límite inferior se incluye y el\nsuperior no, de modo que, con intervalos 1–10 y 10–20, el valor 10 pertenece al\nsegundo. El particionamiento por listas enumera los valores que acepta cada\npartición, como un conjunto de códigos de país. El particionamiento por hash\nasigna a cada partición un módulo y un resto, y cada fila va a la partición cuyo\nresto coincide con el que deja el hash de su clave. Así se distribuyen las filas\nde manera uniforme cuando no hay un rango natural por el que dividirlas. Una\npartición predeterminada puede recoger los valores que no encajan en ninguna otra,\nsolo en el particionamiento por rangos y por listas.\n\nEl particionamiento ocurre dentro de un único servidor de base de datos. Dividir\nlos datos entre servidores separados, cada uno con su propia copia del esquema,\nes sharding, un paso mucho mayor. SQL Server y BigQuery tienen sus propias\nformas de particionamiento, con su propia sintaxis, y las ideas siguientes se\ntrasladan a ellos aunque los comandos sean distintos.\n\n## Por qué importa\n\nLa mayoría de las tablas grandes crecen por un extremo. Pedidos, lecturas,\nregistros y eventos llegan cada día, permanecen meses o años, y la mayoría de\nlas consultas piden la parte reciente. Sin particionamiento, todas las consultas\ntrabajan sobre una tabla y un conjunto de índices que siguen creciendo.\n\nCon una clave de partición que encaje con las consultas, el planificador puede\ndemostrar que la mayoría de las particiones no pueden contener una fila\ncoincidente y excluirlas por completo del plan. PostgreSQL lo llama poda de\nparticiones. Un informe de la semana pasada lee la partición de esa semana y\nnada más. La documentación añade una ventaja menos evidente: como las\nparticiones asumen la función de los niveles superiores del árbol de un índice,\nes más probable que las partes de los índices más utilizadas quepan en memoria.\n\nLa retirada de datos antiguos es lo que más cambia. Borrar de una sola tabla las\nfilas de un mes exige un `DELETE` largo que deja filas muertas para que `VACUUM` las\nlimpie. Con una partición por mes, la misma política de retención se aplica con\nun solo `DROP TABLE` o `DETACH PARTITION`. Según la documentación, esto es mucho más rápido que una\noperación masiva y evita por completo la sobrecarga de `VACUUM`. Una partición\nseparada sigue siendo una tabla ordinaria, así que se puede hacer una copia de\nseguridad o un resumen antes de eliminarla. Las particiones que apenas se leen\npueden alojarse en un almacenamiento más barato y lento.\n\nLa ventaja tiene un coste, y la documentación explica con claridad cuándo\ncompensa. Cada partición añade trabajo de planificación, y las ventajas\nnormalmente solo merecen la pena si, de otro modo, la tabla sería muy grande.\nComo regla orientativa, debería superar el tamaño de la memoria física del\nservidor de base de datos. El particionamiento tampoco cambia una cosa: una fila\npor la que compiten muchas transacciones sigue siendo una sola fila en una\npartición, bajo un único bloqueo.\n\n## Cómo se aplica en la práctica\n\nUna tabla `orders` dividida por mes según `created_at` es el caso más sencillo, en una nota\nsobre cómo escalar una base de datos antes de distribuirla mediante sharding,\nque dedica una sección a [particionar las tablas alrededor de una fila muy disputada](/es/notes/optimise-before-you-shard/). La clave primaria es `(id, created_at)` porque debe incluir la\ncolumna de partición. Una consulta que indica un rango de fechas solo lee las\nparticiones incluidas en él, los índices del mes actual siguen siendo lo\nbastante pequeños para residir en memoria y la política de retención se aplica con un solo\n`DETACH PARTITION` en lugar de un `DELETE` de millones de filas. El límite es igual de claro: el\nparticionamiento no acelera la fila disputada, y una consulta que no indica la\nclave lee todas las particiones.\n\nUn proyecto de mejora del rendimiento de PostgreSQL para una aplicación con\ncuentas de usuario, organizaciones cliente, datos geográficos y consumo diario\nde electricidad [dividió la tabla de electricidad en intervalos temporales](/es/portfolio/accelerated-postgresql-performance-by-10x/) por día y por mes, y utilizó particionamiento por hash para\nlos datos geográficos. Se combinó con índices GiST y compuestos y con consultas\nreescritas; el resultado conjunto fue que los tiempos de respuesta de las consultas se\ndividieron por 10 y la utilización de recursos se redujo un 40 %.\n\nA una escala mucho mayor, el particionamiento fue una técnica entre varias para\n[al menos 100 bases de datos en PostgreSQL, SQL Server y BigQuery](/es/portfolio/ran-100-postgresql-ms-sql-bigquery-warehouses/), con una gran cantidad de datos geográficos y de series temporales. El\nparticionamiento de series temporales formaba parte del diseño del esquema en\nPostgreSQL y SQL Server, y BigQuery utilizaba tablas particionadas por tiempo y\nagrupadas mediante clustering. Junto con índices espaciales, vistas\nmaterializadas y caché, los tiempos de respuesta de las consultas para esos\ndatos disminuyeron un 40–60 %.\n\n## Dónde surgen los problemas\n\nEl particionamiento traslada parte del trabajo del momento de la consulta al\ndiseño, y la mayoría de los problemas proceden de decisiones de diseño tomadas\nsin tener en cuenta las consultas.\n\n**Las inserciones empiezan a fallar el primer día de un mes nuevo.** Ninguna\npartición cubre el rango nuevo, y PostgreSQL rechaza una inserción en la tabla\npadre que no corresponde a ninguna partición existente. Cree las particiones con\nantelación desde un trabajo programado que genere el DDL, como sugiere la\ndocumentación, y configure una alerta cuando la partición más reciente se\nacerque a su final:\n\n```sql\nCREATE TABLE orders_2026_11\n  PARTITION OF orders\n  FOR VALUES FROM ('2026-11-01')\n              TO ('2026-12-01');\n```\n\nUna partición predeterminada evita los errores, pero las filas de todos los meses\nsin cobertura acaban juntas en esa única tabla. Al asociar una partición nueva\nmás adelante, se examina la partición predeterminada bajo un bloqueo `ACCESS EXCLUSIVE`, salvo que\nuna restricción `CHECK` en esta ya excluya el rango nuevo. Trate una partición predeterminada no vacía como una alarma.\n\n**Las consultas son más lentas después de particionar.** Las consultas\nhabituales no filtran por la clave de partición, de modo que cada una lee todas\nlas particiones y sus índices. Otra causa es el número de particiones: la\ndocumentación dice que el planificador funciona bien con hasta unos pocos miles,\nsiempre que las consultas habituales descarten todas salvo unas pocas, y que el\ntiempo y la memoria de planificación aumentan más allá de esa cifra. Elija la\nclave a partir de las cláusulas `WHERE` que ya escribe la aplicación, compruebe con\n`EXPLAIN` que solo aparecen las particiones esperadas y mantenga un número\nproporcionado. Una partición por cliente es una trampa habitual, porque la\ncantidad crece con el negocio; la documentación sugiere en su lugar\nparticionamiento por hash con un número razonable de particiones.\n\n**No se puede crear una clave primaria o una restricción de unicidad.** En una\ntabla particionada, una restricción de unicidad o una clave primaria debe incluir todas las columnas\nde la clave de partición, y esta no puede contener expresiones ni llamadas a\nfunciones. El índice de cada partición solo puede imponer la unicidad dentro de\nella. Añada la columna de la clave a la restricción, como hace la tabla `orders` de\nla nota con `(id, created_at)`.\n\n**Crear un índice en la tabla padre bloquea las escrituras durante mucho\ntiempo.** Un `CREATE INDEX` normal en la tabla padre impide las escrituras hasta que se\nhayan indexado todas las particiones, y la opción `CONCURRENTLY` funciona en cada\npartición, no en la tabla padre. Cree el índice con `ON ONLY` en la tabla padre, lo\nque lo deja marcado como no válido, construya el índice de cada partición con\n`CONCURRENTLY` y asocie cada uno mediante `ALTER INDEX ... ATTACH PARTITION`. Cuando todos los índices de las particiones\nestén asociados, el índice padre pasa a ser válido por sí solo.\n\n**Una tabla grande existente no puede convertirse directamente.** PostgreSQL no\nconvierte una tabla ordinaria en una particionada. Cree la tabla particionada\nnueva y asocie la tabla antigua como una de sus particiones. Antes de asociarla,\nañada una restricción `CHECK` que coincida con los límites de la partición, para\nevitar que la asociación examine toda la tabla mientras mantiene en ella un\nbloqueo `ACCESS EXCLUSIVE`.\n\n## Lecturas adicionales\n\n- [Particionamiento de tablas](https://www.postgresql.org/docs/current/ddl-partitioning.html) — el capítulo de PostgreSQL: los tres métodos, la poda, el mantenimiento,\n  las limitaciones y las buenas prácticas.\n- [CREATE TABLE](https://www.postgresql.org/docs/current/sql-createtable.html) — `PARTITION BY`, `PARTITION OF`, los límites de las particiones y la partición predeterminada.\n- [ALTER TABLE](https://www.postgresql.org/docs/current/sql-altertable.html) — `ATTACH PARTITION` y `DETACH PARTITION`, y los bloqueos de cada uno.\n- [CREATE INDEX](https://www.postgresql.org/docs/current/sql-createindex.html) — los índices de tablas particionadas, `ON ONLY` y la construcción con `CONCURRENTLY`.\n\n\u003chttps://engineer.company/es/glossary/partitioning/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Un solo nombre para tablas más pequeñas divididas por clave: las consultas omiten partes innecesarias y los datos antiguos se retiran con una sola orden.","formats":{"gemtext":"https://engineer.company/es/glossary/partitioning/index.gmi","gopher":"https://engineer.company/es/glossary/partitioning/gophermap","html":"https://engineer.company/es/glossary/partitioning/","json":"https://engineer.company/es/glossary/partitioning/index.json","markdown":"https://engineer.company/es/glossary/partitioning/index.md","pdf":"https://engineer.company/es/glossary/partitioning/index.pdf"},"kind":"page","language":"es","title":"¿Qué es el particionamiento?","url":"https://engineer.company/es/glossary/partitioning/","version":1}