Monitorar o mecanismo colunar

Esta página descreve como monitorar a utilização do mecanismo colunar.

Verificar o uso do mecanismo de colunas usando EXPLAIN

Para verificar o uso do mecanismo de colunas, use a instrução EXPLAIN e observe os novos operadores de colunas que aparecem no plano de consulta gerado de uma consulta.

Cliente 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) indica que a verificação do mecanismo colunar está sendo incluída no plano de consulta.
  • O Rows Removed by Columnar Filter lista o número de linhas filtradas pela execução em vetor de coluna.
  • Columnar cache search mode pode ser columnar filter only, native ou row store scan. O planejador escolhe o modo de pesquisa automaticamente com base no recurso de avaliação de custo e pushdown.

Quando o planejador escolhe o modo native, ele envia alguns dos operadores colunares para a leitura:

  • Rows Aggregated by Columnar Scan lista o número de linhas agregadas.
  • Rows Sorted by Columnar Scan lista o número de linhas classificadas.
  • Rows Limited by Columnar Scan lista o número limitado de linhas verificadas.

Com as junções, os operadores de verificação colunar também podem usar o modo Late Materialization.

Cliente 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 pode ser late materialization. Os operadores colunares escolhem esse modo automaticamente quando o planejador otimiza a projeção adiando a materialização de alguns valores de coluna.

Ver o uso da junção vetorizada do mecanismo colunar

Para verificar o novo operador de junção vetorizada, use a instrução EXPLAIN e observe o novo operador Vectorized Hash Join que aparece no plano de consulta gerado.

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 indica que a junção entre as duas relações usou a junção de hash vetorizada.
  • Vectorized partitioning, Partitions: lista o número de partições em que os dados foram divididos.

Use a opção COLUMNAR_ENGINE para EXPLAIN

O comando EXPLAIN aceita a opção COLUMNAR_ENGINE. Quando especificado, o comando imprime mensagens Columnar Check no plano EXPLAIN para mostrar o que pode ter levado o planejador ou executor a fazer determinadas escolhas relacionadas ao mecanismo colunar para o plano. O comando também imprime outros detalhes específicos do mecanismo colunar. A mensagem está associada ao nó de verificação não colunar. Normalmente, ele indica a primeira causa que impede que uma verificação colunar seja escolhida para uma verificação. Alguns exemplos são the table is too small, a needed column of the table is not in the CE store ou a needed column has a CE unsupported data type.

O exemplo de saída do comando a seguir mostra uma mensagem Columnar Check:

Cliente 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

Com base na mensagem, o usuário pode fazer o seguinte:

  • Resolva a causa específica e execute o comando novamente para confirmar o plano colunar.
  • Itere o mesmo processo. Pode haver mais de uma causa, e a cláusula tenta listar apenas a primeira.

O exemplo a seguir mostra mais detalhes impressos que são específicos do mecanismo colunar:

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

Ver informações sobre tabelas com colunas no repositório de colunas

Para ver informações sobre as tabelas ou as visualizações materializadas com colunas no columnstore, consulte a visualização g_columnar_relations.

Cliente 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

Ver informações sobre as colunas no columnstore

Para ver informações sobre as colunas no columnstore, consulte a visualização g_columnar_columns, incluindo o tamanho das colunas e o último horário de acesso.

Cliente psql

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

Conferir estatísticas de execução do mecanismo colunar para consultas recentes

É possível conferir as estatísticas de execução do mecanismo de colunas para consultas recentes usando a visualização g_columnar_stat_statements. Essa visualização fornece estatísticas colunares específicas do mecanismo e exige que a extensão pg_stat_statements esteja ativada.

Cliente psql

Para conferir essas estatísticas, siga estas etapas:

  1. Ative a extensão pg_stat_statements: 
    CREATE EXTENSION pg_stat_statements;
  2. Execute as consultas para as quais você quer ver estatísticas. É possível fazer isso manualmente ou deixar os aplicativos serem executados por um tempo para gerar dados.
  3. Consulte a visualização g_columnar_stat_statements para conferir as estatísticas coletadas. 
    SELECT * FROM g_columnar_stat_statements WHERE page_read > 0;

    O resultado será o seguinte:

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

Ver o uso da memória do columnstore

Para conferir a quantidade de RAM não utilizada disponível para o mecanismo de colunas, consulte a função google_columnar_engine_memory_available(). O número inteiro resultante mostra a memória disponível em megabytes (MB).

SELECT google_columnar_engine_memory_available();

Ver informações sobre índices no column store

Para conferir informações sobre o status, o tamanho e várias métricas relacionadas à performance dos índices de colunas, consulte a visualização g_columnar_indexes.

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

A tabela a seguir descreve os campos da visualização g_columnar_indexes.

Campo Tipo de dado Descrição
database_name NOME
schema_name NOME Nome do esquema a que o índice pertence
index_name NOME Nome do índice
status NOME Status do índice no mecanismo colunar
tamanho BIGINT Tamanho do índice no mecanismo colunar
total_partition_count BIGINT Número total de partições do índice no mecanismo colunar
non_leaf_partition_count BIGINT Número total de partições não folha do índice no mecanismo colunar
leaf_partition_count BIGINT Número total de partições de folha do índice no mecanismo colunar
invalid_block_count BIGINT Número total de blocos inválidos no mecanismo colunar para o índice
block_count_in_cc BIGINT Número total de blocos do índice no mecanismo colunar
total_block_count BIGINT Número total de blocos do índice
creation_time BIGINT Tempo de criação do índice no mecanismo colunar
auto_refresh_trigger_count BIGINT Número total de atualizações automáticas acionadas desde a inicialização do postgres.
auto_refresh_failure_count BIGINT Número total de falhas de atualização automática desde a inicialização do postgres
auto_refresh_trigger_timestamp BIGINT Carimbo de data/hora da atualização automática mais recente que foi acionada
auto_refresh_start_timestamp BIGINT Carimbo de data/hora da atualização automática mais recente que foi iniciada
auto_refresh_end_timestamp BIGINT Carimbo de data/hora da atualização automática mais recente que foi concluída.
auto_refresh_recent_status TEXT Status da atualização automática mais recente