Database

PostgreSQL: VACUUM e autovacuum, quando intervenire

PostgreSQL: VACUUM e autovacuum, quando intervenire

VACUUM e autovacuum in PostgreSQL sono meccanismi essenziali per recuperare lo spazio su disco occupato da righe obsolete (tuple morte) e per mantenere aggiornate le statistiche del query planner, prevenendo il degrado delle performance e il rischio di blocco del database per transaction ID wraparound.

PostgreSQL: VACUUM e autovacuum in 60 secondi

# Visualizza le tabelle con più tuple morte
SELECT relname, n_dead_tup, last_autovacuum FROM pg_stat_user_tables ORDER BY n_dead_tup DESC LIMIT 10;

# Esegui VACUUM e ANALYZE su una tabella specifica, con output dettagliato
VACUUM (VERBOSE, ANALYZE) mia_tabella;

# Imposta un autovacuum più aggressivo per una tabella specifica
ALTER TABLE mia_tabella SET (autovacuum_vacuum_scale_factor = 0.02, autovacuum_vacuum_threshold = 500);

# Controlla l'età dell'ID di transazione più vecchio per database (rischio wraparound)
SELECT datname, age(datfrozenxid) FROM pg_database ORDER BY 2 DESC;

# Mostra il numero massimo di worker autovacuum configurati globalmente
SHOW autovacuum_max_workers;

# Monitora il progresso di un VACUUM in corso
SELECT pid, datname, relid::regclass AS table_name, phase, heap_blks_scanned, num_dead_tuples FROM pg_stat_progress_vacuum;

La gestione del comando VACUUM e del sottosistema autovacuum è uno degli aspetti più critici dell’amministrazione di PostgreSQL, perché incide contemporaneamente su prestazioni, consumo di spazio su disco e integrità logica del database nel lungo periodo. Il motore PostgreSQL, basato sul modello MVCC, non elimina fisicamente le righe modificate o cancellate, ma le rende “morte” e ne rinvia la bonifica a processi di garbage collection, che si concretizzano nei comandi VACUUM ed in autovacuum. Una configurazione errata o un monitoraggio insufficiente possono portare a fenomeni di bloat delle tabelle, a degrado prestazionale marcato, fino al rischio estremo di transaction ID wraparound, in cui il sistema è costretto a fermare le scritture per proteggere la coerenza dei dati. Questo articolo approfondirà perché PostgreSQL ha bisogno del VACUUM, come individuare le tabelle con troppe righe morte, le differenze operative tra VACUUM, VACUUM ANALYZE e VACUUM FULL, perché quest’ultimo blocca la tabella, come regolare l’autovacuum a livello di tabella e di cluster, quali parametri governano il rischio di wraparound e quali strumenti permettono di monitorare nel tempo l’attività di autovacuum, con particolare attenzione a casi reali, trappole note e raccomandazioni dei vendor.

Versioni di riferimento: PostgreSQL 16 · documentazione consultata a novembre 2026

Prerequisiti

Per seguire le procedure e comprendere i concetti esposti, è necessaria una conoscenza di base dell’amministrazione di PostgreSQL e dei concetti di database relazionali. Si presume l’accesso a un ambiente PostgreSQL con privilegi di superuser o di un ruolo con permessi di eseguire comandi di manutenzione e consultare le viste di sistema (pg_stat_user_tables, pg_stat_activity, pg_stat_progress_vacuum, pg_database). L’estensione pgstattuple deve essere installata e disponibile nel database per le query di analisi più dettagliate.

Perché PostgreSQL ha bisogno del VACUUM

MVCC, tuple morte e crescita dello spazio su disco

Per comprendere perché VACUUM è indispensabile in PostgreSQL, è necessario partire dal modello di concorrenza adottato dal sistema, ovvero Multi-Version Concurrency Control (MVCC). In un sistema MVCC, ogni modifica a una riga non sovrascrive il dato esistente, ma crea una nuova versione della riga, lasciando la precedente in tabella fino a quando non è certo che nessuna transazione possa più vederla come valida. PostgreSQL implementa questo comportamento salvando nella tabella sia le versioni correnti sia quelle obsolete, distinguendole tramite informazioni di visibilità basate su ID di transazione (xid) e su snapshot di transazione.

Questo modello ha il grande vantaggio di permettere letture consistenti e non bloccanti anche in presenza di scritture concorrenti, perché una query può vedere un insieme stabile di righe senza dover aspettare la fine delle transazioni di modifica. Tuttavia, tale approccio ha un costo evidente: righe che non sono più visibili a nessuna transazione attiva restano fisicamente nel file della tabella come tuple morte (dead tuples) e occupano spazio su disco. Senza un meccanismo di pulizia, questo accumulo porterebbe a una crescita potenzialmente illimitata dei file di tabella, a un ampliamento degli indici e, di conseguenza, a un degrado progressivo delle prestazioni dovuto a maggior I/O e a piani di esecuzione meno efficienti.

Per evitare questa deriva, PostgreSQL introduce il comando VACUUM, che ha il compito di scandire le tabelle, individuare le tuple ormai irraggiungibili per qualsiasi transazione e liberare lo spazio da esse occupato, rendendolo nuovamente disponibile per inserimenti futuri. Nel funzionamento ordinario, le tuple eliminate da un DELETE o rese obsolete da un UPDATE non vengono rimosse immediatamente, ma sono contrassegnate in modo tale da essere considerate non più visibili, e sarà VACUUM a effettuare, in un secondo tempo, la vera bonifica. Questo differimento consente di ridurre la contesa tra operazioni di lettura e scrittura, ma sposta sul processo di vacuuming la responsabilità di mantenere sotto controllo lo spazio su disco e la salute delle tabelle.

La necessità di VACUUM non è quindi un optional, ma una caratteristica strutturale di PostgreSQL: la documentazione ufficiale afferma esplicitamente che i database PostgreSQL richiedono una manutenzione periodica nota come vacuuming, che deve essere eseguita su ogni tabella per diversi motivi, cui il recupero o riutilizzo dello spazio occupato da righe aggiornate o cancellate e l’aggiornamento delle statistiche per il query planner. Nelle versioni moderne (PostgreSQL 14, 15, 16, 17, 18), l’esecuzione regolare di VACUUM è talmente centrale che il sistema include un autovacuum daemon dedicato ad automatizzare questa manutenzione.

Il ruolo del comando VACUUM nella manutenzione ordinaria

La documentazione SQL di PostgreSQL definisce il comando VACUUM come un’operazione che “reclaims storage occupied by dead tuples”, ovvero recupera lo spazio occupato da tuple morte. Quando operano le istruzioni INSERT, UPDATE e DELETE, le tuple precedenti restano nel file della tabella sino a quando non viene eseguito un VACUUM; di conseguenza, è necessario eseguire VACUUM periodicamente, soprattutto sulle tabelle sottoposte a frequenti aggiornamenti.

Il VACUUM standard si presenta in due sintassi principali: una sintassi moderna che utilizza una lista di opzioni tra parentesi e una sintassi storica con opzioni separate. Ad esempio, una forma tipica e raccomandata per la manutenzione ordinaria è:

