From 9ab870314726014344b06cbf48a898d501aa5e4c Mon Sep 17 00:00:00 2001 From: Bertrand Drouvot Date: Wed, 28 Oct 2026 06:49:22 +0000 Subject: [PATCH v3 7/8] Report buffer access strategies for table scans in EXPLAIN When ANALYZE and BUFFERS are enabled, report every buffer access strategy selected by sequential, sample, bitmap heap, TID, and TID range scans. Read the strategies from leader and per-worker table scan instrumentation and report them only for processes that execute the scan. If rescans select different strategies, include each one in the reported list. Add documentation and TAP coverage for serial and parallel execution, rescans, never-executed scans, and omission when BUFFERS is disabled. Author: Bertrand Drouvot Reviewed-by: Sami Imseih Discussion: https://postgr.es/m/auCYYbDyrQEwIsQq@bdtpg --- doc/src/sgml/ref/explain.sgml | 12 + src/backend/commands/explain.c | 128 ++++++++++ src/test/modules/test_misc/meson.build | 1 + .../t/016_explain_buffer_strategy.pl | 237 ++++++++++++++++++ src/test/regress/expected/explain.out | 234 +++++++++-------- src/test/regress/sql/explain.sql | 2 + 6 files changed, 503 insertions(+), 111 deletions(-) 3.5% doc/src/sgml/ref/ 15.8% src/backend/commands/ 34.9% src/test/modules/test_misc/t/ 44.8% src/test/regress/expected/ diff --git a/doc/src/sgml/ref/explain.sgml b/doc/src/sgml/ref/explain.sgml index f38d31e106a..3841f171bb3 100644 --- a/doc/src/sgml/ref/explain.sgml +++ b/doc/src/sgml/ref/explain.sgml @@ -200,6 +200,18 @@ ROLLBACK; number of blocks written indicates the number of previously-dirtied blocks evicted from cache by this backend during query processing. + When both ANALYZE and BUFFERS are + enabled, executed Seq Scan, + Sample Scan, Bitmap Heap Scan, + TID Scan, and TID Range Scan plan + nodes report the buffer access + strategies used by the table scan when the table access + method provides them. The reported list includes every strategy + selected while executing the scan, including across rescans. + Only strategies used by scan nodes are reported; write-side strategies + such as bulkwrite are not shown, even when a command + uses them internally. The number of blocks shown for an upper-level node includes those used by all its child nodes. In text format, only non-zero values are printed. Buffers information is diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c index d0ce72d83ff..735150c859e 100644 --- a/src/backend/commands/explain.c +++ b/src/backend/commands/explain.c @@ -140,6 +140,7 @@ static void show_hashagg_info(AggState *aggstate, ExplainState *es); static void show_indexscan_info(PlanState *planstate, ExplainState *es); static void show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es); +static void show_scan_buffer_access_strategies(ScanState *planstate, ExplainState *es); static void show_scan_io_usage(ScanState *planstate, ExplainState *es); static void show_instrumentation_count(const char *qlabel, int which, @@ -2010,6 +2011,7 @@ ExplainNode(PlanState *planstate, List *ancestors, show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); show_tidbitmap_info((BitmapHeapScanState *) planstate, es); + show_scan_buffer_access_strategies((ScanState *) planstate, es); show_scan_io_usage((ScanState *) planstate, es); break; case T_SampleScan: @@ -2029,6 +2031,7 @@ ExplainNode(PlanState *planstate, List *ancestors, planstate, es); if (IsA(plan, CteScan)) show_ctescan_info(castNode(CteScanState, planstate), es); + show_scan_buffer_access_strategies((ScanState *) planstate, es); show_scan_io_usage((ScanState *) planstate, es); break; case T_Gather: @@ -2129,6 +2132,7 @@ ExplainNode(PlanState *planstate, List *ancestors, if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); + show_scan_buffer_access_strategies((ScanState *) planstate, es); } break; case T_TidRangeScan: @@ -2146,6 +2150,7 @@ ExplainNode(PlanState *planstate, List *ancestors, if (plan->qual) show_instrumentation_count("Rows Removed by Filter", 1, planstate, es); + show_scan_buffer_access_strategies((ScanState *) planstate, es); show_scan_io_usage((ScanState *) planstate, es); } break; @@ -4027,6 +4032,49 @@ show_tidbitmap_info(BitmapHeapScanState *planstate, ExplainState *es) } } +/* + * Return the name of a buffer access strategy for EXPLAIN. + */ +static const char * +buffer_access_strategy_name(BufferAccessStrategyType strategy) +{ + switch (strategy) + { + case BAS_NORMAL: + return "normal"; + case BAS_BULKREAD: + return "bulkread"; + case BAS_BULKWRITE: + return "bulkwrite"; + case BAS_VACUUM: + return "vacuum"; + } + + elog(ERROR, "unrecognized buffer access strategy type: %d", strategy); + pg_unreachable(); +} + +/* + * Print all buffer access strategies observed while executing a scan. + */ +static void +print_buffer_access_strategies(ExplainState *es, uint32 strategy_mask) +{ + List *strategies = NIL; + + for (int strategy = BAS_NORMAL; strategy <= BAS_VACUUM; strategy++) + { + if (strategy_mask & BufferAccessStrategyBit(strategy)) + strategies = lappend(strategies, + unconstify(char *, + buffer_access_strategy_name(strategy))); + } + + Assert(strategies != NIL); + ExplainPropertyList("Buffer Access Strategies", strategies, es); + list_free(strategies); +} + /* * Print I/O stats - prefetching and I/O performed * @@ -4111,6 +4159,15 @@ get_table_scan_instrumentation(ScanState *planstate, int worker) SharedBitmapHeapInstrumentation *sinstrument = ((BitmapHeapScanState *) planstate)->sinstrument; + if (sinstrument && worker < sinstrument->num_workers) + return &sinstrument->sinstrument[worker].stats; + break; + } + case T_SampleScan: + { + SharedSampleScanInstrumentation *sinstrument = + ((SampleScanState *) planstate)->sinstrument; + if (sinstrument && worker < sinstrument->num_workers) return &sinstrument->sinstrument[worker].stats; break; @@ -4120,6 +4177,15 @@ get_table_scan_instrumentation(ScanState *planstate, int worker) SharedSeqScanInstrumentation *sinstrument = ((SeqScanState *) planstate)->sinstrument; + if (sinstrument && worker < sinstrument->num_workers) + return &sinstrument->sinstrument[worker].stats; + break; + } + case T_TidScan: + { + SharedTidScanInstrumentation *sinstrument = + ((TidScanState *) planstate)->tss_sinstrument; + if (sinstrument && worker < sinstrument->num_workers) return &sinstrument->sinstrument[worker].stats; break; @@ -4140,6 +4206,68 @@ get_table_scan_instrumentation(ScanState *planstate, int worker) return NULL; } +/* + * Show the buffer access strategy for a scan node. + */ +static void +show_scan_buffer_access_strategies(ScanState *planstate, ExplainState *es) +{ + WorkerNodeInstrumentation *worker_instrument = planstate->ps.worker_instrument; + TableScanInstrumentation *instrument; + double leader_nloops = planstate->ps.instrument ? + planstate->ps.instrument->nloops : 0; + + if (!es->buffers) + return; + + /* Report the buffer access strategy only for these scan types. */ + switch (nodeTag(planstate->ps.plan)) + { + case T_BitmapHeapScan: + case T_SampleScan: + case T_SeqScan: + case T_TidScan: + case T_TidRangeScan: + break; + default: + return; + } + + instrument = get_table_scan_instrumentation(planstate, -1); + + if (worker_instrument) + { + /* + * After parallel cleanup, the node's loop count includes worker + * loops. Remove them to determine whether the leader executed the + * scan. + */ + for (int i = 0; i < worker_instrument->num_workers; ++i) + { + double worker_nloops = worker_instrument->instrument[i].nloops; + TableScanInstrumentation *winstrument = + get_table_scan_instrumentation(planstate, i); + + leader_nloops -= worker_nloops; + + if (!winstrument || winstrument->strategy_mask == 0 || + worker_nloops <= 0) + continue; + + if (es->workers_state) + ExplainOpenWorker(i, es); + + print_buffer_access_strategies(es, winstrument->strategy_mask); + + if (es->workers_state) + ExplainCloseWorker(i, es); + } + } + + if (instrument && instrument->strategy_mask != 0 && leader_nloops > 0) + print_buffer_access_strategies(es, instrument->strategy_mask); +} + /* * Show information about prefetch and I/O in a scan node. */ diff --git a/src/test/modules/test_misc/meson.build b/src/test/modules/test_misc/meson.build index 5d81f5b13be..e71754ebbc3 100644 --- a/src/test/modules/test_misc/meson.build +++ b/src/test/modules/test_misc/meson.build @@ -24,6 +24,7 @@ tests += { 't/013_temp_obj_multisession.pl', 't/014_log_statement_max_length.pl', 't/015_temp_schema_exit_deferrable.pl', + 't/016_explain_buffer_strategy.pl', ], # The injection points are cluster-wide, so disable installcheck 'runningcheck': false, diff --git a/src/test/modules/test_misc/t/016_explain_buffer_strategy.pl b/src/test/modules/test_misc/t/016_explain_buffer_strategy.pl new file mode 100644 index 00000000000..3d8f3aa89d3 --- /dev/null +++ b/src/test/modules/test_misc/t/016_explain_buffer_strategy.pl @@ -0,0 +1,237 @@ +# Copyright (c) 2026, PostgreSQL Global Development Group + +# Test EXPLAIN reporting of buffer access strategies for table scans, +# including rescans, parallel execution, and cases where no strategy is shown. + +use strict; +use warnings FATAL => 'all'; + +use JSON::PP qw(decode_json); +use PostgreSQL::Test::Cluster; +use PostgreSQL::Test::Utils; +use Test::More; + +my $node = PostgreSQL::Test::Cluster->new('main'); +$node->init; +$node->append_conf( + 'postgresql.conf', qq{ +shared_buffers = '1MB' +max_parallel_workers_per_gather = 0 +}); +$node->start; + +$node->safe_psql( + 'postgres', qq{ +CREATE TABLE test_strategy AS + SELECT g, repeat('x', 1000) AS payload + FROM generate_series(1, 4000) AS g; +ALTER TABLE test_strategy SET (parallel_workers = 2); +CREATE INDEX test_strategy_g_idx ON test_strategy (g); +CREATE TABLE test_normal AS SELECT 1 AS g; +}); + +my $seqscan = explain_json('SELECT * FROM test_strategy'); +is($seqscan->{'Node Type'}, 'Seq Scan', 'sequential scan plan'); +check_strategy($seqscan, 'bulkread', 'sequential scan'); + +my $normal_scan = explain_json('SELECT * FROM test_normal'); +is($normal_scan->{'Node Type'}, 'Seq Scan', 'small sequential scan plan'); +check_strategy($normal_scan, 'normal', 'small sequential scan'); + +my $never_executed_plan = decode_json( + $node->safe_psql( + 'postgres', qq{ +SET plan_cache_mode = force_generic_plan; +PREPARE never_execute(bool) AS SELECT * FROM test_normal WHERE \$1; +EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) + EXECUTE never_execute(false); +}))->[0]->{'Plan'}; +my $never_executed_scan = find_plan_node($never_executed_plan, 'Seq Scan'); +ok(defined $never_executed_scan, + 'never-executed plan contains a sequential scan'); +is($never_executed_scan->{'Actual Loops'}, + 0, 'sequential scan was not executed'); +ok( !exists $never_executed_scan->{'Buffer Access Strategies'}, + 'strategy is not shown for a never-executed scan'); + +# Sample scans use the buffer access strategy without a read stream. +my $samplescan = + explain_json('SELECT * FROM test_strategy TABLESAMPLE SYSTEM (100)'); +is($samplescan->{'Node Type'}, 'Sample Scan', 'sample scan plan'); +check_strategy($samplescan, 'bulkread', 'sample scan'); + +my $rescan_plan = explain_json( + q{ +SELECT count(*) +FROM ( + SELECT p + FROM (VALUES (1, 100::real), (2, 0.5::real)) v(ord, p) + ORDER BY ord +) o +JOIN LATERAL ( + SELECT * + FROM test_strategy TABLESAMPLE SYSTEM (o.p) REPEATABLE (0) +) s ON true +}); +my $rescan = find_plan_node($rescan_plan, 'Sample Scan'); +ok(defined $rescan, 'parameterized sample scan plan'); +is($rescan->{'Actual Loops'}, 2, 'parameterized sample scan was rescanned'); +is_deeply( + $rescan->{'Buffer Access Strategies'}, + [ 'normal', 'bulkread' ], + 'parameterized sample scan reports every strategy used'); + +my $bitmap_plan = decode_json( + $node->safe_psql( + 'postgres', qq{ +SET enable_seqscan = off; +SET enable_indexscan = off; +EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) + SELECT * FROM test_strategy WHERE g BETWEEN 1 AND 1000; +}))->[0]->{'Plan'}; +my $bitmap_scan = find_plan_node($bitmap_plan, 'Bitmap Heap Scan'); +ok(defined $bitmap_scan, 'bitmap heap scan plan'); +check_strategy($bitmap_scan, 'normal', 'bitmap heap scan'); + +my $tid_plan = + explain_json("SELECT * FROM test_strategy WHERE ctid = '(0,1)'"); +my $tid_scan = find_plan_node($tid_plan, 'Tid Scan'); +ok(defined $tid_scan, 'TID scan plan'); +check_strategy($tid_scan, 'normal', 'TID scan'); + +my $tidrange_plan = + explain_json( + "SELECT * FROM test_strategy WHERE ctid >= '(0,1)' AND ctid < '(1,1)'"); +my $tidrange_scan = find_plan_node($tidrange_plan, 'Tid Range Scan'); +ok(defined $tidrange_scan, 'TID range scan plan'); +check_strategy($tidrange_scan, 'normal', 'TID range scan'); + +my $worker_samplescan_plan = decode_json( + $node->safe_psql( + 'postgres', qq{ +SET max_parallel_workers_per_gather = 1; +SET debug_parallel_query = on; +EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) + SELECT * FROM test_strategy TABLESAMPLE SYSTEM (100); +}))->[0]->{'Plan'}; +check_worker_strategy($worker_samplescan_plan, 'Sample Scan', 'bulkread', + 'worker-only sample scan'); + +my $worker_tid_plan = decode_json( + $node->safe_psql( + 'postgres', qq{ +SET max_parallel_workers_per_gather = 1; +SET debug_parallel_query = on; +EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) + SELECT * FROM test_strategy WHERE ctid = '(0,1)'; +}))->[0]->{'Plan'}; +check_worker_strategy($worker_tid_plan, 'Tid Scan', 'normal', + 'worker-only TID scan'); + +my $without_buffers = decode_json( + $node->safe_psql( + 'postgres', + 'EXPLAIN (ANALYZE, BUFFERS OFF, IO, FORMAT JSON) ' + . 'SELECT * FROM test_strategy'))->[0]->{'Plan'}; +ok( !exists $without_buffers->{'Buffer Access Strategies'}, + 'strategy is not shown when BUFFERS is disabled'); +ok( exists $without_buffers->{'Average Prefetch Distance'}, + 'read stream statistics are shown when only IO is enabled'); + +my $text = $node->safe_psql('postgres', + 'EXPLAIN (ANALYZE, BUFFERS, COSTS OFF, TIMING OFF, SUMMARY OFF) ' + . 'SELECT * FROM test_strategy'); +like( + $text, + qr/Buffer Access Strategies: bulkread/, + 'text output reports the strategy'); + +my $parallel_plan = decode_json( + $node->safe_psql( + 'postgres', qq{ +SET max_parallel_workers_per_gather = 2; +SET min_parallel_table_scan_size = 0; +SET parallel_setup_cost = 0; +SET parallel_tuple_cost = 0; +SET parallel_leader_participation = off; +EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) + SELECT count(*) FROM test_strategy; +}))->[0]->{'Plan'}; +my $gather = find_plan_node($parallel_plan, 'Gather'); +my $parallel_scan = find_plan_node($parallel_plan, 'Seq Scan'); + +ok(defined $gather, 'parallel plan contains a Gather'); +cmp_ok($gather->{'Workers Launched'}, '>', 0, 'parallel workers launched'); +ok(defined $parallel_scan, 'parallel plan contains a sequential scan'); +ok( !exists $parallel_scan->{'Buffer Access Strategies'}, + 'strategy is not shown for a non-participating leader'); +my $workers = $parallel_scan->{'Workers'}; +ok(ref $workers eq 'ARRAY' && @$workers > 0, + 'parallel scan reports worker strategy information'); + +foreach my $worker (@$workers) +{ + is_deeply($worker->{'Buffer Access Strategies'}, + ['bulkread'], 'parallel worker reports the strategy'); +} + +$node->stop; + +done_testing(); + +# Run EXPLAIN for the query and return its top-level plan. +sub explain_json +{ + my ($query) = @_; + my $output = $node->safe_psql('postgres', + "EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) $query"); + + return decode_json($output)->[0]->{'Plan'}; +} + +# Check that a plan reports only the expected buffer access strategy. +sub check_strategy +{ + my ($plan, $strategy, $description) = @_; + + is_deeply($plan->{'Buffer Access Strategies'}, + [$strategy], "$description uses the $strategy strategy"); +} + +# Check that a worker-only scan reports only the expected strategy. +sub check_worker_strategy +{ + my ($plan, $type, $strategy, $description) = @_; + my $scan = find_plan_node($plan, $type); + + ok(defined $scan, "$description plan contains a $type"); + ok( !exists $scan->{'Buffer Access Strategies'}, + "$description does not report a leader strategy"); + + my $workers = $scan->{'Workers'}; + + ok( ref $workers eq 'ARRAY' && @$workers > 0, + "$description reports worker strategy information"); + foreach my $worker (@$workers) + { + is_deeply($worker->{'Buffer Access Strategies'}, + [$strategy], "$description worker uses the $strategy strategy"); + } +} + +# Return the first plan node of the requested type, or undef if none exists. +sub find_plan_node +{ + my ($plan, $type) = @_; + + return $plan if $plan->{'Node Type'} eq $type; + + foreach my $child (@{ $plan->{'Plans'} // [] }) + { + my $result = find_plan_node($child, $type); + + return $result if defined $result; + } + + return; +} diff --git a/src/test/regress/expected/explain.out b/src/test/regress/expected/explain.out index 74a4d87801e..9efbc8b1a0b 100644 --- a/src/test/regress/expected/explain.out +++ b/src/test/regress/expected/explain.out @@ -89,9 +89,10 @@ select explain_filter('explain (analyze, buffers, format text) select * from int explain_filter ------------------------------------------------------------------------------------------------- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N) + Buffer Access Strategies: normal Planning Time: N.N ms Execution Time: N.N ms -(3 rows) +(4 rows) select explain_filter('explain (buffers, format text) select * from int8_tbl i8'); explain_filter @@ -119,6 +120,9 @@ explain_filter N.N N false + + normal + N.N N N @@ -173,6 +177,8 @@ explain_filter Actual Rows: N.N Actual Loops: N Disabled: false + Buffer Access Strategies: + - "normal" Average Prefetch Distance: N.N Max Prefetch Distance: N Prefetch Capacity: N @@ -301,65 +307,66 @@ select explain_filter('explain verbose select sum(unique1) over w1, sum(unique2) -- but always set in JSON format, so check them only in this case. set track_io_timing = on; select explain_filter('explain (analyze, buffers, format json) select * from int8_tbl i8'); - explain_filter -------------------------------------- - [ + - { + - "Plan": { + - "Node Type": "Seq Scan", + - "Parallel Aware": false, + - "Async Capable": false, + - "Relation Name": "int8_tbl", + - "Alias": "i8", + - "Startup Cost": N.N, + - "Total Cost": N.N, + - "Plan Rows": N, + - "Plan Width": N, + - "Actual Startup Time": N.N, + - "Actual Total Time": N.N, + - "Actual Rows": N.N, + - "Actual Loops": N, + - "Disabled": false, + - "Shared Hit Blocks": N, + - "Shared Read Blocks": N, + - "Shared Dirtied Blocks": N, + - "Shared Written Blocks": N, + - "Local Hit Blocks": N, + - "Local Read Blocks": N, + - "Local Dirtied Blocks": N, + - "Local Written Blocks": N, + - "Temp Read Blocks": N, + - "Temp Written Blocks": N, + - "Shared I/O Read Time": N.N, + - "Shared I/O Write Time": N.N,+ - "Local I/O Read Time": N.N, + - "Local I/O Write Time": N.N, + - "Temp I/O Read Time": N.N, + - "Temp I/O Write Time": N.N + - }, + - "Planning": { + - "Shared Hit Blocks": N, + - "Shared Read Blocks": N, + - "Shared Dirtied Blocks": N, + - "Shared Written Blocks": N, + - "Local Hit Blocks": N, + - "Local Read Blocks": N, + - "Local Dirtied Blocks": N, + - "Local Written Blocks": N, + - "Temp Read Blocks": N, + - "Temp Written Blocks": N, + - "Shared I/O Read Time": N.N, + - "Shared I/O Write Time": N.N,+ - "Local I/O Read Time": N.N, + - "Local I/O Write Time": N.N, + - "Temp I/O Read Time": N.N, + - "Temp I/O Write Time": N.N + - }, + - "Planning Time": N.N, + - "Triggers": [ + - ], + - "Execution Time": N.N + - } + + explain_filter +----------------------------------------------- + [ + + { + + "Plan": { + + "Node Type": "Seq Scan", + + "Parallel Aware": false, + + "Async Capable": false, + + "Relation Name": "int8_tbl", + + "Alias": "i8", + + "Startup Cost": N.N, + + "Total Cost": N.N, + + "Plan Rows": N, + + "Plan Width": N, + + "Actual Startup Time": N.N, + + "Actual Total Time": N.N, + + "Actual Rows": N.N, + + "Actual Loops": N, + + "Disabled": false, + + "Buffer Access Strategies": ["normal"],+ + "Shared Hit Blocks": N, + + "Shared Read Blocks": N, + + "Shared Dirtied Blocks": N, + + "Shared Written Blocks": N, + + "Local Hit Blocks": N, + + "Local Read Blocks": N, + + "Local Dirtied Blocks": N, + + "Local Written Blocks": N, + + "Temp Read Blocks": N, + + "Temp Written Blocks": N, + + "Shared I/O Read Time": N.N, + + "Shared I/O Write Time": N.N, + + "Local I/O Read Time": N.N, + + "Local I/O Write Time": N.N, + + "Temp I/O Read Time": N.N, + + "Temp I/O Write Time": N.N + + }, + + "Planning": { + + "Shared Hit Blocks": N, + + "Shared Read Blocks": N, + + "Shared Dirtied Blocks": N, + + "Shared Written Blocks": N, + + "Local Hit Blocks": N, + + "Local Read Blocks": N, + + "Local Dirtied Blocks": N, + + "Local Written Blocks": N, + + "Temp Read Blocks": N, + + "Temp Written Blocks": N, + + "Shared I/O Read Time": N.N, + + "Shared I/O Write Time": N.N, + + "Local I/O Read Time": N.N, + + "Local I/O Write Time": N.N, + + "Temp I/O Read Time": N.N, + + "Temp I/O Write Time": N.N + + }, + + "Planning Time": N.N, + + "Triggers": [ + + ], + + "Execution Time": N.N + + } + ] (1 row) @@ -436,55 +443,56 @@ select explain_filter('explain (memory, summary, format yaml) select * from int8 (1 row) select explain_filter('explain (memory, analyze, format json) select * from int8_tbl i8'); - explain_filter ------------------------------------- - [ + - { + - "Plan": { + - "Node Type": "Seq Scan", + - "Parallel Aware": false, + - "Async Capable": false, + - "Relation Name": "int8_tbl",+ - "Alias": "i8", + - "Startup Cost": N.N, + - "Total Cost": N.N, + - "Plan Rows": N, + - "Plan Width": N, + - "Actual Startup Time": N.N, + - "Actual Total Time": N.N, + - "Actual Rows": N.N, + - "Actual Loops": N, + - "Disabled": false, + - "Shared Hit Blocks": N, + - "Shared Read Blocks": N, + - "Shared Dirtied Blocks": N, + - "Shared Written Blocks": N, + - "Local Hit Blocks": N, + - "Local Read Blocks": N, + - "Local Dirtied Blocks": N, + - "Local Written Blocks": N, + - "Temp Read Blocks": N, + - "Temp Written Blocks": N + - }, + - "Planning": { + - "Shared Hit Blocks": N, + - "Shared Read Blocks": N, + - "Shared Dirtied Blocks": N, + - "Shared Written Blocks": N, + - "Local Hit Blocks": N, + - "Local Read Blocks": N, + - "Local Dirtied Blocks": N, + - "Local Written Blocks": N, + - "Temp Read Blocks": N, + - "Temp Written Blocks": N, + - "Memory Used": N, + - "Memory Allocated": N + - }, + - "Planning Time": N.N, + - "Triggers": [ + - ], + - "Execution Time": N.N + - } + + explain_filter +----------------------------------------------- + [ + + { + + "Plan": { + + "Node Type": "Seq Scan", + + "Parallel Aware": false, + + "Async Capable": false, + + "Relation Name": "int8_tbl", + + "Alias": "i8", + + "Startup Cost": N.N, + + "Total Cost": N.N, + + "Plan Rows": N, + + "Plan Width": N, + + "Actual Startup Time": N.N, + + "Actual Total Time": N.N, + + "Actual Rows": N.N, + + "Actual Loops": N, + + "Disabled": false, + + "Buffer Access Strategies": ["normal"],+ + "Shared Hit Blocks": N, + + "Shared Read Blocks": N, + + "Shared Dirtied Blocks": N, + + "Shared Written Blocks": N, + + "Local Hit Blocks": N, + + "Local Read Blocks": N, + + "Local Dirtied Blocks": N, + + "Local Written Blocks": N, + + "Temp Read Blocks": N, + + "Temp Written Blocks": N + + }, + + "Planning": { + + "Shared Hit Blocks": N, + + "Shared Read Blocks": N, + + "Shared Dirtied Blocks": N, + + "Shared Written Blocks": N, + + "Local Hit Blocks": N, + + "Local Read Blocks": N, + + "Local Dirtied Blocks": N, + + "Local Written Blocks": N, + + "Temp Read Blocks": N, + + "Temp Written Blocks": N, + + "Memory Used": N, + + "Memory Allocated": N + + }, + + "Planning Time": N.N, + + "Triggers": [ + + ], + + "Execution Time": N.N + + } + ] (1 row) @@ -542,6 +550,8 @@ select jsonb_pretty( select * from tenk1 order by tenthous') -- remove "Workers" node of the Seq Scan plan node #- '{0,Plan,Plans,0,Plans,0,Workers}' + -- remove its buffer access strategies, as they depend on shared_buffers + #- '{0,Plan,Plans,0,Plans,0,Buffer Access Strategies}' -- remove "Workers" node of the Sort plan node #- '{0,Plan,Plans,0,Workers}' -- Also remove its sort-type fields, as those aren't 100% stable @@ -767,19 +777,21 @@ select explain_filter('explain (analyze,serialize text,buffers,timing off) selec explain_filter ----------------------------------------------------------------------------------- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual rows=N.N loops=N) + Buffer Access Strategies: normal Planning Time: N.N ms Serialization: output=NkB format=text Execution Time: N.N ms -(4 rows) +(5 rows) select explain_filter('explain (analyze,serialize binary,buffers,timing) select * from int8_tbl i8'); explain_filter ------------------------------------------------------------------------------------------------- Seq Scan on int8_tbl i8 (cost=N.N..N.N rows=N width=N) (actual time=N.N..N.N rows=N.N loops=N) + Buffer Access Strategies: normal Planning Time: N.N ms Serialization: time=N.N ms output=NkB format=binary Execution Time: N.N ms -(4 rows) +(5 rows) -- this tests an edge case where we have no data to return select explain_filter('explain (analyze,buffers off,serialize) create temp table explain_temp as select * from int8_tbl i8'); diff --git a/src/test/regress/sql/explain.sql b/src/test/regress/sql/explain.sql index 2f163c64bf6..e2b9e80c678 100644 --- a/src/test/regress/sql/explain.sql +++ b/src/test/regress/sql/explain.sql @@ -151,6 +151,8 @@ select jsonb_pretty( select * from tenk1 order by tenthous') -- remove "Workers" node of the Seq Scan plan node #- '{0,Plan,Plans,0,Plans,0,Workers}' + -- remove its buffer access strategies, as they depend on shared_buffers + #- '{0,Plan,Plans,0,Plans,0,Buffer Access Strategies}' -- remove "Workers" node of the Sort plan node #- '{0,Plan,Plans,0,Workers}' -- Also remove its sort-type fields, as those aren't 100% stable -- 2.34.1