Monitorare il motore colonnare

Questa pagina descrive come monitorare l'utilizzo del motore colonnare.

Verificare l'utilizzo del motore colonnare utilizzando EXPLAIN

Puoi verificare l'utilizzo del motore colonnare utilizzando l'istruzione EXPLAIN per osservare i nuovi operatori colonnari che vengono visualizzati nel piano di query generato di una query.

Client psql

EXPLAIN (ANALYZE,COSTS OFF,BUFFERS,TIMING OFF,SUMMARY OFF)
  SELECT l_returnflag, l_linestatus, l_quantity, l_extendedprice,
         l_discount, l_tax
    FROM lineitem
   WHERE l_shipdate <= date '1992-08-06'
;
                                 QUERY PLAN
-----------------------------------------------------------------------------
 Append (actual rows=3941797 loops=1)
   Buffers: shared hit=9
   ->  Custom Scan (columnar scan) on lineitem (actual rows=3941797 loops=1)
         Filter: (l_shipdate <= '1992-08-06'::date)
         Rows Removed by Columnar Filter: 56054083
         Columnar cache search mode: columnar filter only
         Buffers: shared hit=9
   ->  Seq Scan on lineitem (never executed)
  Filter: (l_shipdate <= '1992-08-06'::date)
  • Custom Scan (columnar scan) indica che la scansione del motore colonnare è inclusa nel piano di query.
  • Rows Removed by Columnar Filter elenca il numero di righe filtrate dall'esecuzione vettorizzata colonnare.
  • Columnar cache search mode può essere columnar filter only, native o row store scan. Lo strumento di pianificazione sceglie la modalità di ricerca automaticamente in base alla capacità di valutazione del costo e del pushdown.

Quando il planner sceglie la modalità native, esegue il push-down di alcuni operatori colonnari nella scansione:

  • Rows Aggregated by Columnar Scan elenca il numero di righe aggregate.
  • Rows Sorted by Columnar Scan elenca il numero di righe ordinate.
  • Rows Limited by Columnar Scan elenca il numero limitato di righe scansionate.

Con i join, gli operatori di scansione colonnare possono utilizzare anche la modalità Late Materialization.

Client psql

EXPLAIN (ANALYZE,COSTS OFF,BUFFERS,TIMING OFF,SUMMARY OFF)
  SELECT l_shipmode, o_orderpriority
    FROM orders, lineitem
   WHERE o_orderkey = l_orderkey
         AND l_shipmode in ('AIR', 'FOB')
         AND l_receiptdate >= date '1995-01-01'
;
                                 QUERY PLAN
-----------------------------------------------------------------------------
 Hash Join (actual rows=9865288 loops=1)
   Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
   Buffers: temp read=127738 written=127738
   ->  Append (actual rows=9865288 loops=1)
         ->  Custom Scan (columnar scan) on lineitem (actual rows=9865288 loops=1)
               Filter: ((l_shipmode = ANY ('{AIR,FOB}'::bpchar[])) AND
               (l_receiptdate >= '1995-01-01'::date))
               Rows Removed by Columnar Filter: 50130592
               Columnar cache search mode: native
         ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem
             (never executed)
               Filter: ((l_shipmode = ANY ('{AIR,FOB}'::bpchar[])) AND
               (l_receiptdate >= '1995-01-01'::date))
   ->  Hash (actual rows=15000000 loops=1)
         Buckets: 1048576  Batches: 32  Memory Usage: 37006kB
         Buffers: temp written=83357
         ->  Append (actual rows=15000000 loops=1)
               ->  Custom Scan (columnar scan) on orders (actual rows=15000000
                   loops=1)
                     Rows Removed by Columnar Filter: 0
                     Columnar projection mode: late materialization
                     Columnar cache search mode: native
               ->  Seq Scan on orders (never executed)

Columnar projection mode può essere late materialization. Gli operatori di colonne scelgono automaticamente questa modalità quando il planner ottimizza la proiezione posticipando la materializzazione di alcuni valori delle colonne.

Visualizzare l'utilizzo del join vettorizzato del motore colonnare

Puoi verificare il nuovo operatore di unione vettoriale utilizzando l'istruzione EXPLAIN per osservare il nuovo operatore Vectorized Hash Join che viene visualizzato nel piano di query generato di una query.

EXPLAIN (ANALYZE,COSTS OFF,BUFFERS,TIMING OFF,SUMMARY OFF)
  SELECT l_quantity, l_extendedprice, l_discount, l_tax
    FROM lineitem, orders
    WHERE l_shipdate <= date '2022-08-06'
    AND  l_orderkey = o_orderkey
    AND  o_orderdate <= date '2025-03-07';
                                      QUERY PLAN
