Spaltenbasierte Engine überwachen

Auf dieser Seite wird beschrieben, wie Sie die Auslastung der spaltenorientierten Engine überwachen.

Verwendung der spaltenorientierten Engine mit EXPLAIN prüfen

Sie können die Verwendung der spaltenorientierten Engine mithilfe der Anweisung EXPLAIN prüfen, um die neuen spaltenorientierten Operatoren zu sehen, die im generierten Abfrageplan einer Abfrage erscheinen.

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 ein Scan mit der spaltenorientierten Engine in den Abfrageplan aufgenommen wird.
  • In Rows Removed by Columnar Filter wird die Anzahl der Zeilen aufgeführt, die durch die spaltenorientierte vektorielle Ausführung herausgefiltert wurden.
  • Columnar cache search mode kann columnar filter only, native oder row store scan sein. Der Suchmodus wird vom Planner automatisch basierend auf den Kosten und der Pushdown-Bewertung ausgewählt.

Wenn der Planer den Modus native auswählt, werden einige der spaltenbasierten Operatoren an den Scan übergeben:

  • Rows Aggregated by Columnar Scan enthält die Anzahl der Zeilen, die zusammengefasst werden.
  • 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 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. Spaltenoperatoren wählen diesen Modus automatisch aus, wenn der Planer die Projektion optimiert, indem die Materialisierung einiger Spaltenwerte verschoben wird.

Option COLUMNAR_ENGINE für EXPLAIN verwenden

Der Befehl EXPLAIN unterstützt die Option COLUMNAR_ENGINE. Wenn Sie diese Option angeben, werden im EXPLAIN-Plan Columnar Check-Nachrichten ausgegeben, die Aufschluss darüber geben, warum der Planer oder Executor bestimmte entscheidungen für die spaltenorientierte Engine getroffen hat. Außerdem werden zusätzliche Details ausgegeben, die für die spaltenorientierte Engine spezifisch sind. Die Meldung ist mit dem nicht spaltenbasierten Scanknoten verknüpft. Sie gibt in der Regel die erste Ursache an, die verhindert, dass ein spaltenbasierter Scan für einen Scan ausgewählt wird. Beispiele für mögliche 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.

In der folgenden Beispielausgabe des Befehls wird eine Columnar Check-Nachricht ausgegeben:

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 Meldung kann der Nutzer eine der folgenden Aktionen ausführen:

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

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 aufrufen

Wenn Sie Informationen zu den Tabellen oder den materialisierten Ansichten mit Spalten im Tabellenspeicher aufrufen möchten, können Sie die Ansicht g_columnar_relations abfragen.

psql-Client

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 aufrufen

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 Zeit des letzten Zugriffs.

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 letzte Abfragen aufrufen

In der Ansicht g_columnar_stat_statements finden Sie Statistiken zur Ausführung der spaltenorientierten Engine für die letzten Abfragen. In dieser Ansicht werden der pg_stat_statements-Ansicht, die von der pg_stat_statements-Erweiterung bereitgestellt wird, spaltenbasierte Engine-Statistiken hinzugefügt. Wenn Sie diese Ansicht verwenden möchten, müssen Sie zuerst die pg_stat_statements-Erweiterung aktivieren.

psql-Client

  1. Aktivieren Sie die pg_stat_statements-Erweiterung: 
    CREATE EXTENSION pg_stat_statements;
  2. Stellen Sie die Abfragen, deren Statistiken Sie sich ansehen möchten. Sie können dies manuell tun oder warten, bis Ihre Anwendungen diese Abfragen mit aktivierter pg_stat_statements stellen.
  3. Fragen Sie die Ansichten g_columnar_stat_statements und pg_stat_statements ab. Hinweis: Mit der folgenden Abfrage werden alle Ausführungsstatistiken für Spalten abgerufen, einschließlich derer, die vor der Erstellung der Erweiterung pg_stat_statements erfasst wurden. Der Nullwert userid gibt an, dass die Statistiken erfasst wurden, bevor die Erweiterung pg_stat_statements erstellt wurde. 
    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 der Spalte ansehen

Um die Menge des nicht verwendeten RAM zu sehen, der für das Säulenmodul verfügbar ist, können Sie die Funktion google_columnar_engine_memory_available() abfragen. Die resultierende Ganzzahl gibt den verfügbaren Arbeitsspeicher in Megabyte (MB) an.

SELECT google_columnar_engine_memory_available();