Fix wrong result in parallel ChunkAppend

src/nodes/chunk_append/planner.c

@@ -256,10 +256,12 @@ ts_chunk_append_plan_create(PlannerInfo *root, RelOptInfo *rel, CustomPath *path
 	cscan->custom_plans = custom_plans;
 
 	/*
-	 * If we do either startup or runtime exclusion, we need to pass restrictinfo
-	 * clauses into executor.
+	 * Always pass per-chunk restrictinfo clauses and RT indexes into the
+	 * executor so that the three per-chunk lists (subplans, ri_clauses,
+	 * constraints) are uniformly populated.  This is required for parallel
+	 * workers that index into these lists, and keeps startup/runtime
+	 * exclusion from having to cope with missing data.
 	 */
-	if (capath->startup_exclusion || capath->runtime_exclusion_children)
 	{
 		foreach (lc_child, cscan->custom_plans)
 		{

test/expected/parallel-15.out

@@ -603,6 +603,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=2);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_2_chunk
 
+SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0;
+ count 
+-------
+ 59999
+
 ALTER TABLE :CHUNK1 SET (parallel_workers=2);
 ALTER TABLE :CHUNK2 SET (parallel_workers=0);
 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
@@ -623,6 +628,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=0);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_1_chunk
 
+SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
+ count 
+-------
+ 60000
+
 -- Verify result correctness with mixed partial/non-partial subplans.
 -- chunk1 is partial (parallel_workers=2), chunk2 is non-partial (parallel_workers=0).
 SET max_parallel_workers_per_gather TO 0;
@@ -757,3 +767,36 @@ RESET max_parallel_workers_per_gather;
          ->  Seq Scan on _hyper_1_2_chunk
                Filter: (ts < now())
 
+-- test parallel ChunkAppend with InitPlan params (runtime exclusion)
+-- Filter on j (non-partitioning column) so that the planner produces a
+-- parallel-aware ChunkAppend with runtime_exclusion_parent but without
+-- startup_exclusion. Filtering on the partitioning column i would enable
+-- runtime_exclusion_children, making the planner pick Single Copy mode
+-- (non-parallel ChunkAppend) which does not exercise the shared-memory
+-- subplan coordination path.
+SET max_parallel_workers_per_gather = 2;
+SET parallel_tuple_cost = 0;
+SET parallel_setup_cost = 0;
+SET min_parallel_table_scan_size = 0;
+-- get the sequential result for comparison
+SET max_parallel_workers_per_gather = 0;
+SELECT count(*) AS expected FROM "test" WHERE j = (SELECT max(j) FROM "test") \gset
+-- parallel with leader participation
+SET max_parallel_workers_per_gather = 2;
+SELECT count(*) = :expected AS leader_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ leader_ok 
+-----------
+ t
+
+-- parallel with only workers (leader does not participate)
+SET parallel_leader_participation = off;
+SELECT count(*) = :expected AS workers_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ workers_ok 
+------------
+ t
+
+RESET parallel_leader_participation;
+RESET max_parallel_workers_per_gather;
+RESET parallel_tuple_cost;
+RESET parallel_setup_cost;
+RESET min_parallel_table_scan_size;

test/expected/parallel-16.out

@@ -605,6 +605,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=2);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_2_chunk
 
+SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0;
+ count 
+-------
+ 59999
+
 ALTER TABLE :CHUNK1 SET (parallel_workers=2);
 ALTER TABLE :CHUNK2 SET (parallel_workers=0);
 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
@@ -625,6 +630,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=0);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_1_chunk
 
+SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
+ count 
+-------
+ 60000
+
 -- Verify result correctness with mixed partial/non-partial subplans.
 -- chunk1 is partial (parallel_workers=2), chunk2 is non-partial (parallel_workers=0).
 SET max_parallel_workers_per_gather TO 0;
@@ -759,3 +769,36 @@ RESET max_parallel_workers_per_gather;
          ->  Seq Scan on _hyper_1_2_chunk
                Filter: (ts < now())
 
