Surveiller le moteur de données en colonnes

Cette page explique comment surveiller l'utilisation du moteur de données en colonnes.

Vérifier l'utilisation du moteur de données en colonnes à l'aide de EXPLAIN

Vous pouvez vérifier l'utilisation du moteur de données en colonnes à l'aide de l'instruction EXPLAIN pour observer les nouveaux opérateurs en colonnes qui apparaissent dans le plan de requête généré pour une requête.

Client 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) indique que l'analyse du moteur de données en colonnes est incluse dans le plan de requête.
• La valeur Rows Removed by Columnar Filter indique le nombre de lignes filtrées en fonction de l'exécution vectorisée en colonnes.
• Il peut s'agir de Columnar cache search mode, columnar filter only, native ou row store scan. Le planificateur choisit automatiquement le mode de recherche en fonction de la capacité d'évaluation des coûts et du pushdown.

Lorsque le planificateur choisit le mode native, il transfère certains des opérateurs de colonnes à l'analyse :

• Rows Aggregated by Columnar Scan indique le nombre de lignes agrégées.
• Rows Sorted by Columnar Scan indique le nombre de lignes triées.
• Rows Limited by Columnar Scan : liste le nombre limité de lignes analysées.

Avec les jointures, les opérateurs d'analyse de colonnes peuvent également utiliser le mode Late Materialization.

Client 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 peut être défini sur late materialization. Les opérateurs de colonnes choisissent automatiquement ce mode lorsque le planificateur optimise la projection en différant la matérialisation de certaines valeurs de colonnes.

Afficher l'utilisation des jointures vectorisées du moteur de données en colonnes

Vous pouvez vérifier le nouvel opérateur de jointure vectorisée en utilisant l'instruction EXPLAIN pour observer le nouvel opérateur Vectorized Hash Join qui apparaît dans le plan de requête généré pour une requête.

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 indique que la jointure entre les deux relations a utilisé la jointure de hachage vectorisée.
• Vectorized partitioning, Partitions: indique le nombre de partitions dans lesquelles les données ont été réparties.

Utilisez l'option COLUMNAR_ENGINE pour EXPLAIN.

La commande EXPLAIN accepte l'option COLUMNAR_ENGINE. Lorsqu'elle est spécifiée, la commande affiche les messages Columnar Check dans le plan EXPLAIN pour montrer ce qui a pu amener le planificateur ou l'exécuteur à faire certains choix liés au moteur de colonnes pour le plan. La commande affiche également des informations supplémentaires spécifiques au moteur en colonnes. Le message est associé au nœud d'analyse non colonnaire. Il indique généralement la première cause qui empêche de choisir une analyse par colonne pour une analyse. Voici quelques exemples de causes : 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.

L'exemple de résultat suivant de la commande affiche un message Columnar Check :

Client 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

En fonction du message, l'utilisateur peut effectuer l'une des actions suivantes :

• Corrigez la cause spécifique, puis réexécutez la commande pour confirmer le plan en colonnes.
• Répétez le même processus. Il peut y avoir plusieurs causes, et la clause ne tente de lister que la première.

L'exemple suivant montre l'impression de détails supplémentaires spécifiques au moteur columnar :

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

Afficher des informations sur les tables avec des colonnes dans le store orienté colonnes

Vous pouvez afficher des informations sur les tables ou les vues matérialisées avec des colonnes dans le store orienté colonnes en interrogeant la vue g_columnar_relations.

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

Afficher des informations sur les colonnes du store orienté colonnes

Vous pouvez afficher des informations sur les colonnes du store orienté colonnes en interrogeant la vue g_columnar_columns. Cela concerne, entre autres, la taille de ces colonnes et la dernière heure d'accès.

Client psql

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

Afficher les statistiques d'exécution du moteur de données en colonnes pour les requêtes récentes

Vous pouvez afficher les statistiques d'exécution du moteur de données en colonnes pour les requêtes récentes à l'aide de la vue g_columnar_stat_statements. Cette vue ajoute des statistiques sur le moteur de données en colonnes à la vue pg_stat_statements fournie par l'extension pg_stat_statements. Pour utiliser cette vue, vous devez d'abord activer l'extension pg_stat_statements.

Client psql

1. Activez l'extension pg_stat_statements :

   CREATE EXTENSION pg_stat_statements;
   

2. Créez les requêtes dont vous souhaitez afficher les statistiques. Vous pouvez procéder manuellement ou laisser passer suffisamment de temps pour que vos applications exécutent ces requêtes avec pg_stat_statements activé.
3. Interrogez les vues g_columnar_stat_statements et pg_stat_statements. Notez que la requête suivante récupère toutes les statistiques d'exécution des colonnes, y compris celles qui ont été collectées avant la création de l'extension pg_stat_statements. La valeur nulle de userid indique que les statistiques ont été collectées avant la création de l'extension 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                             │
   └─────────────────────┴───────────────────────────────┘
   

Afficher l'utilisation de la mémoire du store orienté colonnes

Pour connaître la quantité de RAM inutilisée qui est disponible pour le moteur de données en colonnes, vous pouvez interroger la fonction google_columnar_engine_memory_available(). L'entier renvoyé en sortie indique la mémoire disponible en mégaoctets (Mo).

SELECT google_columnar_engine_memory_available();

Afficher des informations sur les index du store orienté colonnes

Vous pouvez afficher des informations sur l'état, la taille et diverses métriques de performances des index de colonnes en interrogeant la vue g_columnar_indexes.

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

Le tableau suivant décrit les champs de la vue g_columnar_indexes.

Champ	Type de données	Description
database_name	NOM
schema_name	NOM	Nom du schéma auquel appartient l'index
index_name	NOM	Nom de l'index
état	NOM	État de l'index dans le moteur de données en colonnes
taille	BIGINT	Taille de l'index dans le moteur de données en colonnes
total_partition_count	BIGINT	Nombre total de partitions d'index dans le moteur de données en colonnes
non_leaf_partition_count	BIGINT	Nombre total de partitions non feuilles de l'index dans le moteur de données en colonnes
leaf_partition_count	BIGINT	Nombre total de partitions feuilles de l'index dans le moteur de données en colonnes
invalid_block_count	BIGINT	Nombre total de blocs non valides dans le moteur de données en colonnes pour l'index
block_count_in_cc	BIGINT	Nombre total de blocs d'index dans le moteur en colonnes
total_block_count	BIGINT	Nombre total de blocs d'index
creation_time	BIGINT	Temps de création d'un index dans le moteur de données en colonnes
auto_refresh_trigger_count	BIGINT	Nombre total d'actualisations automatiques déclenchées depuis le démarrage de Postgres.
auto_refresh_failure_count	BIGINT	Nombre total d'échecs d'actualisation automatique depuis le démarrage de Postgres
auto_refresh_trigger_timestamp	BIGINT	Code temporel de la dernière actualisation automatique déclenchée
auto_refresh_start_timestamp	BIGINT	Code temporel de la dernière actualisation automatique lancée
auto_refresh_end_timestamp	BIGINT	Code temporel de la dernière actualisation automatique effectuée.
auto_refresh_recent_status	TEXTE	État de la dernière actualisation automatique