Memantau mesin kolom

Halaman ini menjelaskan cara memantau pemanfaatan mesin berbasis kolom.

Memverifikasi penggunaan mesin berbasis kolom menggunakan EXPLAIN

Anda dapat memverifikasi penggunaan mesin columnar dengan menggunakan pernyataan EXPLAIN untuk mengamati operator columnar 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 kolom.
  • Columnar cache search mode dapat berupa columnar filter only, native, atau row store scan. Perencana memilih mode penelusuran secara otomatis berdasarkan kemampuan evaluasi biaya dan penurunan.

Saat perencana 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 baris terbatas yang dipindai.

Dengan gabungan, operator pemindaian 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 kolom memilih mode ini secara otomatis saat perencana mengoptimalkan proyeksi dengan menunda materialisasi beberapa nilai kolom.

Melihat penggunaan gabungan tervektorisasi mesin berbasis kolom

Anda dapat memverifikasi operator gabungan tervektorisasi 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 gabungan antara dua relasi menggunakan hash join tervektor.
  • Vectorized partitioning, Partitions: mencantumkan jumlah partisi tempat data dibagi.

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 apa yang mungkin menyebabkan perencana atau pelaksana membuat pilihan terkait mesin kolom tertentu untuk rencana tersebut. Perintah ini juga mencetak detail tambahan yang khusus untuk mesin columnar. Pesan ini terkait dengan node pemindaian non-kolom. Biasanya menunjukkan penyebab pertama yang mencegah pemindaian 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 tersebut, pengguna dapat melakukan salah satu hal berikut:

  • Atasi penyebab spesifiknya, lalu jalankan kembali perintah untuk mengonfirmasi rencana 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 khusus untuk mesin columnar:

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 column store dengan membuat kueri tampilan g_columnar_relations.

Klien psql

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

Melihat informasi tentang kolom di penyimpanan kolom

Anda dapat melihat informasi tentang kolom di penyimpanan kolom dengan membuat kueri 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 mesin columnar untuk kueri terbaru

Anda dapat melihat statistik eksekusi mesin columnar untuk kueri terbaru menggunakan tampilan g_columnar_stat_statements. Tampilan ini menambahkan statistik mesin columnar ke tampilan pg_stat_statements yang disediakan oleh ekstensi pg_stat_statements. Untuk menggunakan tampilan ini, Anda harus mengaktifkan ekstensi pg_stat_statements terlebih dahulu.

Klien psql

  1. Aktifkan ekstensi pg_stat_statements: 
    CREATE EXTENSION pg_stat_statements;
  2. Buat kueri yang statistiknya ingin Anda lihat. Anda dapat melakukannya secara manual, atau membiarkan waktu yang cukup berlalu sehingga aplikasi Anda membuat kueri ini dengan pg_stat_statements diaktifkan.
  3. Buat kueri tampilan g_columnar_stat_statements dan pg_stat_statements. Perhatikan bahwa kueri berikut mengambil semua statistik eksekusi kolom, termasuk yang dikumpulkan sebelum ekstensi pg_stat_statements dibuat. Nilai null userid menunjukkan bahwa statistik dikumpulkan sebelum ekstensi pg_stat_statements dibuat. 
    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                             │
└─────────────────────┴───────────────────────────────┘

Melihat penggunaan memori penyimpanan kolom

Untuk melihat jumlah RAM yang tidak digunakan dan tersedia untuk mesin berbasis kolom, 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 kolom dengan membuat kueri 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 tampilan g_columnar_indexes.

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