Monitorare il motore colonnare

Seleziona una versione della documentazione:

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

Verifica l'utilizzo del motore colonnare utilizzando EXPLAIN

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

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 indica il numero di righe filtrate dall'esecuzione vettorizzata colonnare.
  • Columnar cache search mode può essere columnar filter only, native o row store scan. Il planner sceglie automaticamente la modalità di ricerca in base alla valutazione dei costi e della funzionalità di pushdown.

Quando il planner sceglie la modalità native, esegue il pushdown 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, anche gli operatori di scansione colonnare possono utilizzare la modalità Late Materialization.

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 colonnari scelgono automaticamente questa modalità quando il planner ottimizza la proiezione posticipando la materializzazione di alcuni valori di colonna.

Visualizza l'utilizzo del join vettorizzato del motore colonnare

Puoi verificare il nuovo operatore di join vettorizzato utilizzando l'istruzione EXPLAIN per osservare il nuovo operatore Vectorized Hash Join che appare 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: indica il numero di partizioni in cui sono stati suddivisi i dati.

Visualizza le informazioni sulle tabelle con colonne nell'archivio di colonne

Puoi visualizzare le informazioni sulle tabelle o sulle viste materializzate con colonne nel columnstore eseguendo una query sulla vista g_columnar_relations.

SELECT * FROM g_columnar_relations;

┌─[ RECORD 1 ]────────┬───────────────────┐
│ relation_name       │ tbl_parallel_test │
│ schema_name         │ public            │
│ database_name       │ advisor           │
│ status              │ Usable            │
│ size                │ 581431259         │
│ columnar_unit_count │ 3                 │
│ invalid_block_count │ 0                 │
│ total_block_count   │ 8337              │
├─[ RECORD 2 ]────────┼───────────────────┤
│ relation_name       │ lineitem          │
│ schema_name         │ public            │
│ database_name       │ advisor           │
│ status              │ Usable            │
│ size                │ 423224944         │
│ columnar_unit_count │ 29                │
│ invalid_block_count │ 0                 │
│ total_block_count   │ 115662            │
├─[ RECORD 3 ]────────┼───────────────────┤

Visualizza le informazioni sulle colonne nell'archivio di colonne

Puoi visualizzare le informazioni sulle colonne nell'archivio di colonne eseguendo una query sulla vista g_columnar_columns, incluse le dimensioni delle colonne e l'ora dell'ultimo accesso.

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

Visualizza l'archivio di colonne nell'interfaccia utente web

Puoi anche visualizzare l'inventario del columnstore nell'interfaccia utente web di AlloyDB Omni:

  1. Connettiti alla UI web e seleziona il tuo cluster.
  2. Nel menu di navigazione, fai clic su Motore colonnare.
  3. Nella tabella Dati dell'archivio a colonne, esamina le colonne compilate nell'archivio a colonne:
    • Nome database: il database che contiene la relazione.
    • Nome schema: lo schema della relazione.
    • Nome relazione: il nome della tabella o della vista materializzata.
    • Nome colonna: il nome della colonna colonnarizzata.
    • Tipo di colonna: il tipo di dati SQL della colonna.
    • Stato: lo stato di idoneità della colonna nell'archivio colonne (ad esempio, Usable).
    • Dimensioni: il footprint della memoria della colonna nel columnstore.
    • Accessi: il numero di volte in cui è stato eseguito l'accesso alla colonna tramite scansioni colonnari.
    • Ultimo accesso: il timestamp dell'accesso più recente alla scansione colonnare.

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 vista g_columnar_stat_statements. Questa vista aggiunge le statistiche del motore colonnare alla vista pg_stat_statements fornita dall'estensione pg_stat_statements. Per utilizzare questa visualizzazione, devi prima attivare l'estensione pg_stat_statements.

  1. Attiva l'estensione pg_stat_statements: 
    CREATE EXTENSION pg_stat_statements;
  2. Esegui le query di cui vuoi visualizzare le statistiche. Puoi farlo manualmente o lasciare che passi abbastanza tempo affinché le tue applicazioni eseguano queste query con pg_stat_statements abilitato.
  3. Esegui query sulle viste g_columnar_stat_statements e pg_stat_statements. Tieni presente che la seguente query recupera tutte le statistiche di esecuzione colonnare, incluse quelle raccolte prima della creazione dell'estensione pg_stat_statements. Il valore 10 di userid indica che le statistiche sono state raccolte prima della creazione dell'estensione pg_stat_statements. 
    SELECT *
FROM pg_stat_statements(TRUE) AS pg_stats
     FULL JOIN g_columnar_stat_statements AS g_stats
     ON pg_stats.userid = g_stats.user_id AND
        pg_stats.dbid = g_stats.db_id AND
        pg_stats.queryid = g_stats.query_id
WHERE columnar_unit_read > 0;

