Bonjour,
Je travaille sous postgresql 9.3 et j'observe le phénomène suivant que je ne parviens pas à expliquer (et à résoudre autre que par un vacuum full sur table) :

J'ai une table présentant la structure suivante :

monitor=# \d pg_snap_stat_all_tables
           Table "public.pg_snap_stat_all_tables"
      Column       |            Type             | Modifiers
-------------------+-----------------------------+-----------
snapid            | integer                     | not null
begin_snaptime    | timestamp without time zone |
end_snaptime      | timestamp without time zone |
datid             | oid                         | not null
datname           | name                        | not null
relid             | oid                         | not null
schemaname        | name                        | not null
relname           | name                        | not null
seq_scan          | bigint                      |
seq_tup_read      | bigint                      |
idx_scan          | bigint                      |
idx_tup_fetch     | bigint                      |
n_tup_ins         | bigint                      |
n_tup_upd         | bigint                      |
n_tup_del         | bigint                      |
n_tup_hot_upd     | bigint                      |
n_live_tup        | bigint                      |
n_dead_tup        | bigint                      |
last_vacuum       | timestamp without time zone |
last_autovacuum   | timestamp without time zone |
last_analyze      | timestamp without time zone |
last_autoanalyze  | timestamp without time zone |
vacuum_count      | bigint                      |
autovacuum_count  | bigint                      |
analyze_count     | bigint                      |
autoanalyze_count | bigint                      |
Indexes:
    "pk_pg_snap_stat_all_tables" PRIMARY KEY, btree (snapid, datid, datname, relid, schemaname, relname)
Foreign-key constraints:
    "ref_snapid" FOREIGN KEY (snapid) REFERENCES pg_snap_snapshots(snapid)

(La pk n'est pas optimale, mais c'est un point de détail que je reverrai plus tard). Je met en place un system de snapshots à intervalles de temps réguliers des différentes tables pg_stat_xxxx et je stocke ces snapshots dans des tables pg_snap_xxxx.

L'alimentation de ma table s'effectue à intervalle de temps régulier en suivant le protocole suivant :
1) insertion des records en provenance de la table pg_stat_all_tables => celà génère un snapshot d'à peu près 3000 lignes
2) delete de tous les records antérieurs aux 30 derniers snapshots réalisés

Je m'attend bien évidemment à avoir des dead tuples et par voie de conséquence, une taille de table qui grossit, malgré les suppressions régulières de records.

Par conséquence le vacuum est activé au niveau base mais également au niveau table afin de m'assurer que les dead tuples sont bien supprimés.

Et c'est effectivement le cas, je maintiens un nombre de dead tuples avoisinant les 4000 records.

Problème :
1) La taille de la table ne cesse de croître alors que le nombre de dead tuples reste stable
2) l'espace libre non utilisé ne cesse de croître : il n'est donc pas réutilisé.

Auriez-vous une piste permettant d'expliquer que l'espace libre n'est pas réutilisé ?

Je précise qu'un full vacuum sur la table entraine la libération de l'intégralité de l'espace libre non occupé.

Ce que je ne comprend pas, c'est la non réutilisation de l'espace libre libéré par un vacuum classique, sachant que celui-ci semble fonctionner correctement puisque le nombre de dead tuples stagne.

Par avance merci pour vos avis éclairés.