VACUUM (VERBOSE, ANALYZE) mytable;

In questo caso, la modalità VERBOSE permette di ottenere un report dettagliato sull’attività di vacuum per ciascuna tabella, mentre l’opzione ANALYZE indica al sistema di eseguire, dopo la bonifica, un aggiornamento delle statistiche di distribuzione dei dati usate dal query planner per ottimizzare i piani di esecuzione. L’esecuzione di VACUUM ANALYZE su tabelle molto dinamiche è una pratica raccomandata perché consente, in un’unica operazione, di ripulire tuple morte e di mantenere aggiornate le statistiche di pianificazione.

La documentazione storica (ad esempio PostgreSQL 6.5) già chiariva che VACUUM serviva a reclamare storage e a raccogliere informazioni per l’ottimizzatore, aprendo ogni “class” nel database, rimuovendo record di transazioni annullate e aggiornando statistiche sui cataloghi di sistema, inclusi il numero di tuple e di pagine memorizzate per ogni tabella. Sebbene quella versione sia ormai non supportata, il concetto rimane valido e coerente con la documentazione contemporanea: VACUUM è sia un garbage collector sia un meccanismo di raccolta statistiche, e va eseguito regolarmente per mantenere veloce il database nell’elaborazione delle query.

Un aspetto importante evidenziato dalla documentazione recente è che il VACUUM standard può essere eseguito in parallelo con le normali operazioni di produzione, come SELECT, INSERT, UPDATE e DELETE, senza bloccare la definizione delle tabelle. Durante un VACUUM standard non è possibile modificare la definizione della tabella con comandi come ALTER TABLE, ma le operazioni di lettura e scrittura sui dati possono proseguire normalmente, sebbene con un potenziale aumento del traffico I/O. Questa caratteristica rende il VACUUM standard adatto alla manutenzione ordinaria, anche in ambienti con carico continuo, mentre la forma VACUUM FULL, come vedremo, ha impatti più invasivi.

Vacuum standard e VACUUM FULL: inquadramento generale

La documentazione ufficiale distingue chiaramente tra due varianti di VACUUM: il VACUUM standard e il VACUUM FULL. Il primo è progettato per essere eseguito regolarmente e in parallelo con le normali attività del database, mentre il secondo è un’operazione più pesante che riscrive l’intero contenuto della tabella in un nuovo file su disco, con l’obiettivo di restituire lo spazio inutilizzato al sistema operativo.

Il VACUUM standard rimuove le versioni di riga morte e segna lo spazio come disponibile per futuri inserimenti, ma di norma non restituisce lo spazio al sistema operativo, se non nella situazione particolare in cui una o più pagine alla fine del file della tabella diventano completamente libere e sia possibile ottenere facilmente un lock esclusivo sulla tabella. Questo significa che, anche se una tabella è stata ripulita internamente, il file su disco può mantenere le stesse dimensioni, mentre lo spazio interno viene riutilizzato per nuove tuple. È una strategia pensata per bilanciare efficienza e concorrenza, evitando costose riscritture del file nella maggior parte dei casi.

Il VACUUM FULL, invece, “rewrites the entire contents of the table into a new disk file with no extra space, allowing unused space to be returned to the operating system”. Questa forma di vacuum è molto più lenta, richiede spazio su disco aggiuntivo perché scrive una nuova copia della tabella prima di poter rilasciare quella vecchia, e necessita di un lock di tipo ACCESS EXCLUSIVE sulla tabella, che impedisce qualsiasi uso concorrente della stessa durante l’operazione. Per questi motivi, la documentazione raccomanda di usare VACUUM FULL solo quando è necessario recuperare una quantità significativa di spazio da una tabella gravemente gonfiata (bloated) e non come parte della manutenzione ordinaria.

Il wiki ufficiale di PostgreSQL sottolinea che VACUUM e VACUUM FULL “sono in realtà molto diversi e non dovrebbero essere confusi” e che, nella maggior parte dei casi, si dovrebbe usare VACUUM standard invece di VACUUM FULL, salvo la necessità esplicita di restituire spazio al sistema operativo o di riparare una tabella e un indice gravemente gonfiati a causa di autovacuum insufficiente. I miglioramenti progressivi dell’autovacuum attraverso le versioni di PostgreSQL hanno reso sempre meno frequente la necessità di utilizzare VACUUM FULL, spostando l’attenzione sulla corretta configurazione dell’autovacuum piuttosto che sul ricorso a interventi manuali drastici.

Trovare le tabelle con troppe righe morte

Indicatori di bloat e accumulo di tuple morte

Per un amministratore di sistema o un DBA, uno dei compiti fondamentali è identificare quali tabelle o indici stanno accumulando un numero eccessivo di tuple morte, generando bloat e potenziale degrado prestazionale. PostgreSQL fornisce diversi strumenti per valutare questo fenomeno, partendo sia dalle viste di statistiche cumulative sia da estensioni specializzate come pgstattuple.

La vista pg_stat_user_tables (o pg_stat_all_tables) contiene metriche preziose, tra cui il numero di tuple modificate dall’ultimo VACUUM o ANALYZE (n_mod_since_analyze), il numero di tuple morte (n_dead_tup), il timestamp dell’ultimo autovacuum (last_autovacuum) e dell’ultimo autoanalyze (last_autoanalyze). Queste informazioni permettono di capire se l’autovacuum sta tenendo il passo con il tasso di modifica delle tabelle oppure se alcune tabelle stanno accumulando troppe tuple morte tra un ciclo di manutenzione e l’altro. La documentazione delle statistiche cumulative evidenzia che tali viste sono pensate proprio per monitorare l’attività del server e includono campi specifici relativi a VACUUM e autovacuum.

Un forte aumento di n_dead_tup su una tabella, senza corrispondenti esecuzioni di autovacuum registrate in last_autovacuum, è spesso un segnale di bloat crescente e di autovacuum sottodimensionato o ostacolato da lock e transazioni di lunga durata. La guida Microsoft per Azure Database for PostgreSQL consiglia, ad esempio, di impostare log_autovacuum_min_duration per registrare nei log i vacuum automatici che superano una certa durata e di monitorare n_dead_tup, n_mod_since_analyze, last_autovacuum e last_autoanalyze in pg_stat_user_tables per identificare problematiche di autovacuum che non riesce a mantenere il passo.

Oltre ai contatori di tuple morte, si possono osservare le dimensioni fisiche delle tabelle e degli indici, confrontando la crescita nel tempo del loro pg_relation_size con il numero di tuple effettivamente presenti, per individuare tabelle in cui lo spazio allocato aumenta molto più rapidamente dei dati reali. In abbinamento, gli strumenti di progresso come pg_stat_progress_vacuum permettono di verificare se VACUUM sta effettivamente ripulendo i blocchi della tabella o se viene sistematicamente interrotto da lock o cost-based throttling. Leggi anche: Linux: Liberare Spazio Disco con 12 Comandi (Guida SysAdmin 2026)

