Monitorizar el motor en columnas

En esta página se describe cómo monitorizar el uso del motor de columnas.

Verificar el uso del motor de columnas con EXPLAIN

Para verificar el uso del motor columnar, puedes usar la instrucción EXPLAIN para observar los nuevos operadores columnares que aparecen en el plan de consulta generado de una 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 se incluye en el plan de consulta el análisis de columnar-engine.
  • Rows Removed by Columnar Filter indica el número de filas filtradas por la ejecución vectorial columnar.
  • Columnar cache search mode puede ser columnar filter only, native o row store scan. El planificador elige el modo de búsqueda automáticamente en función de los costes y de la capacidad de evaluación de pushdown.

Cuando el planificador elige el modo native, inserta algunos de los operadores de columna en el análisis:

  • Rows Aggregated by Columnar Scan indica el número de filas que se agregan.
  • Rows Sorted by Columnar Scan indica el número de filas que se han ordenado.
  • Rows Limited by Columnar Scan muestra el número limitado de filas que se han analizado.

Con las combinaciones, los operadores de análisis columnar también pueden usar el 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 puede ser late materialization. Los operadores de columnas eligen este modo automáticamente cuando el planificador optimiza la proyección aplazando la materialización de algunos valores de columna.

Ver el uso de la combinación vectorizada del motor en columnas

Puede verificar el nuevo operador de unión vectorizado mediante la instrucción EXPLAIN para observar el nuevo operador Vectorized Hash Join que aparece en el plan de consulta generado de una consulta.

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 la combinación entre las dos relaciones ha usado la combinación de hash vectorizada.
  • Vectorized partitioning, Partitions: indica el número de particiones en las que se dividieron los datos.

Usa la opción COLUMNAR_ENGINE para EXPLAIN

El comando EXPLAIN admite la opción COLUMNAR_ENGINE. Cuando se especifica, el comando imprime mensajes Columnar Check en el plan EXPLAIN para mostrar qué podría haber llevado al planificador o al ejecutor a tomar determinadas decisiones relacionadas con el motor de columnas para el plan. El comando también muestra detalles adicionales específicos del motor columnar. El mensaje está asociado al nodo de análisis no columnar. Normalmente, indica la primera causa que impide que se elija un análisis columnar para un análisis. Algunos ejemplos son the table is too small, a needed column of the table is not in the CE store o a needed column has a CE unsupported data type.

En el siguiente ejemplo de salida del comando se imprime un mensaje 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

Según el mensaje, el usuario puede hacer lo siguiente:

  • Soluciona el problema específico y vuelve a ejecutar el comando para confirmar el plan columnar.
  • Itera sobre el mismo proceso. Puede haber más de una causa y la cláusula solo intenta enumerar la primera.

En el siguiente ejemplo se muestran detalles adicionales que se imprimen y que son específicos del motor columnar:

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 información sobre las tablas con columnas en el almacén de columnas

Para ver información sobre las tablas o las vistas materializadas con columnas en el almacén de columnas, consulta la vista g_columnar_relations.

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

Ver información sobre las columnas del almacén de columnas

Para ver información sobre las columnas del almacén de columnas, consulta la vista g_columnar_columns, que incluye el tamaño de las columnas y la hora del último acceso.

Cliente psql

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

Ver estadísticas de ejecución del motor en columnas de consultas recientes

Puede consultar estadísticas de ejecución del buscador en formato de columna de las consultas recientes mediante la vista g_columnar_stat_statements. Esta vista añade estadísticas del buscador en forma de columnas a la vista pg_stat_statements que proporciona la extensión pg_stat_statements. Para usar esta vista, primero debes habilitar la extensión pg_stat_statements.

Cliente psql

  1. Habilita la extensión pg_stat_statements: 
    CREATE EXTENSION pg_stat_statements;
  2. Haz las consultas de las que quieras ver las estadísticas. Puedes hacerlo manualmente o esperar un tiempo suficiente para que tus aplicaciones hagan estas consultas con pg_stat_statements habilitado.
  3. Consulta las vistas g_columnar_stat_statements y pg_stat_statements. Ten en cuenta que la siguiente consulta obtiene todas las estadísticas de ejecución de columnas, incluidas las que se recogieron antes de que se creara la extensión pg_stat_statements. El valor nulo de userid indica que las estadísticas se recogieron antes de que se creara la extensión 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                             │
└─────────────────────┴───────────────────────────────┘

Ver el uso de memoria de Column Store

Para ver la cantidad de RAM sin usar que está disponible para el motor de columnas, puedes consultar la función google_columnar_engine_memory_available(). El número entero resultante muestra la memoria disponible en megabytes (MB).

SELECT google_columnar_engine_memory_available();