Bugfix. inherent number of rows from parallel path , not from RelOptInfo.

danolivo · danolivo · commit 91ab602ea1dc · 2024-06-18T17:28:06.000+07:00
diff --git a/contrib/tempscan/expected/basic.out b/contrib/tempscan/expected/basic.out
@@ -31,14 +31,87 @@ SELECT count(*) FROM parallel_test;
 -- Should also utilise parallel workers like scanning of a plain table
 EXPLAIN (COSTS OFF)
 SELECT count(*) FROM parallel_test_tmp;
-                        QUERY PLAN                        
-----------------------------------------------------------
- Aggregate
+                           QUERY PLAN                           
+----------------------------------------------------------------
+ Finalize Aggregate
    ->  Gather
          Workers Planned: 1
-         ->  Custom Scan (nodeCustomTempScan)
-               ->  Parallel Seq Scan on parallel_test_tmp
-(5 rows)
+         ->  Partial Aggregate
+               ->  Custom Scan (nodeCustomTempScan)
+                     ->  Parallel Seq Scan on parallel_test_tmp
+(6 rows)
+
+-- Want to see here partial aggregate over parallel join
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test t1 NATURAL JOIN parallel_test t2;
+                             QUERY PLAN                              
+---------------------------------------------------------------------
+ Finalize Aggregate
+   ->  Gather
+         Workers Planned: 1
+         ->  Partial Aggregate
+               ->  Parallel Hash Join
+                     Hash Cond: (t1.x = t2.x)
+                     ->  Parallel Seq Scan on parallel_test t1
+                     ->  Parallel Hash
+                           ->  Parallel Seq Scan on parallel_test t2
+(9 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test_tmp t1 NATURAL JOIN parallel_test t2;
+                               QUERY PLAN                                
+-------------------------------------------------------------------------
+ Finalize Aggregate
+   ->  Gather
+         Workers Planned: 1
+         ->  Partial Aggregate
+               ->  Parallel Hash Join
+                     Hash Cond: (t1.x = t2.x)
+                     ->  Custom Scan (nodeCustomTempScan)
+                           ->  Parallel Seq Scan on parallel_test_tmp t1
+                     ->  Parallel Hash
+                           ->  Parallel Seq Scan on parallel_test t2
+(10 rows)
+
+-- Just see how merge join manages custom parallel scan path
+SET enable_hashjoin = 'off';
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test t1 NATURAL JOIN parallel_test t2;
+                             QUERY PLAN                              
+---------------------------------------------------------------------
+ Finalize Aggregate
+   ->  Gather
+         Workers Planned: 1
+         ->  Partial Aggregate
+               ->  Merge Join
+                     Merge Cond: (t1.x = t2.x)
+                     ->  Sort
+                           Sort Key: t1.x
+                           ->  Parallel Seq Scan on parallel_test t1
+                     ->  Sort
+                           Sort Key: t2.x
+                           ->  Seq Scan on parallel_test t2
+(12 rows)
+
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test_tmp t1 NATURAL JOIN parallel_test t2;
+                                  QUERY PLAN                                   
+-------------------------------------------------------------------------------
+ Finalize Aggregate
+   ->  Gather
+         Workers Planned: 1
+         ->  Partial Aggregate
+               ->  Merge Join
+                     Merge Cond: (t1.x = t2.x)
+                     ->  Sort
+                           Sort Key: t1.x
+                           ->  Custom Scan (nodeCustomTempScan)
+                                 ->  Parallel Seq Scan on parallel_test_tmp t1
+                     ->  Sort
+                           Sort Key: t2.x
+                           ->  Seq Scan on parallel_test t2
+(13 rows)
 
+RESET enable_hashjoin;
 RESET tempscan.enable;
 DROP TABLE parallel_test, parallel_test_tmp;
diff --git a/contrib/tempscan/nodeCustomTempScan.c b/contrib/tempscan/nodeCustomTempScan.c
@@ -14,6 +14,7 @@
 #include "postgres.h"
 
 #include "nodes/extensible.h"
+#include "optimizer/clauses.h"
 #include "optimizer/cost.h"
 #include "optimizer/pathnode.h"
 #include "optimizer/paths.h"
@@ -70,6 +71,7 @@ static CustomExecMethods exec_methods =
 };
 
 static set_rel_pathlist_hook_type set_rel_pathlist_hook_next = NULL;