---------------------------------------------------------------------------------------
 Vectorized Hash Join (actual rows=3934686 loops=1)
   Vectorized partitioning, Partitions: 16 (Disk usage: 208MB)
   (Peak Memory Usage: 27MB, Threads: 1)
   Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
   Rows Removed by Bloom Filter: 0
   Buffers: temp read=26728 written=26728
   ->  Append (actual rows=3934686 loops=1)
         ->  Custom Scan (columnar scan) on lineitem (actual rows=3934686 loops=1)
               Filter: (l_shipdate <= '2022-08-06'::date)
               Rows Removed by Columnar Filter: 56051366
               Columnar cache search mode: native
         ->  Seq Scan on lineitem (never executed)
               Filter: (l_shipdate <= '2022-08-06'::date)
   ->  Vectorized Hash (actual rows=7245824 loops=1)
         Build bloom filter, Memory Usage: 1024kB
         ->  Append (actual rows=7245824 loops=1)
               ->  Custom Scan (columnar scan) on orders (actual rows=7245824 loops=1)
                     Filter: (o_orderdate <= '2025-03-07'::date)
                     Rows Removed by Columnar Filter: 7754176
                     Columnar cache search mode: native
               ->  Seq Scan on orders (never executed)
                     Filter: (o_orderdate <= '2025-03-07'::date)
  • Vectorized Hash Join indica che l'unione tra le due relazioni ha utilizzato l'unione hash vettorizzata.
  • Vectorized partitioning, Partitions: elenca il numero di partizioni in cui sono stati suddivisi i dati.

Utilizza l'opzione COLUMNAR_ENGINE per EXPLAIN

Il comando EXPLAIN supporta l'opzione COLUMNAR_ENGINE. Se specificato, il comando stampa Columnar Check messaggi nel piano EXPLAIN per mostrare cosa potrebbe aver portato il pianificatore o l'executor a fare determinate scelte relative al motore colonnare per il piano. Il comando stampa anche ulteriori dettagli specifici del motore colonnare. Il messaggio è associato al nodo di scansione non colonnare. In genere indica la prima causa che impedisce la scelta di una scansione colonnare per una scansione. Alcuni esempi di cause sono the table is too small, a needed column of the table is not in the CE store o a needed column has a CE unsupported data type.

Il seguente output di esempio del comando stampa un messaggio Columnar Check:

Client psql

EXPLAIN (COLUMNAR_ENGINE, COSTS OFF)
SELECT * FROM sample_small_table
WHERE col1 > 10000;
              QUERY PLAN
--------------------------------------
 Seq Scan on sample_small_table
   Filter: (col1 > 10000)
   Columnar Check: table is too small

A seconda del messaggio, l'utente può:

  • Risolvi la causa specifica e poi esegui di nuovo il comando per confermare il piano colonnare.
  • Ripeti la stessa procedura. Può esserci più di una causa e la clausola tenta di elencare solo la prima.

Il seguente esempio mostra la stampa di dettagli aggiuntivi specifici per il motore colonnare:

Client psql

EXPLAIN (ANALYZE, COLUMNAR_ENGINE, COSTS OFF, TIMING OFF, SUMMARY OFF, VERBOSE) SELECT SUM(c1) FROM counter_table WHERE c2 > 0 and c2 < 80000;
                                         QUERY PLAN
---------------------------------------------------------------------------------------------
 Aggregate (actual rows=1 loops=1)
   Output: sum(c1)
   ->  Append (actual rows=79999 loops=1)
         ->  Custom Scan (columnar scan) on public.counter_table (actual rows=79999 loops=1)
               Output: c1
               Filter: ((counter_table.c2 > 0) AND (counter_table.c2 < 80000))
               Rows Removed by Columnar Filter: 1
               Rows Aggregated by Columnar Scan: 79999
               Bytes fetched from storage cache: 1392655
               Columnar cache search mode: native
         ->  Seq Scan on public.counter_table (never executed)
               Output: c1
               Filter: ((counter_table.c2 > 0) AND (counter_table.c2 < 80000))
(13 rows)

Visualizzare le informazioni sulle tabelle con colonne nel column store

Puoi visualizzare informazioni sulle tabelle o sulle viste materializzate con colonne nello column store eseguendo una query sulla vista g_columnar_relations.

Client psql

SELECT * FROM g_columnar_relations;

-[ RECORD 1 ]------------------+---------------------
database_name                  | postgres
schema_name                    | public
relation_name                  | uuid_mod_test_stored
status                         | Usable
size                           | 700672237
invalid_block_count            | 0
block_count_in_cc              | 123907
total_block_count              | 123907
auto_refresh_trigger_count     | 0
auto_refresh_failure_count     | 0
auto_refresh_trigger_timestamp | NULL
auto_refresh_start_timestamp   | NULL
auto_refresh_end_timestamp     | NULL
auto_refresh_recent_status     | NONE YET

