Memantau columnar engine

Memantau columnar engine membantu Anda mengonfirmasi bahwa kueri menggunakan penyimpanan kolom dan memutuskan apakah akan mengubah konten atau ukuran memorinya. Anda dapat memeriksa rencana kueri menggunakan pernyataan EXPLAIN, dan melihat tabel, kolom, dan indeks penyimpanan kolom, serta statistik eksekusi dan penggunaan memori. Untuk mengubah setelan columnar engine, lihat Tune the columnar engine.

Memverifikasi penggunaan columnar engine menggunakan EXPLAIN

Anda dapat memverifikasi penggunaan columnar engine dengan menggunakan pernyataan EXPLAIN untuk mengamati operator berbasis kolom baru yang muncul dalam rencana kueri yang dihasilkan kueri.

Klien 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) menunjukkan bahwa pemindaian columnar-engine disertakan dalam rencana kueri.
• Rows Removed by Columnar Filter mencantumkan jumlah baris yang difilter oleh eksekusi vektorisasi berbentuk kolom.
• Columnar cache search mode dapat berupa columnar filter only, native, atau row store scan. Perencana memilih mode penelusuran secara otomatis berdasarkan biaya dan kemampuan evaluasi pushdown.

Saat memilih mode native, perencana akan mendorong beberapa operator kolom ke pemindaian:

• Rows Aggregated by Columnar Scan mencantumkan jumlah baris yang digabungkan.
• Rows Sorted by Columnar Scan mencantumkan jumlah baris yang diurutkan.
• Rows Limited by Columnar Scan mencantumkan jumlah terbatas baris yang dipindai.

Dengan join, operator pemindaian berbasis kolom juga dapat menggunakan mode Late Materialization.

Klien 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 dapat berupa late materialization. Operator berbentuk kolom memilih mode ini secara otomatis saat perencana mengoptimalkan proyeksi dengan menunda materialisasi beberapa nilai kolom.

Melihat penggunaan operasi gabung dengan vektor columnar engine

Anda dapat memverifikasi operator gabung dengan vektor yang baru menggunakan pernyataan EXPLAIN untuk mengamati operator Vectorized Hash Join baru yang muncul dalam rencana kueri yang dihasilkan kueri.

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 menunjukkan bahwa penggabungan antara dua relasi menggunakan penggabungan hash vektor.
• Vectorized partitioning, Partitions: mencantumkan jumlah partisi yang digunakan untuk membagi data.

Gunakan opsi COLUMNAR_ENGINE untuk EXPLAIN

Perintah EXPLAIN mendukung opsi COLUMNAR_ENGINE. Jika ditentukan, perintah akan mencetak pesan Columnar Check dalam rencana EXPLAIN untuk menunjukkan hal yang mungkin menyebabkan perencana atau eksekutor membuat pilihan tertentu terkait columnar engine untuk rencana tersebut. Perintah ini juga mencetak detail tambahan yang khusus untuk columnar engine. Pesan ini terkait dengan node pemindaian non-kolom. Biasanya, hal ini menunjukkan penyebab pertama yang mencegah pemindaian berbasis kolom dipilih untuk pemindaian. Beberapa contoh penyebabnya adalah the table is too small, a needed column of the table is not in the CE store, atau a needed column has a CE unsupported data type.

Contoh output perintah berikut mencetak pesan Columnar Check:

Klien 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

Berdasarkan pesan, pengguna dapat melakukan salah satu tindakan berikut:

• Atasi penyebab spesifiknya, lalu jalankan kembali perintah untuk mengonfirmasi rencana berbentuk kolom.
• Ulangi proses yang sama. Mungkin ada lebih dari satu penyebab, dan klausa hanya mencoba mencantumkan penyebab pertama.

Contoh berikut menunjukkan detail tambahan yang dicetak dan khusus untuk columnar engine:

Klien 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)

Melihat informasi tentang tabel dengan kolom di penyimpanan kolom

Anda dapat melihat informasi tentang tabel atau tampilan terwujud dengan kolom di penyimpanan kolom dengan membuat kueri tampilan g_columnar_relations.

Klien 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

Melihat informasi tentang kolom di penyimpanan kolom

Anda dapat melihat informasi tentang kolom di penyimpanan kolom dengan mengkueri tampilan g_columnar_columns, termasuk ukuran kolom tersebut dan waktu akses terakhir.

Klien psql

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

Melihat statistik eksekusi columnar engine untuk kueri terbaru

Anda dapat melihat statistik eksekusi columnar engine untuk kueri terbaru menggunakan tampilan g_columnar_stat_statements. Tampilan ini menyediakan statistik khusus columnar engine dan memerlukan pengaktifan ekstensi pg_stat_statements.

Klien psql

Untuk melihat statistik ini, ikuti langkah-langkah berikut:

1. Aktifkan ekstensi pg_stat_statements:

   CREATE EXTENSION pg_stat_statements;
   

2. Jalankan kueri yang statistiknya ingin Anda lihat. Anda dapat melakukannya secara manual, atau membiarkan aplikasi berjalan selama beberapa waktu untuk menghasilkan data.
3. Buat kueri tabel virtual g_columnar_stat_statements untuk melihat statistik yang dikumpulkan.

   SELECT * FROM g_columnar_stat_statements WHERE page_read > 0;
   

   Outputnya mirip dengan hal berikut ini:

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

Melihat penggunaan memori penyimpanan kolom

Untuk melihat jumlah RAM yang tidak digunakan yang tersedia untuk columnar engine, Anda dapat membuat kueri fungsi google_columnar_engine_memory_available(). Bilangan bulat yang dihasilkan menunjukkan memori yang tersedia dalam megabyte (MB).

SELECT google_columnar_engine_memory_available();

Melihat informasi tentang indeks di penyimpanan kolom

Anda dapat melihat informasi tentang status, ukuran, dan berbagai metrik terkait performa indeks berbasis kolom dengan mengkueri tampilan g_columnar_indexes.

Klien 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;

Tabel berikut menjelaskan kolom tabel virtual g_columnar_indexes.

Kolom	Jenis data	Deskripsi
database_name	NAME	Nama database tempat indeks berada
schema_name	NAME	Nama skema tempat indeks berada
index_name	NAME	Nama indeks
status	NAME	Status indeks di columnar engine
size	BIGINT	Ukuran indeks di columnar engine
total_partition_count	BIGINT	Jumlah total partisi indeks di columnar engine
non_leaf_partition_count	BIGINT	Jumlah total partisi non-leaf indeks di columnar engine
leaf_partition_count	BIGINT	Jumlah total partisi leaf indeks di columnar engine
invalid_block_count	BIGINT	Jumlah total blok yang tidak valid di columnar engine untuk indeks
block_count_in_cc	BIGINT	Jumlah total blok indeks di columnar engine
total_block_count	BIGINT	Jumlah total blok indeks
creation_time	BIGINT	Waktu pembuatan indeks di columnar engine
auto_refresh_trigger_count	BIGINT	Jumlah total pemuatan ulang otomatis yang dipicu sejak startup PostgreSQL
auto_refresh_failure_count	BIGINT	Jumlah total kegagalan refresh otomatis sejak startup PostgreSQL
auto_refresh_trigger_timestamp	BIGINT	Stempel waktu pemuatan ulang otomatis terbaru yang dipicu
auto_refresh_start_timestamp	BIGINT	Stempel waktu pemuatan ulang otomatis terbaru yang dimulai
auto_refresh_end_timestamp	BIGINT	Stempel waktu pemuatan ulang otomatis terbaru yang telah selesai
auto_refresh_recent_status	TEXT	Status pemuatan ulang otomatis terbaru