Uso delle viste di monitoraggio: pg_stat_user_tables, pg_stat_activity, pg_stat_progress_vacuum

PostgreSQL include un ampio sistema di raccolta statistiche, noto come statistics collector, che alimenta diverse viste utili a monitorare attività e progressi dei comandi di manutenzione. Tra queste, due viste sono particolarmente rilevanti per il tema VACUUM/autovacuum: pg_stat_activity e pg_stat_progress_vacuum, affiancate dalle viste specifiche per tabelle come pg_stat_user_tables.

La vista pg_stat_activity mostra una riga per ogni processo server, indicando lo stato corrente (ad esempio active, idle, idle in transaction, idle in transaction (aborted)), il comando in esecuzione, il timestamp di inizio transazione (xact_start) e altri dettagli rilevanti. Attraverso questa vista è possibile individuare sessioni che restano “idle in transaction” per lunghi periodi, bloccando il cutoff di VACUUM e impedendo la rimozione di tuple morte più vecchie, con effetti diretti sia sul bloat sia sul rischio di transaction ID wraparound. Le lunghe transazioni inattive, evidenziate da stati come idle in transaction, sono infatti una delle trappole più note in PostgreSQL, e la documentazione raccomanda esplicitamente di monitorarle e di evitare che possano ritardare la progressione di VACUUM per periodi estesi.

La vista pg_stat_progress_vacuum è stata introdotta per riportare il progresso di VACUUM per ciascun backend, inclusi i worker di autovacuum. Quando VACUUM è in esecuzione, questa vista contiene una riga per ogni processo che sta effettuando vacuum, con colonne quali pid (ID di processo), datid e datname (database interessato), relid (OID della tabella) e diversi contatori sul numero totale di blocchi heap (heap_blks_total), blocchi scansionati (heap_blks_scanned), blocchi vacuumed (heap_blks_vacuumed), numero di cicli di vacuum sugli indici (index_vacuum_count) e numero di dead tuples in memoria (num_dead_tuples). La colonna phase indica la fase corrente di VACUUM, ad esempio scanning heap, vacuuming indexes, vacuuming heap, cleaning up indexes, truncating heap e performing final cleanup, consentendo di interpretare quanto lavoro è già stato completato.

Questi contatori permettono di valutare se VACUUM sta effettivamente avanzando sulla tabella o se è bloccato, ad esempio, nella fase di scanning heap con progressi minimi, che potrebbe segnalare contesa I/O o cost-based throttling eccessivo. È importante notare che il progresso di VACUUM FULL non è riportato in pg_stat_progress_vacuum, ma in pg_stat_progress_cluster, perché VACUUM FULL viene trattato internamente in modo simile a CLUSTER. Ciò significa che, per monitorare un VACUUM FULL, bisogna consultare pg_stat_progress_cluster, che ha una semantica differente, più orientata alle operazioni di riscrittura fisica della tabella.

Infine, la vista pg_stat_user_tables fornisce statistiche cumulative per ogni tabella utente, tra cui il numero di vacuum manuali (vacuum_count) e automatici (autovacuum_count), l’ultimo autovacuum (last_autovacuum), l’ultimo autoanalyze (last_autoanalyze) e i contatori di righe modificate e morte. Incrociando questi dati con i log dell’autovacuum e con pg_stat_progress_vacuum, un DBA può costruire un quadro completo di quali tabelle stiano soffrendo di bloat, quali abbiano parametri di autovacuum troppo conservativi e quali siano ostacolate da lock o transazioni di lunga durata. Leggi anche: mysqldump Backup: Coerenza e Ripristino MySQL/MariaDB

Uso di pgstattuple e pgstattuple_approx

Per quantificare con precisione la percentuale di tuple morte e di spazio libero in una tabella, PostgreSQL mette a disposizione l’estensione pgstattuple, che fornisce funzioni per ottenere statistiche a livello di tuple. Nella documentazione di PostgreSQL 8.4 e successiva, pgstattuple viene presentata come uno strumento che può “help users to determine whether vacuum is necessary or not”, restituendo lunghezza fisica della relazione, numero e lunghezza delle tuple vive, delle tuple morte e dello spazio libero, espresso sia in bytes sia in percentuali.

La funzione pgstattuple(regclass) accetta il nome (eventualmente schema-qualified) o l’OID di una relazione e restituisce un record con colonne come table_len (lunghezza fisica della tabella in bytes), tuple_count (numero di tuple vive), tuple_len (lunghezza totale delle tuple vive), tuple_percent (percentuale di tuple vive), dead_tuple_count (numero di tuple morte), dead_tuple_len (lunghezza totale delle tuple morte), dead_tuple_percent (percentuale di tuple morte), free_space (spazio libero totale) e free_percent (percentuale di spazio libero).

È importante notare che pgstattuple acquisisce solo un read lock sulla relazione, quindi i risultati non rappresentano uno snapshot istantaneo e possono essere influenzati da aggiornamenti concorrenti durante la scansione. Inoltre, nelle versioni più recenti, pgstattuple giudica una tupla “dead” in base alla funzione interna HeapTupleSatisfiesDirty, mentre nelle versioni più vecchie usava HeapTupleSatisfiesNow. Questa differenza riflette miglioramenti nella semantica di visibilità, ma per l’utente finale il concetto rimane: pgstattuple misura tuple che non sarebbero considerate visibili da una transazione “normale”.

La funzione pgstattuple_approx è stata introdotta per fornire una versione più leggera che evita la full-table scan, restituendo un conteggio esatto delle tuple morte e una stima del numero e della dimensione delle tuple vive e dello spazio libero. La documentazione evidenzia che, a differenza di pgstattuple, la versione _approx stimala il numero totale di tuple vive basandosi sul numero di pagine e di tuple scansionate, nello stesso modo in cui VACUUM stima pg_class.reltuples. Questo consente di usare pgstattuple_approx su tabelle molto grandi con minor impatto prestazionale, accettando una leggera approssimazione sulle tuple vive e sul free space.

Un caveat fondamentale è che, per motivi di sicurezza, nelle versioni recenti l’esecuzione delle funzioni pgstattuple è limitata al ruolo pg_stat_scan_tables, che ha privilege di EXECUTE preassegnato. Questo significa che, in ambienti gestiti, il DBA deve assicurarsi di avere i permessi necessari o di delegare l’uso di pgstattuple a ruoli appropriati, mantenendo il controllo sul potenziale impatto di scansioni dettagliate su tabelle di grandi dimensioni.

Esempi di query pratiche per individuare tabelle problematiche

Un approccio operativo comune per individuare tabelle con eccesso di tuple morte consiste nel combinare le viste di sistema e le funzioni di pgstattuple con query di monitoraggio ad hoc. Una query tipica per evidenziare tabelle con elevato n_dead_tup e con autovacuum poco frequente potrebbe essere:

SELECT
    relname,
    n_dead_tup,
    n_mod_since_analyze,
    last_autovacuum,
    last_autoanalyze
