Monitorar o mecanismo colunar

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

Verificar o uso do mecanismo de colunas usando EXPLAIN

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

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á incluída no plano de consulta.
  • Rows Removed by Columnar Filter lista o número de linhas filtradas pela execução vetorial 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 de coluna para a verificação:

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

Com as mesclagens, os operadores de verificação de colunas também podem usar o modo Late Materialization.

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 de colunas escolhem esse modo automaticamente quando o planejador otimiza a projeção adiando a materialização de alguns valores de coluna.

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

É possível consultar informações sobre as tabelas ou as visualizações materializadas com colunas no repositório de colunas consultando a visualização g_columnar_relations.

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

Conferir informações sobre as colunas no repositório de colunas

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

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 adiciona estatísticas do mecanismo colunar à visualização pg_stat_statements fornecida pela extensão pg_stat_statements. Para usar essa visualização, primeiro ative a extensão pg_stat_statements.

  1. Ative a extensão pg_stat_statements:
    CREATE EXTENSION pg_stat_statements;
    
  2. Execute as consultas com as estatísticas que você quer conferir. Você pode fazer isso manualmente ou deixar passar tempo suficiente para que seus aplicativos executem essas consultas com pg_stat_statements ativado.
  3. Consulte as visualizações g_columnar_stat_statements e pg_stat_statements. A consulta a seguir recupera todas as estatísticas de execução de colunas, incluindo aquelas coletadas antes da criação da extensão pg_stat_statements. O valor 10 userid indica que as estatísticas foram coletadas antes da criação da extensão pg_stat_statements.
    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                             │
    └─────────────────────┴───────────────────────────────┘
    

Conferir o uso da memória do armazenamento de colunas

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

SELECT google_columnar_engine_memory_available();

Conferir o cache de armazenamento do mecanismo colunar

Para conferir e monitorar dados sobre o cache de armazenamento do mecanismo de colunas, chame as seguintes funções:

Função Descrição
google_columnar_engine_storage_cache_used Retorna o tamanho do cache de armazenamento do mecanismo colunar usado.
google_columnar_engine_storage_cache_available Retorna o tamanho do cache de armazenamento do mecanismo colunar não usado.
google_columnar_engine_storage_cache_total Retorna a quantidade total do tamanho configurado do armazenamento em cache para o mecanismo colunar.

Confira a seguir como consultar uma função SQL usada para conferir e monitorar dados sobre o cache de armazenamento do mecanismo de colunas:

SELECT SQL_FUNCTION;

Substitua SQL_FUNCTION pelo nome da função de cache de armazenamento do mecanismo de colunas que você quer usar na tabela anterior.