+
 static bool tempscan_enable = false;
 
 void _PG_init(void);
@@ -90,7 +92,7 @@ create_partial_tempscan_path(PlannerInfo *root, RelOptInfo *rel,
 	pathnode->pathtype = T_CustomScan;
 	pathnode->parent = rel;
 	pathnode->pathtarget = rel->reltarget;
-	pathnode->rows = rel->rows;
+	pathnode->rows = path->rows; /* Don't use rel->rows! Remember semantics of this field in the parallel case */
 
 	/* XXX: Just for now */
 	pathnode->param_info = NULL;
@@ -100,8 +102,8 @@ create_partial_tempscan_path(PlannerInfo *root, RelOptInfo *rel,
 	pathnode->parallel_workers = path->parallel_workers;
 
 	/* DEBUGGING purposes only */
-	pathnode->startup_cost = path->startup_cost / disable_cost;
-	pathnode->total_cost = path->total_cost / disable_cost;
+	pathnode->startup_cost = path->startup_cost /*/ disable_cost*/;
+	pathnode->total_cost = path->total_cost /*/ disable_cost*/;
 
 	cpath->custom_paths = list_make1(path);
 	cpath->custom_private = NIL;
@@ -213,21 +215,25 @@ try_partial_tempscan(PlannerInfo *root, RelOptInfo *rel, Index rti,
 	if (set_rel_pathlist_hook_next)
 		(*set_rel_pathlist_hook_next)(root, rel, rti, rte);
 
-	if (rel->consider_parallel)
+	if (!tempscan_enable || rel->consider_parallel)
 		return;
 
 	if (rte->rtekind != RTE_RELATION ||
 		get_rel_persistence(rte->relid) != RELPERSISTENCE_TEMP)
 		return;
 
+	/* HACK */
+	if (!is_parallel_safe(root, (Node *) rel->baserestrictinfo) ||
+		!is_parallel_safe(root, (Node *) rel->reltarget->exprs))
+		return;
+
 	parallel_workers = compute_parallel_worker(rel, rel->pages, -1,
 											   max_parallel_workers_per_gather);
 
 	/* If any limit was set to zero, the user doesn't want a parallel scan. */
 	if (parallel_workers <= 0)
 		return;
 
-	/* HACK */
 	rel->consider_parallel = true;
 
 	path = create_seqscan_path(root, rel, NULL, parallel_workers);
@@ -238,8 +244,6 @@ try_partial_tempscan(PlannerInfo *root, RelOptInfo *rel, Index rti,
 								create_partial_tempscan_path(root, rel, path));
 	}
 
-	if (!bms_equal(rel->relids, root->all_query_rels))
-		rel->consider_parallel = false;
 	Assert(IsA(linitial(rel->partial_pathlist), CustomPath));
 }
 
diff --git a/contrib/tempscan/sql/basic.sql b/contrib/tempscan/sql/basic.sql
@@ -29,5 +29,19 @@ SELECT count(*) FROM parallel_test;
 EXPLAIN (COSTS OFF)
 SELECT count(*) FROM parallel_test_tmp;
 
+-- Want to see here partial aggregate over parallel join
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test t1 NATURAL JOIN parallel_test t2;
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test_tmp t1 NATURAL JOIN parallel_test t2;
+
+-- Just see how merge join manages custom parallel scan path
+SET enable_hashjoin = 'off';
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test t1 NATURAL JOIN parallel_test t2;
+EXPLAIN (COSTS OFF)
+SELECT count(*) FROM parallel_test_tmp t1 NATURAL JOIN parallel_test t2;
+
+RESET enable_hashjoin;
 RESET tempscan.enable;
 DROP TABLE parallel_test, parallel_test_tmp;