FROM pg_stat_user_tables
ORDER BY n_dead_tup DESC
LIMIT 20;

Questa query sfrutta la vista pg_stat_user_tables per mostrare le venti tabelle con il maggior numero di tuple morte, insieme al numero di modifiche dall’ultimo analyze e agli ultimi timestamp di autovacuum e autoanalyze, consentendo di identificare rapidamente candidate per tuning di autovacuum o per vacuum manuale. Osservando tabelle con n_dead_tup molto alto e last_autovacuum distante nel tempo, si può sospettare che l’autovacuum threshold e scale factor siano troppo elevati, o che lock e transazioni lunghe stiano impedendo l’esecuzione di autovacuum.

Per verificare la percentuale reale di tuple morte e di spazio libero, si può eseguire:

SELECT *
FROM pgstattuple('public.mia_tabella');

ottenendo un record che indica il dead_tuple_percent e free_percent, con cui valutare quanto realmente la tabella sia gonfia e se un semplice VACUUM standard o, in casi estremi, un VACUUM FULL siano giustificati. Poiché pgstattuple compie una full-table scan con solo read lock, questa operazione va pianificata su tabelle molto grandi in finestre di carico moderato, ma costituisce un riferimento affidabile per decidere la strategia di manutenzione.

Durante l’esecuzione di un VACUUM manuale o automatico su una tabella sospetta, è interessante monitorare pg_stat_progress_vacuum:

SELECT
    pid,
    datname,
    relid::regclass AS table_name,
    phase,
    heap_blks_total,
    heap_blks_scanned,
    heap_blks_vacuumed,
    index_vacuum_count,
    num_dead_tuples
FROM pg_stat_progress_vacuum;

Questa query mostra in tempo reale il progresso dei processi di vacuum, rivelando se la tabella viene effettivamente ripulita e quanto lavoro è richiesto sugli indici. Ad esempio, un heap_blks_scanned che cresce lentamente e un num_dead_tuples elevato possono indicare che VACUUM sta facendo un lavoro intensivo e potrebbe essere soggetto a cost-based throttling, mentre un rapido completamento con pochi dead tuples suggerisce che l’intervento è relativamente leggero.

In definitiva, combinando queste query con l’osservazione sistematica dei log di autovacuum, è possibile costruire una mappa di quali tabelle sono le principali “fonti di bloat” nel cluster PostgreSQL e intervenire con tuning mirato invece di applicare politiche generiche che potrebbero sovra- o sotto-ottimizzare il comportamento del vacuuming.

VACUUM, VACUUM ANALYZE e VACUUM FULL

Semantica del comando VACUUM

La sintassi moderna di VACUUM, come documentata nelle versioni recenti di PostgreSQL (ad esempio 16 e 18), permette di specificare un insieme di opzioni tra parentesi, seguito da un elenco di tabelle e, opzionalmente, di colonne da analizzare. Un esempio formale è:

VACUUM [ ( option [, ...] ) ] [ table_and_columns [, ...] ];

oppure, nella sintassi storica:

VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ ANALYZE ] [ table_and_columns [, ...] ];

In assenza di una lista di tabelle, VACUUM processa tutte le tabelle e le materialized view nel database corrente per cui l’utente ha i permessi di vacuum. Se viene fornita una lista, VACUUM si limita alle tabelle specificate, consentendo una manutenzione mirata su tabelle particolarmente dinamiche o problematiche. La variante VACUUM ANALYZE combina l’operazione di garbage collection con la raccolta di statistiche, risultando una forma comoda per script di manutenzione periodici.

Il VACUUM standard, senza opzione FULL, esegue la bonifica delle tuple morte e rende lo spazio interno disponibile al sistema di allocazione delle pagine della tabella, ma, come già ricordato, non effettua una riscrittura completa del file. L’operazione rispetta la concorrenza con altre query: mentre è in esecuzione, comandi come SELECT, INSERT, UPDATE e DELETE continuano a funzionare normalmente, sebbene una parte dell’I/O del sistema sia dedicata alla scansione e pulizia dei blocchi del heap e degli indici. La documentazione sottolinea che VACUUM genera un carico I/O significativo e può causare un peggioramento temporaneo delle performance per le altre sessioni attive, motivo per cui i parametri di cost-based vacuuming sono stati introdotti per limitare l’impatto.

La modalità FREEZE di VACUUM (non approfondita nei risultati ma parte della sintassi ufficiale) serve a congelare tuple con ID di transazione molto vecchi, marcandole come permanenti, in modo da evitare che debbano essere considerate durante future scansioni di protezione dal wraparound. In pratica, VACUUM FREEZE esegue un vacuum aggressivo che forza la “freezing” delle tuple, avanzando il relfrozenxid della tabella e riducendo la pressione sul sistema di gestione degli XID.

VACUUM ANALYZE e le statistiche per il planner

L’opzione ANALYZE aggiunge una dimensione cruciale al comando VACUUM, perché consente di aggiornare le statistiche di distribuzione dei dati utilizzate dal PostgreSQL query planner per determinare i piani di esecuzione più efficienti. Nella documentazione storica, ANALYZE veniva definita come l’opzione che “updates column statistics used by the optimizer to determine the most efficient way to execute a query”, con statistiche che rappresentano la distribuzione dei dati in ogni colonna. Queste statistiche sono particolarmente utili quando il planner deve scegliere tra diversi path di esecuzione possibili, ad esempio tra una scansione sequenziale e l’uso di un indice, tra hash join e nested loop, o tra piani che prevedono sort e limit.

In PostgreSQL moderno, VACUUM ANALYZE viene spesso usato come combinazione standard nelle routine di manutenzione, perché consente di effettuare, in un’unica passata, la rimozione delle tuple morte e l’aggiornamento delle statistiche. La documentazione raccomanda di eseguire ANALYZE regolarmente, soprattutto su tabelle soggette a frequenti inserimenti, aggiornamenti o cancellazioni, perché statistiche non aggiornate possono portare a piani subottimali, e la sola bonifica fisica non è sufficiente a mantenere prestazioni prevedibili.

Autovacuum stesso integra sia VACUUM sia ANALYZE nelle sue attività, attivando ANALYZE quando il numero di tuple inserite, aggiornate o cancellate supera la soglia autovacuum_analyze_threshold più la parte proporzionale stabilita da autovacuum_analyze_scale_factor. Questo significa che, nella maggior parte delle installazioni, il DBA può affidarsi al sistema per eseguire automaticamente ANALYZE quando necessario, regolando solo le soglie e i scale factor per adattarli al comportamento delle singole tabelle. Tuttavia, in scenari particolarmente critici, ad esempio dopo bulk load massivi o dopo modifiche massive a schema e dati, può essere opportuno eseguire manualmente VACUUM (ANALYZE) su tabelle chiave, per garantire che il planner disponga subito di statistiche affidabili.

VACUUM FULL e la riscrittura della tabella

