Spaltenbasierte Engine überwachen

Durch das Monitoring der spaltenbasierten Engine können Sie prüfen, ob Abfragen den Spaltenspeicher verwenden, und entscheiden, ob Sie den Inhalt oder die Speichergröße ändern möchten. Sie können Abfragepläne mit der Anweisung EXPLAIN prüfen und die Tabellen, Spalten und Indexe des Spaltenspeichers sowie Ausführungsstatistiken und die Arbeitsspeichernutzung aufrufen. Informationen zum Ändern der Einstellungen für die spaltenbasierte Engine finden Sie unter Spaltenbasierte Engine optimieren.

Verwendung der spaltenbasierten Engine mit EXPLAIN überprüfen

Sie können die Verwendung der spaltenbasierten Engine mit der Anweisung EXPLAIN prüfen, um die neuen spaltenbasierten Operatoren zu beobachten, die im generierten Abfrageplan einer Abfrage angezeigt werden.

psql-Client

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 mit der spaltenbasierten Engine im Abfrageplan enthalten ist.
• Rows Removed by Columnar Filter gibt die Anzahl der Zeilen an, die durch die spaltenbasierte 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 Pushdown-Bewertungsfunktion aus.

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

• Rows Aggregated by Columnar Scan gibt die Anzahl der aggregierten Zeilen an.
• Rows Sorted by Columnar Scan listet die Anzahl der sortierten Zeilen auf.
• Rows Limited by Columnar Scan listet die begrenzte Anzahl der gescannten Zeilen auf.

Bei Joins können spaltenbasierte Scanoperatoren auch den Modus Late Materialization verwenden.

psql-Client

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. Spaltenbasierte Operatoren wählen diesen Modus automatisch aus, wenn der Planer die Projektion optimiert, indem er die Materialisierung einiger Spaltenwerte verzögert.

Nutzung des vektorisierten Joins der spaltenbasierten Engine ansehen

Sie können den neuen vektorisierten Join-Operator mit der EXPLAIN-Anweisung prüfen, um den neuen Vectorized Hash Join-Operator zu sehen, 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.
• Vectorized partitioning, Partitions: gibt die Anzahl der Partitionen an, in die die Daten aufgeteilt wurden.

Verwenden Sie die Option COLUMNAR_ENGINE für EXPLAIN.

Der Befehl EXPLAIN unterstützt die Option COLUMNAR_ENGINE. Wenn angegeben, gibt der Befehl Columnar Check-Nachrichten im EXPLAIN-Plan aus, um zu zeigen, was den Planer oder Executor dazu veranlasst haben könnte, bestimmte Entscheidungen im Zusammenhang mit der spaltenbasierten Engine für den Plan zu treffen. Der Befehl gibt auch zusätzliche Details aus, die für die spaltenorientierte Engine spezifisch sind. Die Nachricht ist mit dem nicht spaltenbasierten Scanknoten verknüpft. In der Regel wird die erste Ursache angegeben, die verhindert, dass ein spaltenbasierter Scan für einen Scan ausgewählt wird. Beispiele für Ursachen sind the table is too small, a needed column of the table is not in the CE store oder a needed column has a CE unsupported data type.

Die folgende Beispielausgabe des Befehls gibt eine Columnar Check-Nachricht aus:

psql-Client

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

Je nach Nachricht kann der Nutzer eine der folgenden Aktionen ausführen:

• Beheben Sie die spezifische Ursache und führen Sie den Befehl dann noch einmal aus, um den spaltenbasierten Plan zu bestätigen.
• Wiederholen Sie den Vorgang. Es kann mehrere Ursachen geben. In der Klausel wird nur versucht, die erste aufzulisten.

Im folgenden Beispiel werden zusätzliche Details ausgegeben, die für die spaltenorientierte Engine spezifisch sind:

psql-Client

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)

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.

psql-Client

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

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, einschließlich der Größe dieser Spalten und der letzten Zugriffszeit.

psql-Client

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

In der Ansicht g_columnar_stat_statements können Sie die Ausführungsstatistiken der spaltenbasierten Engine für aktuelle Abfragen aufrufen. Diese Ansicht bietet spaltenspezifische Statistiken für die spaltenorientierte Engine und erfordert die Aktivierung der Erweiterung pg_stat_statements.

psql-Client

So rufen Sie diese Statistiken auf:

1. Aktivieren Sie die Erweiterung pg_stat_statements:

   CREATE EXTENSION pg_stat_statements;
   

2. Führen Sie die Abfragen aus, für die Sie Statistiken sehen möchten. Sie können dies manuell tun oder Ihre Anwendungen eine Zeit lang ausführen, um Daten zu generieren.
3. Fragen Sie die Ansicht g_columnar_stat_statements ab, um die erfassten Statistiken aufzurufen.

   SELECT * FROM g_columnar_stat_statements WHERE page_read > 0;
   

   Die Ausgabe sieht etwa so aus:

   -[ 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
   

Arbeitsspeichernutzung des Spaltenspeichers ansehen

Wenn Sie wissen möchten, wie viel ungenutzter RAM für die spaltenbasierte Engine verfügbar ist, können Sie die Funktion google_columnar_engine_memory_available() abfragen. Die resultierende Ganzzahl zeigt den verfügbaren Arbeitsspeicher in Megabyte (MB) an.

SELECT google_columnar_engine_memory_available();

Informationen zu Indexen im Spaltenspeicher ansehen

Sie können Informationen zum Status, zur Größe und zu verschiedenen leistungsbezogenen Messwerten von spaltenbasierten Indexen abrufen, indem Sie die Ansicht g_columnar_indexes abfragen.

psql-Client

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;

In der folgenden Tabelle werden die Felder der Ansicht g_columnar_indexes beschrieben.

Feld	Datentyp	Beschreibung
database_name	NAME	Name der Datenbank, in der sich der Index befindet
schema_name	NAME	Name des Schemas, zu dem der Index gehört
index_name	NAME	Name des Index
status	NAME	Status des Index in der spaltenbasierten Engine
size	BIGINT	Größe des Index in der spaltenbasierten Engine
total_partition_count	BIGINT	Gesamtzahl der Partitionen des Index in der spaltenbasierten Engine
non_leaf_partition_count	BIGINT	Gesamtzahl der Nicht-Blattpartitionen des Index in der spaltenorientierten Engine
leaf_partition_count	BIGINT	Gesamtzahl der Blattpartitionen des Index in der spaltenbasierten Engine
invalid_block_count	BIGINT	Gesamtzahl der ungültigen Blöcke in der spaltenbasierten Engine für den Index
block_count_in_cc	BIGINT	Gesamtzahl der Blöcke des Index in der spaltenbasierten Engine
total_block_count	BIGINT	Gesamtzahl der Blöcke des Index
creation_time	BIGINT	Zeitpunkt der Indexerstellung in der spaltenbasierten Engine
auto_refresh_trigger_count	BIGINT	Gesamtzahl der automatischen Aktualisierungen, die seit dem Start von PostgreSQL ausgelöst wurden
auto_refresh_failure_count	BIGINT	Gesamtzahl der Fehler bei der automatischen Aktualisierung seit dem Start von PostgreSQL
auto_refresh_trigger_timestamp	BIGINT	Zeitstempel der letzten ausgelösten automatischen Aktualisierung
auto_refresh_start_timestamp	BIGINT	Zeitstempel der letzten automatischen Aktualisierung, die gestartet wurde
auto_refresh_end_timestamp	BIGINT	Zeitstempel der letzten abgeschlossenen automatischen Aktualisierung
auto_refresh_recent_status	TEXT	Status der letzten automatischen Aktualisierung