Monitoraggio dell'avanzamento della costruzione dell'indice in PostgreSQL

36

Esiste un modo per monitorare l'avanzamento della creazione di un indice in PostgreSQL. Sto creando un indice su una tabella di grandi dimensioni e vorrei vedere quanto velocemente si sta verificando.

C'è un modo per monitorare questo?

postgresql index

— myahya
fonte

se stai usando psql, dovresti provare \ timing

— sftsz il

21

Secondo la pagina di manutenzione degli indici di Postgres Wiki , puoi scoprire lo stato corrente di tutti i tuoi indici con:

SELECT
  t.tablename,
  indexname,
  c.reltuples AS num_rows,
  pg_size_pretty(pg_relation_size(quote_ident(t.tablename)::text)) AS table_size,
  pg_size_pretty(pg_relation_size(quote_ident(indexrelname)::text)) AS index_size,
  CASE WHEN indisunique THEN 'Y'
    ELSE 'N'
  END AS UNIQUE,
  idx_scan AS number_of_scans,
  idx_tup_read AS tuples_read,
  idx_tup_fetch AS tuples_fetched
FROM pg_tables t
  LEFT OUTER JOIN pg_class c ON t.tablename=c.relname
  LEFT OUTER JOIN
    ( SELECT c.relname AS ctablename, ipg.relname AS indexname, x.indnatts AS number_of_columns, idx_scan, idx_tup_read, idx_tup_fetch, indexrelname, indisunique FROM pg_index x
      JOIN pg_class c ON c.oid = x.indrelid
      JOIN pg_class ipg ON ipg.oid = x.indexrelid
      JOIN pg_stat_all_indexes psai ON x.indexrelid = psai.indexrelid )
    AS foo
  ON t.tablename = foo.ctablename
WHERE t.schemaname='public'
ORDER BY 1,2;

La colonna num_rowsindica quante righe sono coperte dal tuo indice e index_sizecrescerà mentre l'indice viene creato.

— databyte
fonte

8

Sospetto che questo potrebbe non funzionare per un nuovo indice, che potrebbe non essere visibile nel catalogo fino a quando la transazione che lo crea non viene impegnata.

— Mustaccio,

@mustaccio hai ragione. sto creando un indice che impiega molto tempo e il comando sopra mostra solo gli indici che sono già stati creati; non mostrerà gli indici in cui 'CREATE INDEX' è ancora in corso.

— orange80,

1

REINDEX TABLE blocca questa query. Almeno, lo ha fatto quando l'ho eseguito il 9.6.

— RonJohn

10

Quindi, non c'è un buon modo per farlo, ma se hai davvero bisogno di sapere ... prima calcola la quantità di spazio che l'indice dovrebbe occupare, in base alla dimensione dei dati * righe + sovraccarico. È quindi possibile utilizzare qualcosa come pfiles o pgtruss per trovare i file che vengono scritti all'interno di $ PGDATA; se gli indici superano 1 GB, sarà una serie di file come nnnnn.n, in cui il primo set di n è coerente e gli ultimi n incrementi per ciascun file GB. Una volta che sai quanti file vengono creati, puoi vedere la crescita e capire quanto sei vicino alla fine. Stima approssimativa, ma forse aiuta.

— xzilla
fonte

4

No, non lo è, anche se lo stai costruendo in modalità CONCURRENT. Anche se in passato ho tenuto d'occhio la dimensione del file nella directory del database, questo non è davvero utile poiché puoi solo immaginare quanto sarà grande.

— araqnid
fonte

3

Sarà possibile nella prossima versione di PostgreSQL 12 (dovrebbe essere rilasciata il 3 ottobre 2019).

SELECT 
  now()::TIME(0), 
  a.query, 
  p.phase, 
  p.blocks_total, 
  p.blocks_done, 
  p.tuples_total, 
  p.tuples_done
FROM pg_stat_progress_create_index p 
JOIN pg_stat_activity a ON p.pid = a.pid;

Vedi i documenti per la vista pg_stat_progress_create_index e il post sul blog di depesz per i dettagli.

— Envek
fonte