Spaltenbasierte Engine überwachen

Verwendung der spaltenorientierten Engine mit EXPLAIN prüfen

Wenn Sie die neuen spaltenorientierten Operatoren sehen möchten, die im generierten Abfrageplan einer Abfrage angezeigt werden, können Sie die Verwendung der spaltenorientierten Engine mit der EXPLAIN-Anweisung überprüfen.

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) gibt an, dass das Scannen der Spalten-Engine im Abfrageplan enthalten ist.
• Unter Rows Removed by Columnar Filter wird die Anzahl der Zeilen aufgeführt, die durch die spaltenweise vektorisierte Ausführung herausgefiltert wurden.
• Columnar cache search mode kann columnar filter only, native oder row store scan sein. Der Planer wählt den Suchmodus automatisch basierend auf den Kosten und der Möglichkeit zur Pushdown-Bewertung aus.

Wenn der Planer den Modus native auswählt, werden einige der spaltenorientierten Operatoren in den Scan verschoben:

• Unter Rows Aggregated by Columnar Scan wird die Anzahl der zusammengefassten Zeilen aufgeführt.
• Unter Rows Sorted by Columnar Scan wird die Anzahl der sortierten Zeilen aufgeführt.
• Unter Rows Limited by Columnar Scan wird die begrenzte Anzahl der gescannten Zeilen aufgeführt.

Bei Joins können Spaltenscanoperatoren auch den Late Materialization-Modus verwenden.

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 kann late materialization sein. Spaltenorientierte Operatoren wählen diesen Modus automatisch aus, wenn der Planner die Projektion optimiert, indem er die Materialisierung einiger Spaltenwerte verzögert.

Verwendung von vektorisierten Joins in der spaltenbasierten Engine ansehen

Sie können den neuen vektorisierten Join-Operator mit der EXPLAIN-Anweisung überprüfen, um den neuen Vectorized Hash Join-Operator zu beobachten, der im generierten Abfrageplan einer Abfrage angezeigt wird.

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 gibt an, dass für den Join zwischen den beiden Beziehungen der vektorisierte Hash-Join verwendet wurde.
• Unter Vectorized partitioning, Partitions: wird die Anzahl der Partitionen aufgeführt, in die die Daten aufgeteilt wurden.

Informationen zu Tabellen mit Spalten im Spaltenspeicher ansehen

Sie können Informationen zu den Tabellen oder materialisierten Ansichten mit Spalten im Spaltenspeicher abrufen, indem Sie die Ansicht g_columnar_relations abfragen.

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 ]────────┼───────────────────┤

Informationen zu den Spalten im Spaltenspeicher ansehen

Sie können Informationen zu den Spalten im Spaltenspeicher abrufen, indem Sie die Ansicht g_columnar_columns abfragen. Dazu gehören die Größe der Spalten und die letzte Zugriffszeit.

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

Ausführungsstatistiken der spaltenbasierten Engine für aktuelle Abfragen ansehen

Sie können sich die Ausführungsstatistiken der Spalten-Engine für die letzten Abfragen in der Ansicht g_columnar_stat_statements ansehen. In dieser Ansicht werden der pg_stat_statements-Ansicht, die von der pg_stat_statements-Erweiterung bereitgestellt wird, Spaltenstatistiken für die Engine hinzugefügt. Wenn Sie diese Ansicht verwenden möchten, müssen Sie zuerst die Erweiterung pg_stat_statements aktivieren.

1. Aktivieren Sie die Erweiterung pg_stat_statements:

   CREATE EXTENSION pg_stat_statements;
   

2. Führen Sie die Abfragen aus, deren Statistiken Sie sehen möchten. Sie können dies manuell tun oder genügend Zeit vergehen lassen, damit Ihre Anwendungen diese Abfragen mit aktivierter pg_stat_statements ausführen.
3. Fragen Sie die Ansichten g_columnar_stat_statements und pg_stat_statements ab. Mit der folgenden Abfrage werden alle Spaltenstatistiken abgerufen, einschließlich der Statistiken, die vor der Erstellung der Erweiterung pg_stat_statements erfasst wurden. Der 10-Wert von userid gibt an, dass die Statistiken vor der Erstellung der Erweiterung pg_stat_statements erfasst wurden.

   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                             │
   └─────────────────────┴───────────────────────────────┘
   

Arbeitsspeichernutzung des Spaltenspeichers ansehen

Wenn Sie sehen möchten, wie viel ungenutzter RAM für das Säulenmodul verfügbar ist, können Sie die Funktion google_columnar_engine_memory_available abfragen. Die ausgegebene Ganzzahl gibt den verfügbaren Speicher in Megabyte (MB) an.

SELECT google_columnar_engine_memory_available();

Speichercache der spaltenbasierten Engine ansehen

Wenn Sie Daten zum Speichercache der spaltenorientierten Engine aufrufen und überwachen möchten, können Sie die folgenden Funktionen aufrufen:

Im Folgenden sehen Sie, wie Sie eine SQL-Funktion abfragen, mit der Sie Daten zum Speichercache der spaltenorientierten Engine ansehen und überwachen können:

SELECT SQL_FUNCTION;

Ersetzen Sie SQL_FUNCTION durch den Namen der Funktion für den Spaltenspeicher-Cache, die Sie aus der vorherigen Tabelle verwenden möchten.