+-- test parallel ChunkAppend with InitPlan params (runtime exclusion)
+-- Filter on j (non-partitioning column) so that the planner produces a
+-- parallel-aware ChunkAppend with runtime_exclusion_parent but without
+-- startup_exclusion. Filtering on the partitioning column i would enable
+-- runtime_exclusion_children, making the planner pick Single Copy mode
+-- (non-parallel ChunkAppend) which does not exercise the shared-memory
+-- subplan coordination path.
+SET max_parallel_workers_per_gather = 2;
+SET parallel_tuple_cost = 0;
+SET parallel_setup_cost = 0;
+SET min_parallel_table_scan_size = 0;
+-- get the sequential result for comparison
+SET max_parallel_workers_per_gather = 0;
+SELECT count(*) AS expected FROM "test" WHERE j = (SELECT max(j) FROM "test") \gset
+-- parallel with leader participation
+SET max_parallel_workers_per_gather = 2;
+SELECT count(*) = :expected AS leader_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ leader_ok 
+-----------
+ t
+
+-- parallel with only workers (leader does not participate)
+SET parallel_leader_participation = off;
+SELECT count(*) = :expected AS workers_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ workers_ok 
+------------
+ t
+
+RESET parallel_leader_participation;
+RESET max_parallel_workers_per_gather;
+RESET parallel_tuple_cost;
+RESET parallel_setup_cost;
+RESET min_parallel_table_scan_size;

test/expected/parallel-17.out

@@ -605,6 +605,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=2);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_2_chunk
 
+SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0;
+ count 
+-------
+ 59999
+
 ALTER TABLE :CHUNK1 SET (parallel_workers=2);
 ALTER TABLE :CHUNK2 SET (parallel_workers=0);
 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
@@ -625,6 +630,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=0);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_1_chunk
 
+SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
+ count 
+-------
+ 60000
+
 -- Verify result correctness with mixed partial/non-partial subplans.
 -- chunk1 is partial (parallel_workers=2), chunk2 is non-partial (parallel_workers=0).
 SET max_parallel_workers_per_gather TO 0;
@@ -759,3 +769,36 @@ RESET max_parallel_workers_per_gather;
          ->  Seq Scan on _hyper_1_2_chunk
                Filter: (ts < now())
 
+-- test parallel ChunkAppend with InitPlan params (runtime exclusion)
+-- Filter on j (non-partitioning column) so that the planner produces a
+-- parallel-aware ChunkAppend with runtime_exclusion_parent but without
+-- startup_exclusion. Filtering on the partitioning column i would enable
+-- runtime_exclusion_children, making the planner pick Single Copy mode
+-- (non-parallel ChunkAppend) which does not exercise the shared-memory
+-- subplan coordination path.
+SET max_parallel_workers_per_gather = 2;
+SET parallel_tuple_cost = 0;
+SET parallel_setup_cost = 0;
+SET min_parallel_table_scan_size = 0;
+-- get the sequential result for comparison
+SET max_parallel_workers_per_gather = 0;
+SELECT count(*) AS expected FROM "test" WHERE j = (SELECT max(j) FROM "test") \gset
+-- parallel with leader participation
+SET max_parallel_workers_per_gather = 2;
+SELECT count(*) = :expected AS leader_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ leader_ok 
+-----------
+ t
+
+-- parallel with only workers (leader does not participate)
+SET parallel_leader_participation = off;
+SELECT count(*) = :expected AS workers_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ workers_ok 
+------------
+ t
+
+RESET parallel_leader_participation;
+RESET max_parallel_workers_per_gather;
+RESET parallel_tuple_cost;
+RESET parallel_setup_cost;
+RESET min_parallel_table_scan_size;

test/expected/parallel-18.out

@@ -578,6 +578,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=2);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_2_chunk
 
+SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0;
+ count 
+-------
+ 59999
+
 ALTER TABLE :CHUNK1 SET (parallel_workers=2);
 ALTER TABLE :CHUNK2 SET (parallel_workers=0);
 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
@@ -598,6 +603,11 @@ ALTER TABLE :CHUNK2 SET (parallel_workers=0);
                                  One-Time Filter: (length(version()) > 0)
                                  ->  Parallel Seq Scan on _hyper_1_1_chunk
 
+SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
+ count 
+-------
+ 60000
+
 -- Verify result correctness with mixed partial/non-partial subplans.
 -- chunk1 is partial (parallel_workers=2), chunk2 is non-partial (parallel_workers=0).
 SET max_parallel_workers_per_gather TO 0;