Visualizzare informazioni sulle colonne nel column store

Puoi visualizzare le informazioni sulle colonne nel column store eseguendo query sulla visualizzazione g_columnar_columns, incluse le dimensioni delle colonne e l'ora dell'ultimo accesso.

Client psql

SELECT database_name, schema_name, relation_name, column_name, size_in_bytes, last_accessed_time FROM g_columnar_columns;

Visualizza le statistiche di esecuzione del motore colonnare per le query recenti

Puoi visualizzare le statistiche di esecuzione del motore colonnare per le query recenti utilizzando la visualizzazione g_columnar_stat_statements. Questa visualizzazione fornisce statistiche specifiche del motore colonnare e richiede l'attivazione dell'estensione pg_stat_statements.

Client psql

Per visualizzare queste statistiche, segui questi passaggi:

  1. Attiva l'estensione pg_stat_statements: 
    CREATE EXTENSION pg_stat_statements;
  2. Esegui le query per cui vuoi visualizzare le statistiche. Puoi farlo manualmente o lasciare che le applicazioni vengano eseguite per un po' di tempo per generare dati.
  3. Esegui una query sulla visualizzazione g_columnar_stat_statements per visualizzare le statistiche raccolte. 
    SELECT * FROM g_columnar_stat_statements WHERE page_read > 0;

    L'output è simile al seguente:

    -[ RECORD 1 ]--------------------------+--------------------
user_id                              | 16391
db_id                                | 1008530
query_id                             | 6672321263128921833
columnar_unit_read                   | 32
page_read                            | 128003
rows_filtered                        | 0
columnar_scan_time                   | 0
vectorized_join_time                 | 0
vectorized_aggregation_time          | 0
vectorized_aggregation_vj_time       | 0
-[ RECORD 2 ]--------------------------+--------------------
user_id                              | 16391
db_id                                | 1008530
query_id                             | -816808861243589285
columnar_unit_read                   | 30
page_read                            | 119811
rows_filtered                        | 0
columnar_scan_time                   | 0
vectorized_join_time                 | 0
vectorized_aggregation_time          | 0
vectorized_aggregation_vj_time       | 0

Visualizzare l'utilizzo della memoria dello store di colonne

Per visualizzare la quantità di RAM inutilizzata disponibile per il motore a colonne, puoi interrogare la funzione google_columnar_engine_memory_available(). L'intero risultante mostra la memoria disponibile in megabyte (MB).

SELECT google_columnar_engine_memory_available();

Visualizzare informazioni sugli indici nello column store

Puoi visualizzare informazioni su stato, dimensioni e varie metriche relative al rendimento degli indici colonna eseguendo query sulla visualizzazione g_columnar_indexes.

Client psql

SELECT
     database_name, schema_name, index_name, status, size,
     total_partition_count, non_leaf_partition_count, leaf_partition_count,
     invalid_block_count, block_count_in_cc, total_block_count,
     creation_time, auto_refresh_trigger_count,
     auto_refresh_failure_count, auto_refresh_trigger_timestamp,
     auto_refresh_start_timestamp, auto_refresh_end_timestamp,
     auto_refresh_recent_status
FROM g_columnar_indexes;

La tabella seguente descrive i campi della visualizzazione g_columnar_indexes.

Campo Tipo di dati Descrizione
database_name NOME
schema_name NOME Nome dello schema a cui appartiene l'indice
index_name NOME Nome dell'indice
stato NOME Stato dell'indice nel motore colonnare
dimensioni BIGINT Dimensione dell'indice nel motore colonnare
total_partition_count BIGINT Numero totale di partizioni dell'indice nel motore colonnare
non_leaf_partition_count BIGINT Numero totale di partizioni non foglia dell'indice nel motore colonnare
leaf_partition_count BIGINT Numero totale di partizioni foglia dell'indice nel motore colonnare
invalid_block_count BIGINT Numero totale di blocchi non validi nel motore colonnare per l'indice
block_count_in_cc BIGINT Numero totale di blocchi dell'indice nel motore colonnare
total_block_count BIGINT Numero totale di blocchi dell'indice
creation_time BIGINT Tempo di creazione dell'indice nel motore colonnare
auto_refresh_trigger_count BIGINT Numero totale di aggiornamenti automatici attivati dall'avvio di PostgreSQL.
auto_refresh_failure_count BIGINT Numero totale di errori di aggiornamento automatico dall'avvio di PostgreSQL
auto_refresh_trigger_timestamp BIGINT Timestamp dell'ultimo aggiornamento automatico attivato
auto_refresh_start_timestamp BIGINT Timestamp dell'ultimo aggiornamento automatico avviato
auto_refresh_end_timestamp BIGINT Timestamp dell'aggiornamento automatico più recente completato.
auto_refresh_recent_status TESTO Stato dell'aggiornamento automatico più recente