Stabilize regression tests across PostgreSQL 17–19

Extend portable_explain_analyze() to normalise additional sources of
version-specific output variation:

- Strip "Index Searches: N" lines introduced in PG 18 so that a single
  expected file covers both PG 17 and PG 18+.  This also lets us drop
  expected/join_filtering_1.out entirely, leaving one canonical file.
- Normalise "actual rows=N.00" to "actual rows=N".  PG 18 started
  printing row counts with two decimal places inside EXPLAIN ANALYZE
  output; the normalisation hides this from all callers of the helper.
- Normalise "Heap Fetches: N" to mask the non-deterministic value that
  depends on visibility-map state at test time.

Switch subplan.sql to route both EXPLAIN calls through
portable_explain_analyze() so that the normalisation rules apply there
too.  Add "AND query LIKE 'EXPLAIN%'" to the tracking-result query so
that only the inner EXPLAIN query appears in pg_track_optimizer(), not
the portable_explain_analyze() wrapper itself.

Update expected output files accordingly:
- expected/subplan.out     – PG 19+ (SubPlan expr_1 naming)
- expected/subplan_1.out   – PG 17–18 (SubPlan 1 naming)
- expected/subplan_2.out   – deleted; PG 16 is no longer supported
- expected/join_filtering_1.out – deleted; consolidated into one file
- expected/pg_track_optimizer.out / _1.out – updated for the
  portable_explain_analyze() change in the verify_test block

Add a "Regression Test Expected Output Files" section to README.md
documenting which file covers which PostgreSQL version and why.

Author: danolivo

README.md

