Particionamiento por rango con pg_partman y autolimpieza en PostgreSQL
El problema del crecimiento descontrolado de datos
Todo administrador de bases de datos que haya gestionado un sistema con datos temporales (logs, eventos, métricas, transacciones históricas) se ha enfrentado al mismo dilema: las tablas crecen sin límite y el rendimiento de las consultas se degrada progresivamente. Los índices se vuelven enormes, los VACUUM tardan más, y las consultas que antes eran instantáneas ahora requieren escaneos secuenciales larguísimos. La solución clásica pasa por el particionamiento, una técnica que divide una tabla lógica en múltiples tablas físicas más pequeñas. Sin embargo, gestionar las particiones manualmente es tedioso y propenso a errores humanos: olvidar crear la partición del mes siguiente o dejar que los datos antiguos se acumulen indefinidamente son fallos comunes.
Aquí es donde entra pg_partman, una extensión de PostgreSQL que automatiza el ciclo de vida completo de las particiones. En este artículo técnico, exploraremos cómo configurar el particionamiento por rango (el más habitual para datos temporales) con pg_partman, y cómo implementar una política de autolimpieza que elimine automáticamente las particiones antiguas, liberando espacio y manteniendo la base de datos ágil.
Requisitos previos y configuración inicial
Antes de comenzar, asegúrate de tener PostgreSQL 12 o superior, ya que el particionamiento declarativo nativo (sintaxis PARTITION BY RANGE) es la base sobre la que trabaja pg_partman. Aunque la extensión soporta particionamiento por herencia, recomendamos encarecidamente el enfoque declarativo por su simplicidad y mejor integración con el planificador de consultas.
Primero, instalamos la extensión en la base de datos objetivo:
CREATE EXTENSION pg_partman;
Además, es necesario crear un esquema dedicado para la configuración de pg_partman (aunque puede usarse el esquema por defecto, es buena práctica aislarlo):
CREATE SCHEMA partman;
ALTER EXTENSION pg_partman SET SCHEMA partman;
Por último, añadimos la configuración en postgresql.conf para que el proceso de mantenimiento automático funcione (lo veremos más adelante):
shared_preload_libraries = 'pg_partman_bgw'
Tras reiniciar el servicio, crearemos la tabla particionada base.
Creando una tabla particionada por rango con pg_partman
Vamos a simular un caso típico: una tabla de eventos de aplicación (logs) con un campo event_date de tipo DATE o TIMESTAMP. Lo primero es crear la tabla maestra con la sintaxis nativa de PostgreSQL:
CREATE TABLE eventos (
id BIGSERIAL,
event_date DATE NOT NULL,
mensaje TEXT
) PARTITION BY RANGE (event_date);
Ahora, en lugar de crear particiones manualmente (por ejemplo, eventos_2025_01), llamamos a la función de pg_partman para inicializar el particionamiento. El parámetro p_interval define el rango de cada partición. Para un mes de datos:
SELECT partman.create_parent(
p_parent_table => 'public.eventos',
p_control => 'event_date',
p_interval => '1 month',
p_premake => 4
);
- p_parent_table: nombre de la tabla maestra.
- p_control: columna por la que se particiona.
- p_interval: tamaño del rango. Acepta
'1 day','1 week','1 month','1 year', etc. - p_premake: número de particiones futuras que se crean por adelantado (en este caso, 4 meses). Esto evita errores al insertar datos con fechas futuras.
La función creará automáticamente las particiones correspondientes al periodo actual y los siguientes meses. Podemos verificarlo con:
SELECT child_table FROM partman.part_config WHERE parent_table = 'public.eventos';
-- O consultando el catálogo de particiones nativas
SELECT inhrelid::regclass FROM pg_inherits WHERE inhparent = 'eventos'::regclass;
El resultado mostrará tablas como eventos_2025_01, eventos_2025_02, etc., con nombres automáticos. Insertar datos es transparente: PostgreSQL dirige el INSERT a la partición correcta según el valor de event_date.
Automatizando el mantenimiento: el background worker
Crear particiones manualmente con create_parent es útil, pero el verdadero poder de pg_partman reside en su proceso en segundo plano. Este worker se encarga de ejecutar tareas periódicas: crear nuevas particiones según el p_premake, y (lo que nos interesa) eliminar particiones antiguas si así lo configuramos.
La configuración del worker se realiza en postgresql.conf. Además de la línea que ya añadimos (shared_preload_libraries), podemos ajustar la frecuencia de ejecución:
pg_partman_bgw.interval = 3600 # segundos (por defecto: 3600, cada hora)
pg_partman_bgw.role = 'postgres' # usuario con permisos
Si no deseas usar el background worker (por ejemplo, en entornos con restricciones de carga), puedes ejecutar el mantenimiento manualmente con cron:
SELECT partman.run_maintenance(p_parent_table := 'public.eventos');
Recomendamos el worker para entornos de producción, ya que garantiza la automatización real, pero siempre puedes combinarlo con un cron para tareas puntuales.
Configurando la autolimpieza (retención de datos)
El objetivo principal de este artículo es la autolimpieza. En muchos sistemas, los datos más antiguos que X meses ya no son relevantes operativamente, pero siguen ocupando espacio y lastrando el rendimiento de los VACUUM y de las consultas que los escanean accidentalmente. Con pg_partman, la retención es una simple actualización de la tabla de configuración partman.part_config.
Supongamos que queremos conservar únicamente los últimos 6 meses de eventos. Ejecutamos:
UPDATE partman.part_config
SET retention = '6 months',
retention_keep_table = false
WHERE parent_table = 'public.eventos';
- retention: intervalo de tiempo que define cuánto mantener. Acepta formatos como
'1 month','90 days', etc. - retention_keep_table: si es
false, la tabla de la partición se elimina físicamente conDROP TABLE. Si estrue, solo se desvincula del particionamiento (útil para auditorías o archivado). Para una autolimpieza real, usamosfalse.
Cuando el worker ejecute run_maintenance, detectará las particiones cuyo rango máximo sea anterior a CURRENT_DATE - 6 months y las eliminará. Es importante entender que pg_partman compara la fecha de control de la partición (el valor máximo del rango) con la fecha actual. Por ejemplo, si hoy es 15 de mayo de 2025, una partición de enero de 2025 (que cubre hasta el 31 de enero) se considera fuera de retención porque el 1 de febrero + 6 meses = 1 de agosto, y eso es posterior a hoy? No, espera: la lógica real es: la partición se elimina si su fecha de inicio (o fin) es menor que el límite calculado. En la práctica, pg_partman elimina cualquier partición cuyo rango completo sea anterior a now() - retention. Para nuestro ejemplo, eliminará las particiones de noviembre de 2024 y anteriores, manteniendo desde diciembre de 2024 (si hoy es mayo de 2025). Esto suele ajustarse bien a la intención del administrador.
Podemos verificar qué particiones se van a eliminar antes de que el worker actúe, consultando directamente:
SELECT child_table, range_max
FROM partman.part_config_sub
WHERE parent_table = 'public.eventos'
ORDER BY range_max;
Además, para una limpieza inmediata sin esperar al siguiente ciclo del worker, podemos ejecutar manualmente:
SELECT partman.run_maintenance(p_parent_table := 'public.eventos');
Si queremos eliminar particiones específicas bajo demanda (por ejemplo, una purga urgente), podemos usar la función dedicada:
SELECT partman.drop_partition(
p_parent_table => 'public.eventos',
p_retention => '1 month',
p_keep_table => false
);
Esta función borra todas las particiones con rango máximo anterior a now() - 1 month.