Supervisa el motor de columnas

Selecciona una versión de la documentación:

En esta página, se describe cómo supervisar la utilización del motor columnar.

Verifica el uso del motor de columnas con EXPLAIN

Para observar los nuevos operadores columnares que aparecen en el plan de ejecución generado de una consulta, puedes verificar el uso del motor columnar con la instrucción EXPLAIN.

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 el análisis del motor columnar se incluye en el plan de consultas.
  • Rows Removed by Columnar Filter muestra la cantidad de filas que se filtraron con la ejecución vectorizada 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 la capacidad de evaluación de costos y de reducción.

Cuando el planificador elige el modo native, envía algunos de los operadores columnares al análisis:

  • Rows Aggregated by Columnar Scan enumera la cantidad de filas que se agregan.
  • Rows Sorted by Columnar Scan enumera la cantidad de filas que se ordenan.
  • Rows Limited by Columnar Scan enumera la cantidad limitada de filas que se analizaron.

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

Consulta el uso de la unión vectorizada del motor de columnas

Puedes verificar el nuevo operador de unión vectorizado con 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 unión entre las dos relaciones usó la unión hash vectorizada.
  • Vectorized partitioning, Partitions: enumera la cantidad de particiones en las que se dividieron los datos.

Consulta información sobre las tablas con columnas en el almacén de columnas

Puedes consultar la vista g_columnar_relations para ver información sobre las tablas o las vistas materializadas con columnas en el almacén de columnas.

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 en el almacén de columnas

Puedes consultar información sobre las columnas del almacén de columnas consultando la vista g_columnar_columns, incluidos el tamaño de esas columnas y la última hora de acceso.

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

Visualiza las estadísticas de ejecución del motor de columnas para las consultas recientes

Puedes ver las estadísticas de ejecución del motor columnar para las consultas recientes con la vista g_columnar_stat_statements. Esta vista agrega estadísticas del motor 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.

  1. Habilita la extensión pg_stat_statements: 
    CREATE EXTENSION pg_stat_statements;
  2. Ejecuta las consultas cuyas estadísticas deseas ver. Puedes hacerlo de forma manual o dejar que transcurra el tiempo suficiente para que tus aplicaciones ejecuten 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 recupera todas las estadísticas de ejecución columnar, incluidas las que se recopilaron antes de que se creara la extensión pg_stat_statements. El valor 10 de userid indica que las estadísticas se recopilaron 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                             │
└─────────────────────┴───────────────────────────────┘

Cómo ver el uso de memoria del almacén de columnas

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

SELECT google_columnar_engine_memory_available();

Cómo ver la caché de almacenamiento del motor de columnas

Para ver y supervisar los datos sobre la caché de almacenamiento del motor columnar, puedes usar los siguientes comandos:

Comando Descripción
SELECT google_columnar_engine_storage_cache_used(); Devuelve el tamaño de la caché de almacenamiento del motor de columnas que se usa.
SELECT google_columnar_engine_storage_cache_available(); Devuelve el tamaño de la caché de almacenamiento del motor de columnas sin usar.
SHOW google_columnar_engine.storage_cache_size; Devuelve la cantidad total del tamaño configurado de la caché de almacenamiento para el motor de columnas.