@@ -732,3 +742,36 @@ RESET max_parallel_workers_per_gather;
          ->  Seq Scan on _hyper_1_2_chunk
                Filter: (ts < now())
 
+-- test parallel ChunkAppend with InitPlan params (runtime exclusion)
+-- Filter on j (non-partitioning column) so that the planner produces a
+-- parallel-aware ChunkAppend with runtime_exclusion_parent but without
+-- startup_exclusion. Filtering on the partitioning column i would enable
+-- runtime_exclusion_children, making the planner pick Single Copy mode
+-- (non-parallel ChunkAppend) which does not exercise the shared-memory
+-- subplan coordination path.
+SET max_parallel_workers_per_gather = 2;
+SET parallel_tuple_cost = 0;
+SET parallel_setup_cost = 0;
+SET min_parallel_table_scan_size = 0;
+-- get the sequential result for comparison
+SET max_parallel_workers_per_gather = 0;
+SELECT count(*) AS expected FROM "test" WHERE j = (SELECT max(j) FROM "test") \gset
+-- parallel with leader participation
+SET max_parallel_workers_per_gather = 2;
+SELECT count(*) = :expected AS leader_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ leader_ok 
+-----------
+ t
+
+-- parallel with only workers (leader does not participate)
+SET parallel_leader_participation = off;
+SELECT count(*) = :expected AS workers_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+ workers_ok 
+------------
+ t
+
+RESET parallel_leader_participation;
+RESET max_parallel_workers_per_gather;
+RESET parallel_tuple_cost;
+RESET parallel_setup_cost;
+RESET min_parallel_table_scan_size;

test/sql/parallel.sql.in

@@ -167,10 +167,12 @@ RESET max_parallel_workers_per_gather;
 ALTER TABLE :CHUNK1 SET (parallel_workers=0);
 ALTER TABLE :CHUNK2 SET (parallel_workers=2);
 :PREFIX SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0;
+SELECT count(*) FROM "test" WHERE i > 400000 AND length(version()) > 0;
 
 ALTER TABLE :CHUNK1 SET (parallel_workers=2);
 ALTER TABLE :CHUNK2 SET (parallel_workers=0);
 :PREFIX SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
+SELECT count(*) FROM "test" WHERE i < 600000 AND length(version()) > 0;
 
 -- Verify result correctness with mixed partial/non-partial subplans.
 -- chunk1 is partial (parallel_workers=2), chunk2 is non-partial (parallel_workers=0).
@@ -240,3 +242,33 @@ RESET max_parallel_workers_per_gather;
 -- this won't be parallel query because now() is parallel restricted in PG < 12
 :PREFIX SELECT i FROM "test" WHERE ts < now();
 
+-- test parallel ChunkAppend with InitPlan params (runtime exclusion)
+-- Filter on j (non-partitioning column) so that the planner produces a
+-- parallel-aware ChunkAppend with runtime_exclusion_parent but without
+-- startup_exclusion. Filtering on the partitioning column i would enable
+-- runtime_exclusion_children, making the planner pick Single Copy mode
+-- (non-parallel ChunkAppend) which does not exercise the shared-memory
+-- subplan coordination path.
+SET max_parallel_workers_per_gather = 2;
+SET parallel_tuple_cost = 0;
+SET parallel_setup_cost = 0;
+SET min_parallel_table_scan_size = 0;
+
+-- get the sequential result for comparison
+SET max_parallel_workers_per_gather = 0;
+SELECT count(*) AS expected FROM "test" WHERE j = (SELECT max(j) FROM "test") \gset
+
+-- parallel with leader participation
+SET max_parallel_workers_per_gather = 2;
+SELECT count(*) = :expected AS leader_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+
+-- parallel with only workers (leader does not participate)
+SET parallel_leader_participation = off;
+SELECT count(*) = :expected AS workers_ok FROM "test" WHERE j = (SELECT max(j) FROM "test");
+RESET parallel_leader_participation;
+
+RESET max_parallel_workers_per_gather;
+RESET parallel_tuple_cost;
+RESET parallel_setup_cost;
+RESET min_parallel_table_scan_size;
+