Come già accennato, la variante VACUUM FULL è una operazione speciale che riscrive completamente il contenuto della tabella in un nuovo file su disco, senza lasciare spazio extra, permettendo che lo spazio inutilizzato venga restituito al sistema operativo. La documentazione ufficiale evidenzia che VACUUM FULL è molto più lento del VACUUM standard e richiede un lock di tipo ACCESS EXCLUSIVE su ogni tabella mentre viene processata, impedendo l’uso concorrente della tabella da parte di altre sessioni. Inoltre, questa forma richiede spazio su disco aggiuntivo, perché la nuova copia della tabella viene completata prima che la vecchia possa essere rimossa, e lo spazio liberato non è disponibile durante la parte iniziale dell’operazione.

Per queste ragioni, il manuale suggerisce di utilizzare VACUUM FULL solo quando è necessario recuperare una quantità significativa di spazio interno alla tabella, ad esempio in seguito a cancellazioni massicce o a un lungo periodo di manutenzione insufficiente che abbia portato a bloat marcato. Il wiki ufficiale evidenzia che, a meno che non si debba restituire spazio al sistema operativo o riparare tabelle e indici “bloated out of control”, si è generalmente invitati a usare VACUUM standard e non VACUUM FULL. Leggi anche: Oracle Data Pump: Export e Import con expdp e impdp

È importante notare che VACUUM FULL, nelle versioni moderne, condivide il meccanismo di reporting di progresso con CLUSTER, ed è monitorato tramite pg_stat_progress_cluster piuttosto che pg_stat_progress_vacuum. Questo dettaglio tecnico sottolinea la natura di VACUUM FULL: più che una semplice bonifica di tuple morte, esso è un’operazione di clusterizzazione fisica della tabella, che ne ricrea il layout su disco, potenzialmente migliorando la località dei dati ma al costo di un lock esclusivo e di un I/O molto intenso.

Impatto sulle transazioni concorrenti e sui lock

La differenza principale, dal punto di vista della concorrenza, tra VACUUM standard e VACUUM FULL è la tipologia di lock richiesto e la compatibilità con altre operazioni. Il VACUUM standard può essere eseguito in parallelo con altre operazioni di lettura e scrittura, perché non richiede un lock esclusivo sulla tabella, ma solo lock più leggeri che impediscono modifiche al suo schema. La documentazione specifica che, durante un VACUUM standard, non è possibile modificare la definizione di una tabella, ad esempio con ALTER TABLE, mentre le operazioni di DML (SELECT, INSERT, UPDATE, DELETE) continuano a funzionare normalmente. Questo rende il VACUUM standard compatibile con ambienti di produzione con alta concorrenza, sebbene sia necessario tenere conto del suo impatto I/O.

Al contrario, VACUUM FULL richiede un lock ACCESS EXCLUSIVE sulla tabella, il che implica che nessuna altra sessione può usare la tabella durante l’operazione. Ciò include sia le operazioni di lettura sia di scrittura, e, in pratica, VACUUM FULL “blocca la tabella” per tutta la durata della riscrittura. Questo comportamento è una trappola ben nota: eseguire VACUUM FULL su tabelle molto grandi durante orari di punta può congelare porzioni significative dell’applicazione, causando time-out e code di richieste in attesa del lock.

La gestione corretta di VACUUM FULL, quindi, richiede una pianificazione accurata, tipicamente in finestre di manutenzione programmata con ridotto carico utente, e una valutazione preventiva delle dimensioni delle tabelle e dello spazio su disco disponibile. Inoltre, in cluster con replica, è necessario considerare l’effetto di VACUUM FULL sulla replica e sui tempi di convergenza dei standby, poiché la riscrittura massiva dei file può generare volumi elevati di WAL.

Per mitigare questi effetti, PostgreSQL offre parametri di vacuum cost-based throttling (come vacuum_cost_delay, vacuum_cost_limit e i loro equivalenti per autovacuum), che possono rallentare il vacuum standard per ridurre l’impatto sulle performance, ma tali meccanismi non sono applicati in modalità VACUUM FULL, che per definizione è una operazione aggressiva e non soggetta a throttling. Pertanto, VACUUM FULL va considerato un “ultimo ricorso” e non uno strumento di routine.

Perché VACUUM FULL blocca la tabella

ACCESS EXCLUSIVE lock e blocchi sulle operazioni DML e DDL

La ragione tecnica per cui VACUUM FULL blocca la tabella risiede nella natura dell’operazione: la riscrittura completa del contenuto in un nuovo file richiede che nessun’altra transazione possa leggere o modificare la tabella durante il processo, per evitare inconsistenze e problemi di visibilità. PostgreSQL implementa questa protezione richiedendo un lock di tipo ACCESS EXCLUSIVE, che è il livello di lock più restrittivo e impedisce anche le semplici letture.

Il lock ACCESS EXCLUSIVE è condiviso solo con se stesso, il che significa che, mentre un VACUUM FULL è in esecuzione, tutte le altre operazioni che richiedono anche solo un lock ACCESS SHARE (tipico delle SELECT) o ROW EXCLUSIVE (tipico delle UPDATE/DELETE) restano in attesa. Il risultato percepito dagli utenti è che la tabella appare “congelata”: query che la coinvolgono si bloccano o vanno in timeout finché VACUUM FULL non termina.

La documentazione di routine vacuuming ribadisce che, mentre il VACUUM standard può operare in parallelo con le normali operazioni, VACUUM FULL “requires an ACCESS EXCLUSIVE lock on the table it is working on, and therefore cannot be done in parallel with other use of the table”. Questa frase sintetizza in modo chiaro il motivo per cui VACUUM FULL è considerato invasivo e non adatto alla manutenzione ordinaria. I DBA devono essere consapevoli di questo comportamento e evitare di eseguire VACUUM FULL su tabelle critiche in orari di produzione.

Un ulteriore punto da considerare è che, in presenza di lochi a cascata, un VACUUM FULL su una tabella referenziata da chiavi esterne o coinvolta in indici complessi può contribuire a situazioni di blocking esteso, specialmente se altre transazioni tentano di acquisire lock a loro volta. La pianificazione delle operazioni di VACUUM FULL deve dunque considerare non solo la singola tabella, ma anche le dipendenze e l’uso applicativo.

Differenze tra VACUUM FULL, CLUSTER e REINDEX

VACUUM FULL non è l’unica operazione di manutenzione che riscrive fisicamente una tabella. Comandi come CLUSTER e REINDEX hanno effetti analoghi nella misura in cui ricostruiscono strutture su disco e sugli indici, e condividono molte delle stesse implicazioni in termini di lock. Il comando CLUSTER, ad esempio, riscrive una tabella ordinandone fisicamente le righe secondo un indice, producendo un nuovo file della tabella; VACUUM FULL, pur non imponendo un ordine specifico, effettua comunque una ricreazione fisica del file, e per questo motivo il suo progresso viene monitorato tramite pg_stat_progress_cluster insieme a CLUSTER.