@@ -313,6 +313,22 @@ SELECT pg_track_optimizer_reset();
 -- Re-check error metrics
 ```
 
+## Regression Test Expected Output Files
+
+PostgreSQL's `pg_regress` supports multiple alternative expected output files
+(`test.out`, `test_1.out`, `test_2.out`, …).  It tries each in order and
+passes if any matches.  This extension uses that mechanism to handle
+differences in plan output across PostgreSQL versions.
+
+| File | PostgreSQL version | Key differences |
+|------|--------------------|-----------------|
+| `expected/pg_track_optimizer.out` | PG 18+ | `actual rows=N.00` notation; `Heap Fetches` normalised via `portable_explain_analyze`; `Index Searches` filtered out |
+| `expected/pg_track_optimizer_1.out` | PG 17 | `actual rows=N` (no decimals); `Heap Fetches` normalised; `Index Searches` filtered out |
+| `expected/join_filtering.out` | all versions | `Index Searches` and `rows=N.00` normalised by `portable_explain_analyze` |
+| `expected/subplan.out` | PG 19+ | `SubPlan expr_1` naming (new in PG 19); output via `portable_explain_analyze` |
+| `expected/subplan_1.out` | PG 17–18 | `SubPlan 1` naming; output via `portable_explain_analyze` |
+| `expected/interface.out` | all versions | No version-specific differences |
+
 ## Implementation Notes
 
 - **Filtering metrics**: The extension tracks filtering overhead separately from error calculations via `f_scan_filter` and `f_join_filter` metrics. For leaf nodes (scans), `f_scan_filter` captures `nfiltered1` weighted by relative time and output rows. For JOIN nodes, `f_join_filter` captures `nfiltered1 + nfiltered2` similarly weighted. These metrics help identify inefficient scans or joins where many rows are fetched but filtered out. Filtered tuples are **not** included in error calculations (`avg_error`, `rms_error`, etc.) to keep error metrics focused on cardinality estimation accuracy rather than filtering efficiency.

expected/join_filtering.out

@@ -11,6 +11,10 @@ begin
     out_line := regexp_replace(line, '\d+kB', 'NNkB', 'g');
     out_line := regexp_replace(out_line, 'rows=(\d+)\.00', 'rows=\1', 'g');
     out_line := regexp_replace(out_line, '(Heap Fetches:) \d+', '\1 N', 'g');
+    -- Skip Index Searches line: added in PG 18, not present in PG 17
+    if out_line ~ '^\s*Index Searches:' then
+      continue;
+    end if;
     return next;
   end loop;
 end;
@@ -157,12 +161,11 @@ SELECT portable_explain_analyze('SELECT * FROM join_inner JOIN join_outer USING
  Merge Join (actual rows=100 loops=1)
    Merge Cond: (join_outer.id = join_inner.id)
    ->  Index Scan using join_outer_id_idx on join_outer (actual rows=101 loops=1)
-         Index Searches: 1
    ->  Sort (actual rows=100 loops=1)
          Sort Key: join_inner.id
          Sort Method: quicksort  Memory: NNkB
          ->  Seq Scan on join_inner (actual rows=100 loops=1)
-(8 rows)
+(7 rows)
 
 SELECT
   ROUND((avg_avg::numeric), 2) AS err,

expected/join_filtering_1.out

@@ -146,8 +146,7 @@ SELECT portable_explain_analyze('SELECT val FROM verify_test;');
    Workers Launched: 4
    ->  Parallel Index Only Scan using idx_verify on verify_test (actual rows=20000 loops=5)
          Heap Fetches: N
-         Index Searches: 1
-(6 rows)
+(5 rows)
 
 -- XXX: if we ever implement per-node error printing it would allow to
 -- demonstrate how the error grows and show reasoning for the final value in

expected/pg_track_optimizer.out

@@ -138,15 +138,14 @@ UPDATE verify_test SET val = val + 1 WHERE id % 10 = 0;
 SET min_parallel_index_scan_size = 0;
 SET enable_seqscan = off;
 -- Check if we get parallel index-only scan WITH heap fetches
-EXPLAIN (COSTS OFF, ANALYZE, BUFFERS OFF, TIMING OFF, SUMMARY OFF)
-SELECT val FROM verify_test;
-                                         QUERY PLAN                                         
+SELECT portable_explain_analyze('SELECT val FROM verify_test;');
+                                  portable_explain_analyze
 --------------------------------------------------------------------------------------------
  Gather (actual rows=100000 loops=1)
    Workers Planned: 4
    Workers Launched: 4
    ->  Parallel Index Only Scan using idx_verify on verify_test (actual rows=20000 loops=5)
-         Heap Fetches: 110000
+         Heap Fetches: N
 (5 rows)
 
 -- XXX: if we ever implement per-node error printing it would allow to
@@ -155,11 +154,11 @@ SELECT val FROM verify_test;
 -- So, make this test helpful in the future ...
 SELECT query,evaluated_nodes,plan_nodes,nexecs
 FROM pg_track_optimizer() WHERE query LIKE '%FROM verify_test%';
-                               query                                | evaluated_nodes | plan_nodes | nexecs 
---------------------------------------------------------------------+-----------------+------------+--------
- EXPLAIN (COSTS OFF, ANALYZE, BUFFERS OFF, TIMING OFF, SUMMARY OFF)+|               2 |          2 |      1
- SELECT val FROM verify_test;                                       |                 |            | 
-(1 row)
+                                             query                                              | evaluated_nodes | plan_nodes | nexecs
+------------------------------------------------------------------------------------------------+-----------------+------------+--------
+ SELECT portable_explain_analyze('SELECT val FROM verify_test;');                               |               2 |          2 |      1
+ EXPLAIN (ANALYZE, COSTS OFF, TIMING OFF, SUMMARY OFF, BUFFERS OFF)SELECT val FROM verify_test; |               2 |          2 |      1
+(2 rows)
 
 -- Test the case when we prepare all the stuff for execution but never actually
 -- executed query plan (total time == 0)
@@ -176,7 +175,7 @@ COMMIT;
 SELECT * FROM pg_track_optimizer_reset();
  pg_track_optimizer_reset 
 --------------------------
-                       13
+                       14
 (1 row)
 
 DROP EXTENSION pg_track_optimizer;