┌─[ RECORD 1 ]────────┬───────────────────────────────
│ userid              │ 10                            │
│ dbid                │ 33004                         │
│ queryid             │ 6779068104316758833           │
│ query               │ SELECT  l_returnflag,        ↵│
│                     │         l_linestatus,        ↵│
│                     │         l_quantity,          ↵│
│                     │         l_extendedprice,     ↵│
│                     │         l_discount,          ↵│
│                     │         l_tax                ↵│
│                     │FROM  lineitem                ↵│
│                     │WHERE  l_shipdate <= date $1│
│ calls               │ 1                             │
│ total_time          │ 299.969983                    │
│ min_time            │ 299.969983                    │
│ max_time            │ 299.969983                    │
│ mean_time           │ 299.969983                    │
│ stddev_time         │ 0                             │
│ rows                │ 392164                        │
│ shared_blks_hit     │ 0                             │
│ shared_blks_read    │ 0                             │
│ shared_blks_dirtied │ 0                             │
│ shared_blks_written │ 0                             │
│ local_blks_hit      │ 0                             │
│ local_blks_read     │ 0                             │
│ local_blks_dirtied  │ 0                             │
│ local_blks_written  │ 0                             │
│ temp_blks_read      │ 0                             │
│ temp_blks_written   │ 0                             │
│ blk_read_time       │ 0                             │
│ blk_write_time      │ 0                             │
│ user_id             │ 10                            │
│ db_id               │ 33004                         │
│ query_id            │ 6779068104316758833           │
│ columnar_unit_read  │ 29                            │
│ page_read           │ 115662                        │
│ rows_filtered       │ 0                             │
│ columnar_scan_time  │ 0                             │
└─────────────────────┴───────────────────────────────┘

Visualizza le statistiche delle query colonnari nell'interfaccia utente web

Dopo aver attivato l'estensione pg_stat_statements, puoi anche esaminare le statistiche di esecuzione delle query colonnari nell'interfaccia utente web di AlloyDB Omni:

  1. Connettiti alla UI web e seleziona il tuo cluster.
  2. Nel menu di navigazione, fai clic su Motore colonnare.
  3. Nella tabella Query colonnari, esamina le statistiche di esecuzione delle query analitiche che hanno utilizzato l'archivio di colonne:
    • ID query: l'identificatore della query sottoposta a sanitizzazione.
    • Query: il testo dell'istruzione SQL sottoposto a sanitizzazione, con i valori costanti sostituiti da segnaposto.
    • Numero di chiamate: il numero di volte in cui è stata eseguita la query.
    • Media righe recuperate: il numero medio di righe restituite per esecuzione.
    • Latenza media: la latenza di esecuzione media della query.
    • Latenza massima: la latenza di esecuzione massima registrata per la query.
    • Unità colonnare letta: il numero di unità colonnari lette dal datastore a colonne.
    • Pagine lette: il numero di pagine lette durante l'esecuzione.

Visualizza la memoria utilizzata dal columnstore

Per visualizzare la quantità di RAM inutilizzata disponibile per il motore colonnare, puoi eseguire una query sulla funzione google_columnar_engine_memory_available. Il numero intero di output mostra la memoria disponibile in megabyte (MB).

SELECT google_columnar_engine_memory_available();

Visualizza le dimensioni e le impostazioni della memoria del columnstore nell'interfaccia utente web

Puoi anche controllare il consumo di memoria e le impostazioni di configurazione del column store nell'interfaccia utente web di AlloyDB Omni:

  1. Connettiti alla UI web e seleziona il tuo cluster.
  2. Nel menu di navigazione, fai clic su Motore colonnare.
  3. Esamina la sezione Impostazioni archivio a colonne, che mostra i seguenti indicatori di stato e memoria:
    • Motore colonnare: indica se il motore colonnare è attivo (ad esempio Enabled).
    • Dimensioni della memoria: mostra la quantità di memoria dello spazio di archiviazione a colonne in uso rispetto alla memoria colonnare totale allocata (ad esempio, 2.0 MB used of 1024.0 MB).
    • Auto Columnarization: indica se la colonnarizzazione automatica è abilitata (ad esempio, Enabled).
    • Frequenza di esecuzione: mostra l'intervallo di pianificazione per le esecuzioni automatiche della columnarizzazione (ad esempio, Every 5 minutes).
    • Scansione colonnare: indica se l'esecuzione della scansione colonnare è abilitata (ad esempio, Enabled).

Visualizza la cache di archiviazione del motore colonnare

Per visualizzare e monitorare i dati relativi alla cache di archiviazione del motore colonnare, puoi utilizzare i seguenti comandi:

Comando Descrizione
SELECT google_columnar_engine_storage_cache_used(); Restituisce le dimensioni della cache di archiviazione del motore colonnare utilizzata.
SELECT google_columnar_engine_storage_cache_available(); Restituisce le dimensioni della cache di archiviazione del motore colonnare non utilizzata.
SHOW google_columnar_engine.storage_cache_size; Restituisce la quantità totale della dimensione configurata della cache di archiviazione per il motore colonnare.