Il comando REINDEX ricostruisce un indice, eliminando bloat e ottimizzando la sua struttura, ma non riscrive il heap; tuttavia, anche REINDEX richiede lock importanti sugli oggetti coinvolti e non può essere eseguito in piena concorrenza con tutte le operazioni. In certe situazioni, un bloat estremo degli indici può essere mitigato da REINDEX invece che da VACUUM FULL, riducendo l’impattosul heap e sul lock globale della tabella.

La scelta tra VACUUM FULL, CLUSTER e REINDEX dipende dalla natura del problema: se il bloat riguarda principalmente il heap e si desidera restituire spazio al sistema operativo, VACUUM FULL può essere giustificato; se si vuole migliorare la località dei dati in funzione di un indice clusterizzato, CLUSTER è la scelta naturale; se il bloat è concentrato sugli indici, REINDEX è spesso sufficiente. In tutti i casi, però, gli amministratori devono tenere conto dei lock richiesti e pianificare tali operazioni in finestre adeguate, evitando di eseguirle in momenti di carico elevato. Leggi anche: logrotate: Configurare Rotazione Log su Linux

Scenari in cui VACUUM FULL è giustificato

La documentazione PostgreSQL è chiara nel raccomandare di evitare l’uso routinario di VACUUM FULL, ma riconosce che esistono scenari in cui esso può essere giustificato o addirittura necessario. Il primo scenario tipico è quello di una tabella che ha subito cancellazioni massicce o aggiornamenti che di fatto hanno ridotto drasticamente il numero di righe attive, ma il cui file su disco rimane molto grande perché lo spazio interno non può essere restituito facilmente al sistema operativo. In tali casi, se il bloat è tale da compromettere l’utilizzo complessivo dello storage o da influire pesantemente sulla cache, un VACUUM FULL può riportare la tabella a dimensioni proporzionate ai dati realmente presenti, liberando spazio per altri usi.

Un secondo scenario è quello di tabelle che hanno sofferto per lungo tempo di una configurazione autovacuum insufficiente o di transazioni lunghe che hanno bloccato la bonifica di tuple morte, portando a una crescita progressiva del file e degli indici. Se, dopo aver corretto la configurazione o l’uso applicativo (riducendo ad esempio gli idle in transaction), si scopre che alcune tabelle sono ormai gravemente gonfiate, un intervento straordinario con VACUUM FULL può essere il modo più rapido per riportarle a una situazione normale.

Il wiki PostgreSQL sottolinea che, se autovacuum non riesce a tenere libere tabelle e indici dal bloat, la risposta dovrebbe essere “tune it, don’t supplement it with manual vacuuming and reindexing”, ma ammette che esistono casi in cui tabelle sono “bloated out of control due to insufficient autovacuum”, in cui un VACUUM FULL o equivalenti possono essere considerati per riparare la situazione. La chiave sta nel riconoscere che VACUUM FULL risolve il sintomo, ma la causa va affrontata regolando autovacuum e l’uso applicativo, per evitare che il problema si ripresenti.

Strategie alternative: autovacuum aggressivo, partizionamento, migrazioni

In ambienti moderni, la tendenza dei vendor e della community è quella di considerare VACUUM FULL come un’operazione eccezionale e di privilegiare strategie alternative per gestire bloat e accumulo di tuple morte. La prima strategia consiste nel tuning dell’autovacuum per tabelle specifiche, riducendo i parametri autovacuum_vacuum_scale_factor e autovacuum_vacuum_threshold per tabelle molto dinamiche, in modo che autovacuum intervenga più frequentemente e impedisca la crescita incontrollata delle tuple morte. Si possono anche aumentare autovacuum_max_workers e autovacuum_work_mem per consentire a più worker di operare simultaneamente e gestire più dead tuples per ciclo, a costo di maggior consumo di risorse.

Una seconda strategia è il partizionamento delle tabelle molto grandi o con pattern di accesso e cancellazione caratteristici. In presenza di tabelle di log o dati temporali, ad esempio, partizionare per intervallo temporale o per range consente di gestire la cancellazione intera di partizioni con TRUNCATE o DROP, evitando che l’accumulo di dead tuples si concentri su un unico file di tabella. TRUNCATE, in particolare, svuota interamente una tabella e restituisce immediatamente lo spazio interno, ma è applicabile solo quando è accettabile la cancellazione totale dei dati, tipicamente su partizioni “scadute”.

Una terza strategia è la migrazione logica o fisica dei dati da una tabella gonfiata a una nuova tabella, ad esempio con CREATE TABLE AS SELECT delle sole righe attive, seguita da rinomina delle tabelle, in operazioni pianificate attentamente. Questa tecnica, pur costosa in termini di I/O, può essere meno invasiva di VACUUM FULL se combinata con lock ordinati e con replicazione adeguata, e permette di riprogettare schema e indici durante il processo.

Infine, in ambienti cloud gestiti, come Azure Database for PostgreSQL, la raccomandazione del vendor è di monitorare attentamente autovacuum e di intervenire principalmente sul tuning e sulle pratiche applicative, utilizzando strumenti di monitoring avanzati per individuare anti-wraparound vacuums e failsafe vacuums che indicano che la manutenzione ordinaria non sta tenendo il passo. In tali contesti, interventi manuali come VACUUM FULL vengono spesso scoraggiati o gestiti tramite procedure di change control, proprio per il loro impatto potenzialmente disruptive.

Regolare l’autovacuum per tabella

Parametri globali di autovacuum nel postgresql.conf

L’autovacuum daemon è una componente opzionale ma altamente raccomandata di PostgreSQL, il cui scopo è automatizzare l’esecuzione di VACUUM e ANALYZE. Nella configurazione predefinita delle installazioni moderne di PostgreSQL, autovacuum è attivo per default e opera in background, ma i suoi parametri globali, definiti nel file postgresql.conf, influenzano il comportamento su tutto il cluster. Tra i parametri più importanti troviamo:

  • autovacuum = on: abilita o disabilita il demone autovacuum (default on).
  • autovacuum_max_workers: il numero massimo di processi autovacuum che possono essere eseguiti contemporaneamente (default 3). Aumentarlo può aiutare a gestire cluster con molte tabelle attive, ma aumenta il consumo di risorse. Un output tipico:
    SHOW autovacuum_max_workers;
     autovacuum_max_workers
    ------------------------
     3
    (1 row)
  • autovacuum_vacuum_cost_delay: la pausa in millisecondi tra un ciclo di vacuum e l’altro quando il costo di I/O supera autovacuum_vacuum_cost_limit (default 2ms). Ridurlo rende il vacuum più aggressivo, aumentarlo lo rende più lento e meno impattante.
  • autovacuum_vacuum_cost_limit: la quantità di “costo” di I/O che un processo autovacuum può accumulare prima di andare in pausa (default -1, che significa usare vacuum_cost_limit).
  • autovacuum_naptime: il tempo di riposo tra due cicli di scansione dei database per tabelle che necessitano di vacuum o analyze (default 1 minuto). Ridurlo rende i controlli più frequenti, aumentandolo li dirada.

Questi parametri globali stabiliscono il comportamento di base dell’autovacuum, ma è fondamentale comprendere che spesso è necessario un tuning più granulare, a livello di singola tabella, per ottimizzare le performance senza impattare negativamente l’intero cluster. La documentazione ufficiale di PostgreSQL dedica un’intera sezione ai parametri del server relativi al vacuum, indicando come regolarli per bilanciare aggressività e impatto sulle risorse. Consulta la documentazione ufficiale di PostgreSQL sui parametri di Autovacuum

Tuning per singola tabella con ALTER TABLE

Sebbene i parametri globali siano un buon punto di partenza, le tabelle in un database hanno comportamenti molto diversi: alcune sono statiche, altre subiscono milioni di UPDATE/DELETE al giorno. PostgreSQL permette di sovrascrivere i parametri di autovacuum per singola tabella, offrendo un controllo granulare e mirato. Questo si fa con il comando ALTER TABLE ... SET (storage_parameter = value). I parametri più comuni da configurare a livello di tabella sono:

  • autovacuum_vacuum_threshold: il numero minimo di tuple morte che devono accumularsi prima che autovacuum intervenga (default autovacuum_vacuum_threshold globale, tipicamente 50).
  • autovacuum_vacuum_scale_factor: una percentuale della dimensione della tabella che, sommata al threshold, determina la soglia effettiva per l’attivazione del vacuum (default autovacuum_vacuum_scale_factor globale, tipicamente una quota rilevante). Per tabelle molto dinamiche, si può ridurre questo valore. Ad esempio:
    ALTER TABLE ordini SET (autovacuum_vacuum_scale_factor = 0.02);

Questo imposta il fattore di scala a un valore ridotto, rendendo autovacuum più reattivo su ordini rispetto alla configurazione globale.

  • autovacuum_analyze_threshold e autovacuum_analyze_scale_factor: simili ai parametri di vacuum, ma controllano quando eseguire ANALYZE per aggiornare le statistiche del planner. Regolarli è cruciale per mantenere piani di esecuzione efficienti su tabelle con alta volatilità dei dati.
  • autovacuum_enabled = off: disabilita completamente autovacuum per una tabella specifica. Questo è raramente raccomandato, ma può essere utile per tabelle estremamente statiche o gestite con procedure di manutenzione manuale molto specifiche (ad esempio, tabelle partizionate che vengono troncate periodicamente).

L’approccio migliore è monitorare le tabelle più attive usando pg_stat_user_tables e pgstattuple, identificare quelle con n_dead_tup in crescita rapida o con bloat significativo, e poi applicare tuning specifici. Ad esempio, una tabella di log con milioni di inserimenti e cancellazioni giornaliere potrebbe beneficiare di un autovacuum_vacuum_scale_factor molto basso (es. 0.01) e un autovacuum_vacuum_threshold elevato, per bilanciare l’aggressività del vacuum con il costo di I/O. Al contrario, una tabella di configurazione raramente modificata potrebbe non richiedere tuning particolari o, in casi estremi, avere autovacuum disabilitato.

Transaction ID wraparound: il rischio da conoscere

Cos’è il Transaction ID Wraparound

Il Transaction ID wraparound è una delle trappole più pericolose e meno comprese in PostgreSQL. Come accennato, ogni transazione e ogni tupla in PostgreSQL ha un ID di transazione (XID) a 32 bit. Questo XID viene utilizzato dal sistema MVCC per determinare la visibilità delle tuple. Poiché gli XID sono a 32 bit, il loro numero massimo è di circa 4 miliardi. Quando il contatore degli XID si avvicina a questo limite, se le tuple più vecchie non vengono “congelate” (frozen) da VACUUM, il sistema rischia di interpretare erroneamente le transazioni future come “più vecchie” di quelle passate, portando a una potenziale corruzione dei dati. Per prevenire ciò, PostgreSQL implementa un meccanismo di protezione che, in caso di rischio imminente di wraparound, ferma tutte le nuove scritture sul database, mettendolo in modalità di sola lettura fino a quando un VACUUM anti-wraparound non viene completato. Questo blocco può durare ore o giorni, a seconda delle dimensioni del database e della velocità del vacuum, causando un’interruzione totale del servizio.

Parametri di protezione e monitoraggio

PostgreSQL offre parametri per monitorare e gestire il rischio di wraparound:

  • autovacuum_freeze_max_age: definisce l’età massima in transazioni che una tupla può raggiungere prima di essere considerata un candidato per un “anti-wraparound vacuum” aggressivo (default 200 milioni di transazioni). Se una tabella contiene tuple con XID più vecchi di questo valore, autovacuum forzerà un vacuum su quella tabella, anche se non ha raggiunto le soglie normali di tuple morte.
  • vacuum_freeze_min_age: l’età minima di una tupla (in transazioni) per essere candidata al “freezing” (default 50 milioni di transazioni).

Per monitorare l’età delle transazioni e prevenire il wraparound, è fondamentale interrogare la vista pg_database. In particolare, la colonna datfrozenxid di pg_database mostra l’XID più vecchio che non è ancora stato congelato per quel database. Possiamo calcolare l’età di questo XID rispetto all’XID corrente con la funzione age():

SELECT datname, age(datfrozenxid) FROM pg_database ORDER BY 2 DESC;

Un output tipico:

    datname    |    age
--------------+-----------
    my_app_db  | 150000000
    postgres   |  10000000
    template1  |  10000000
    template0  |  10000000
(4 rows)

Se l’output mostra un age che si avvicina a autovacuum_freeze_max_age (o, peggio, supera i 2 miliardi, che è il punto di non ritorno), è un segnale di allarme rosso. In questi casi, è necessario un intervento immediato per forzare VACUUM sulle tabelle interessate, o per aumentare l’aggressività dell’autovacuum, altrimenti il database si bloccherà. Leggi anche: Backup 3-2-1-1-0: la Regola Spiegata con Esempio Reale

Monitorare l’autovacuum nel tempo

Un monitoraggio efficace è la chiave per prevenire problemi legati a VACUUM e autovacuum. Oltre alle query già menzionate, è utile integrare il monitoraggio di PostgreSQL con strumenti esterni per tenere traccia delle tendenze nel tempo.

Log di PostgreSQL

I log di PostgreSQL sono una fonte inestimabile di informazioni. È possibile configurare il parametro log_autovacuum_min_duration (nel postgresql.conf) per registrare nel log tutti i vacuum che superano una certa durata in millisecondi (es. log_autovacuum_min_duration = 250). Questo permette di individuare vacuum troppo lenti o che falliscono, fornendo dettagli utili per il tuning o il troubleshooting. I log mostreranno anche gli “anti-wraparound vacuum” o i “failsafe vacuum”, che sono segnali di allarme di un autovacuum non sufficientemente aggressivo.

Strumenti di monitoraggio esterni

Piattaforme come Prometheus con Grafana, Zabbix o equivalenti cloud (es. Azure Monitor, AWS CloudWatch) possono raccogliere metriche da pg_stat_user_tables e pg_stat_activity e visualizzarle in dashboard. Monitorare grafici come:

  • n_dead_tup per le tabelle più attive: per identificare il bloat in crescita.
  • last_autovacuum e last_autoanalyze: per verificare la frequenza e l’efficacia dell’autovacuum.
  • age(datfrozenxid): per tenere sotto controllo il rischio di wraparound a livello di database.
  • autovacuum_count e vacuum_count: per capire quanti vacuum automatici e manuali vengono eseguiti.

Questi dati, visualizzati nel tempo, consentono di identificare pattern, anticipare problemi e validare l’efficacia delle modifiche ai parametri di autovacuum. Un aumento costante di n_dead_tup su una tabella, nonostante frequenti autovacuum, potrebbe indicare la necessità di un tuning più aggressivo o di un’analisi del workload applicativo.

Errori comuni e troubleshooting

Errore o messaggio esatto Causa Soluzione
FATAL: database is in "recovery mode" (a causa di wraparound) Il database ha raggiunto il limite di transaction ID e si è bloccato per prevenire la corruzione dei dati. Eseguire un VACUUM FREEZE o VACUUM aggressivo (manualmente o tramite autovacuum) per congelare le tuple vecchie. Richiede downtime.
ERROR: relation "mytable" does not exist (dopo VACUUM FULL) Un VACUUM FULL non è terminato correttamente o è stato interrotto, lasciando la tabella in uno stato inconsistente. Controllare i log di PostgreSQL per il motivo del fallimento. Ripristinare da backup o tentare un REINDEX TABLE se il problema è sull’indice.
Query lente su tabelle con molte modifiche Accumulo di tuple morte (bloat) che rallenta le scansioni o statistiche del planner obsolete. Eseguire VACUUM (ANALYZE) sulla tabella. Se il problema persiste, tunare i parametri di autovacuum per renderlo più frequente.
idle in transaction o idle in transaction (aborted) in pg_stat_activity Sessioni applicative che aprono transazioni ma non le chiudono, bloccando il cutoff di VACUUM e impedendo la pulizia delle tuple morte. Identificare le query o i processi applicativi responsabili e correggere il codice. Terminare manualmente le sessioni bloccanti (pg_terminate_backend(pid)).
Spazio su disco del tablespace in costante crescita Autovacuum non riesce a recuperare lo spazio al sistema operativo, o la tabella è gravemente gonfiata. Verificare l’efficacia di autovacuum. Se il bloat è estremo, considerare un VACUUM FULL in finestra di manutenzione o strategie di migrazione/partizionamento.

Domande frequenti

Devo eseguire VACUUM manualmente anche con autovacuum abilitato?

Generalmente no. L’autovacuum è progettato per gestire la maggior parte delle esigenze di pulizia. L’intervento manuale è consigliato solo in casi specifici: dopo bulk load massivi, per risolvere un bloat grave che l’autovacuum non riesce a gestire, o in situazioni di emergenza come il rischio di transaction ID wraparound. Un buon tuning dell’autovacuum riduce al minimo la necessità di interventi manuali.

VACUUM FULL è sempre da evitare?

VACUUM FULL è un’operazione molto invasiva che blocca completamente la tabella. Va evitato nella manutenzione ordinaria. È giustificato solo quando è strettamente necessario recuperare una quantità significativa di spazio su disco al sistema operativo da una tabella gravemente gonfiata e non ci sono alternative pratiche, e solo in finestre di manutenzione programmate con basso carico applicativo.

Come posso sapere se una tabella è “gonfia”?

Puoi usare la query SELECT relname, n_dead_tup, n_live_tup FROM pg_stat_user_tables ORDER BY n_dead_tup DESC; per vedere il numero di tuple morte. Per un’analisi più dettagliata, installa l’estensione pgstattuple e usa SELECT * FROM pgstattuple('mia_tabella'); per ottenere la percentuale esatta di tuple morte e spazio libero.

Qual è l’impatto di autovacuum sulle performance?

L’autovacuum consuma risorse (CPU, I/O) durante l’esecuzione. Tuttavia, il suo impatto è mitigato da meccanismi di cost-based throttling che rallentano il processo se il carico sul sistema è elevato. Se ben configurato, il beneficio di un database pulito e con statistiche aggiornate supera di gran lunga il costo del vacuuming, prevenendo problemi di performance ben più gravi causati dal bloat.

Cosa succede se disabilito autovacuum?

Disabilitare l’autovacuum è fortemente sconsigliato. Senza di esso, le tuple morte si accumuleranno indefinitamente, portando a un bloat estremo, degrado delle performance e, in ultima analisi, al rischio di transaction ID wraparound che bloccherà il database. La manutenzione manuale sarebbe un onere enorme e difficile da gestire in un ambiente dinamico.

Conclusioni con takeaway operativi

La gestione di VACUUM e autovacuum è un pilastro fondamentale dell’amministrazione di PostgreSQL. Comprendere il meccanismo MVCC e il ruolo delle tuple morte è essenziale per mantenere un database performante e stabile. I takeaway operativi chiave sono:

  1. Monitoraggio Proattivo: Utilizza pg_stat_user_tables, pg_stat_activity e pgstattuple per identificare tempestivamente le tabelle con bloat o con n_dead_tup in crescita. Monitora anche age(datfrozenxid) per prevenire il wraparound.
  2. Tuning Granulare di Autovacuum: Non fare affidamento solo sui parametri globali. Regola autovacuum_vacuum_threshold e autovacuum_vacuum_scale_factor a livello di singola tabella per quelle più dinamiche, bilanciando aggressività e consumo di risorse.
  3. VACUUM Standard vs. VACUUM FULL: Preferisci sempre il VACUUM standard per la manutenzione ordinaria, in quanto non blocca le operazioni DML. Riserva VACUUM FULL solo a casi eccezionali di bloat estremo che richiede il recupero di spazio al sistema operativo, pianificandolo in finestre di manutenzione.
  4. Attenzione alle Transazioni Lunghe: Le sessioni idle in transaction possono bloccare il cutoff di VACUUM e causare l’accumulo di tuple morte. Identifica e risolvi queste problematiche a livello applicativo.
  5. Log e Alerting: Configura log_autovacuum_min_duration e integra i log di PostgreSQL con il tuo sistema di alerting per essere avvisato di vacuum problematici o del rischio di wraparound.

Implementando queste pratiche, potrai assicurare che il tuo database PostgreSQL rimanga un componente robusto e performante del tuo stack IT, evitando interruzioni inaspettate e mantenendo sotto controllo il consumo di risorse.

Fonti

Aggiornato: novembre 2026

Condividi questo articolo:

Scritto da

Rosario Giordano

Rosario Giordano è System Administrator e consulente IT specializzato in cybersecurity e cloud, con oltre 20 anni di esperienza nella gestione di infrastrutture Linux enterprise. Le sue aree di competenza includono hardening di SSH, piattaforme Kubernetes, database PostgreSQL, ambient i virtualizzati VMware e Proxmox, nonché la conformità ai framework di sicurezza NIS2 e ISO 27001.