ADBDEV-4152: Optimize the Explicit Redistribute application logic

src/backend/cdb/cdbmutate.c

@@ -75,8 +75,18 @@ typedef struct ApplyMotionState
 								 * plan_tree_walker/mutator */
 	int			nextMotionID;
 	int			sliceDepth;
-	bool		containMotionNodes;
 	HTAB	   *planid_subplans; /* hash table for InitPlanItem */
+
+	/* Context for ModifyTable to elide Explicit Redistribute Motion */
+	bool		mtIsChecking;		/* True if we encountered ModifyTable
+									 * node with UPDATE/DELETE and we plan
+									 * to insert Explicit Motions. */
+	Bitmapset  *mtResultRtis; 		/* Indexes into rtable for relations to
+									 * be modified. Only valid if mtIsChecking
+									 * is true. */
+	bool		needExplicitMotion;
+	int			nMotionsAbove;		/* Number of motions above the current
+									 * node */
 } ApplyMotionState;
 
 typedef struct InitPlanItem
@@ -404,7 +414,11 @@ apply_motion(PlannerInfo *root, Plan *plan, Query *query)
 													 * plan */
 	state.nextMotionID = 1;		/* Start at 1 so zero will mean "unassigned". */
 	state.sliceDepth = 0;
-	state.containMotionNodes = false;
+	state.mtResultRtis = NULL;
+	state.needExplicitMotion = false;
+	state.nMotionsAbove = 0;
+	state.mtIsChecking = false;
+
 	memset(&ctl, 0, sizeof(ctl));
 	ctl.keysize = sizeof(int);
 	ctl.entrysize = sizeof(InitPlanItem);
@@ -755,14 +769,14 @@ apply_motion_mutator(Node *node, ApplyMotionState *context)
 	if (!is_plan_node(node))
 	{
 		/*
-		 * The containMotionNodes flag keeps track of whether there are any
-		 * Motion nodes, ignoring any in InitPlans. So if we recurse into an
-		 * InitPlan, save and restore the flag.
+		 * mtIsChecking is true whether we are checking for motions underneath
+		 * to add Explicit Reditribute Motion, ignoring any in InitPlans. So if
+		 * we recurse into an InitPlan, save it and temporarily set it to false.
 		 */
 		if (IsA(node, SubPlan) &&((SubPlan *) node)->is_initplan)
 		{
 			bool		found;
-			bool		saveContainMotionNodes = context->containMotionNodes;
+			bool		saveMtIsChecking = context->mtIsChecking;
 			int			saveSliceDepth = context->sliceDepth;
 			SubPlan		*subplan = (SubPlan *) node;
 			/*
@@ -777,9 +791,10 @@ apply_motion_mutator(Node *node, ApplyMotionState *context)
 
 			/* reset sliceDepth for each init plan */
 			context->sliceDepth = 0;
+			context->mtIsChecking = false;
 			node = plan_tree_mutator(node, apply_motion_mutator, context);
 
-			context->containMotionNodes = saveContainMotionNodes;
+			context->mtIsChecking = saveMtIsChecking;
 			context->sliceDepth = saveSliceDepth;
 
 			return node;
@@ -788,6 +803,102 @@ apply_motion_mutator(Node *node, ApplyMotionState *context)
 			return plan_tree_mutator(node, apply_motion_mutator, context);
 	}
 
+	/*
+	 * For UPDATE/DELETE, we check if there's any motions before scan in the
+	 * same subtree for the table we're going to modify. If we encounter the
+	 * scan before any motions, then we can elide unnecessary Explicit
+	 * Redistribute Motion.
+	 */
+	if (IsA(node, ModifyTable))
+	{
+		ModifyTable *mt = (ModifyTable *) node;
+
+		if (mt->operation == CMD_UPDATE || mt->operation == CMD_DELETE)
+		{
+			ListCell   *lcr;
+
+			/*
+			 * Sanity check, since we don't allow multiple ModifyTable nodes.
+			 */
+			Assert(context->mtResultRtis == NULL);
+			Assert(context->nMotionsAbove == 0);
+			Assert(!context->needExplicitMotion);
+			Assert(!context->mtIsChecking);
+
+			/*
+			 * When UPDATE/DELETE occurs on a partitioned table, or a table that
+			 * is a part of inheritance tree, ModifyTable node will have more
+			 * than one relation in resultRelations.
+			 *
+			 * We make a set of resulting relations' indexes to compare them
+			 * later.
+			 */
+			foreach(lcr, mt->resultRelations)
+			{
+				context->mtResultRtis = bms_add_member(context->mtResultRtis,
+													   lfirst_int(lcr));
+			}
+
+			context->mtIsChecking = true;
+		}
+	}
+
+	if (context->mtIsChecking)
+	{
+
+		/* Remember if we are descending into a motion node. */
+		if (IsA(node, Motion))
+			context->nMotionsAbove++;
+
+		/*
+		 * If this is a scan and it's scanrelid matches ModifyTable's relid,
+		 * we need to check if there were any motions above.
+		 */
+		else
+		{
+			/*
+			 * These are scan nodes that can be used to perform distributed
+			 * UPDATE/DELETE on the relation they scan, possibly with motions
+			 * above them. This list needs to be updated for other nodes if they
+			 * are changed to support DML execution on segments.
+			 */
+			switch (nodeTag(node))
+			{
+				case T_SeqScan:
+				case T_DynamicSeqScan:
+				case T_IndexScan:
+				case T_DynamicIndexScan:
+				case T_IndexOnlyScan:
+				case T_BitmapIndexScan:
+				case T_DynamicBitmapIndexScan:
+				case T_BitmapHeapScan:
+				case T_DynamicBitmapHeapScan:
+				case T_TidScan:
+					{
+						Scan	   *scan = (Scan *) node;
+
+						if (bms_is_member(scan->scanrelid, context->mtResultRtis))
+						{
+							/*
+							 * We need Explicit Redistribute Motion only if
+							 * there were any motions above.
+							 */
+							context->needExplicitMotion = context->nMotionsAbove > 0;
+
+							/*
+							 * We don't need to check other nodes in this
+							 * subtree anymore.
+							 */
+							context->mtIsChecking = false;
+						}
+					}
+					break;
+				default:
+					break;
+			}
+		}
+	}
+
 	plan = (Plan *) node;
 	flow = plan->flow;
 
@@ -936,17 +1047,11 @@ apply_motion_mutator(Node *node, ApplyMotionState *context)
 			break;
 
 		case MOVEMENT_EXPLICIT:
-
 			/*
-			 * add an ExplicitRedistribute motion node only if child plan
-			 * nodes have a motion node
+			 * Were there any motions above the scan?
 			 */
-			if (context->containMotionNodes)
+			if (context->needExplicitMotion)
 			{
-				/*
-				 * motion node in child nodes: add a ExplicitRedistribute
-				 * motion
-				 */
 				newnode = (Node *) make_explicit_motion(plan,
 														flow->segidColIdx,
 														true	/* useExecutorVarFormat */
@@ -955,13 +1060,21 @@ apply_motion_mutator(Node *node, ApplyMotionState *context)
 			else
 			{
 				/*
-				 * no motion nodes in child plan nodes - no need for
-				 * ExplicitRedistribute: restore flow
+				 * Restore flow if Explicit Redistribute Motion is not needed
 				 */
 				flow->req_move = MOVEMENT_NONE;
 				flow->flow_before_req_move = NULL;
 			}
 
+			/*
+			 * If we're here, it means we are directly under the ModifyTable
+			 * node. We are about to go to out of the recursion and go into
+			 * other subtree. So reset the state and continue checking in case
+			 * of another Explicit Redistribute Motion is needed.
+			 */
+			context->mtIsChecking = true;
+			context->needExplicitMotion = false;
+			context->nMotionsAbove = 0;
 			break;
 
 		case MOVEMENT_NONE:
@@ -1009,16 +1122,14 @@ apply_motion_mutator(Node *node, ApplyMotionState *context)
 	plan->nMotionNodes = context->nextMotionID - saveNextMotionID;
 	plan->nInitPlans = hash_get_num_entries(context->planid_subplans) - saveNumInitPlans;
 
-	/*
-	 * Remember if this was a Motion node. This is used at the top of the
-	 * tree, with MOVEMENT_EXPLICIT, to avoid adding an explicit motion, if
-	 * there were no Motion in the subtree. Note that this does not take
-	 * InitPlans containing Motion nodes into account. InitPlans are executed
-	 * as a separate step before the main plan, and hence any Motion nodes in
-	 * them don't need to affect the way the main plan is executed.
-	 */
-	if (IsA(newnode, Motion))
-		context->containMotionNodes = true;
+	if (context->mtIsChecking)
+	{
+		/* We're going out of this motion node. */
+		if (IsA(node, Motion))
+			context->nMotionsAbove--;
+		else if (IsA(node, ModifyTable))
+			context->mtIsChecking = false;
+	}
 
 	return newnode;
 }								/* apply_motion_mutator */

src/test/regress/expected/bfv_dml.out

@@ -521,17 +521,16 @@ alter table bar set with(REORGANIZE=false) distributed randomly;
 analyze foo;
 analyze bar;
 explain delete from foo using bar;
-                                                      QUERY PLAN                                                       
------------------------------------------------------------------------------------------------------------------------
+                                            QUERY PLAN                                            
+--------------------------------------------------------------------------------------------------
  Delete on foo  (cost=10000000000.00..10000000009.98 rows=34 width=16)
-   ->  Explicit Redistribute Motion 3:3  (slice2; segments: 3)  (cost=10000000000.00..10000000009.98 rows=34 width=16)
-         ->  Nested Loop  (cost=10000000000.00..10000000009.98 rows=34 width=16)
-               ->  Seq Scan on foo  (cost=0.00..3.10 rows=4 width=10)
-               ->  Materialize  (cost=0.00..3.65 rows=10 width=6)
-                     ->  Broadcast Motion 3:3  (slice1; segments: 3)  (cost=0.00..3.50 rows=10 width=6)
-                           ->  Seq Scan on bar  (cost=0.00..3.10 rows=4 width=6)
+   ->  Nested Loop  (cost=10000000000.00..10000000009.98 rows=34 width=16)
+         ->  Seq Scan on foo  (cost=0.00..3.10 rows=4 width=10)
+         ->  Materialize  (cost=0.00..3.65 rows=10 width=6)
+               ->  Broadcast Motion 3:3  (slice1; segments: 3)  (cost=0.00..3.50 rows=10 width=6)
+                     ->  Seq Scan on bar  (cost=0.00..3.10 rows=4 width=6)
  Optimizer: Postgres query optimizer
-(8 rows)
+(7 rows)
 
 delete from foo using bar;
 drop table foo;

src/test/regress/expected/gangsize.out

@@ -173,13 +173,11 @@ end;
 INFO:  Distributed transaction command 'Distributed Commit (one-phase)' to PARTIAL contents: 0 1
 update random_2_0 set a = 1 from hash_3_3_2 where hash_3_3_2.b = random_2_0.c;
 INFO:  (slice 1) Dispatch command to ALL contents: 0 1 2
-INFO:  (slice 2) Dispatch command to PARTIAL contents: 0 1
 INFO:  (slice 0) Dispatch command to PARTIAL contents: 0 1
 INFO:  Distributed transaction command 'Distributed Commit (one-phase)' to ALL contents: 0 1 2
 begin;
 update random_2_0 set a = 1 from hash_3_3_2 where hash_3_3_2.b = random_2_0.c;
 INFO:  (slice 1) Dispatch command to ALL contents: 0 1 2
-INFO:  (slice 2) Dispatch command to PARTIAL contents: 0 1
 INFO:  (slice 0) Dispatch command to PARTIAL contents: 0 1
 end;
 INFO:  Distributed transaction command 'Distributed Commit (one-phase)' to ALL contents: 0 1 2

src/test/regress/expected/gangsize_optimizer.out

@@ -171,13 +171,11 @@ end;
 INFO:  Distributed transaction command 'Distributed Commit (one-phase)' to PARTIAL contents: 0 1
 update random_2_0 set a = 1 from hash_3_3_2 where hash_3_3_2.b = random_2_0.c;
 INFO:  (slice 1) Dispatch command to ALL contents: 0 1 2
-INFO:  (slice 2) Dispatch command to PARTIAL contents: 0 1
 INFO:  (slice 0) Dispatch command to PARTIAL contents: 0 1
 INFO:  Distributed transaction command 'Distributed Commit (one-phase)' to ALL contents: 0 1 2
 begin;
 update random_2_0 set a = 1 from hash_3_3_2 where hash_3_3_2.b = random_2_0.c;
 INFO:  (slice 1) Dispatch command to ALL contents: 0 1 2
-INFO:  (slice 2) Dispatch command to PARTIAL contents: 0 1
 INFO:  (slice 0) Dispatch command to PARTIAL contents: 0 1
 end;
 INFO:  Distributed transaction command 'Distributed Commit (one-phase)' to ALL contents: 0 1 2

src/test/regress/expected/gp_unique_rowid.out

@@ -192,22 +192,21 @@ where e.x in
     select b from t2_12512
     )
 ;
-                                QUERY PLAN                                 
----------------------------------------------------------------------------
+                             QUERY PLAN                              
+---------------------------------------------------------------------
  Update on t_12512
-   ->  Explicit Redistribute Motion 3:3  (slice2; segments: 3)
-         ->  HashAggregate
-               Group Key: t_12512.ctid, x.ctid
-               ->  Hash Join
-                     Hash Cond: (x.x = t2_12512.b)
-                     ->  Nested Loop
-                           ->  Seq Scan on t_12512
-                           ->  Function Scan on x
-                     ->  Hash
-                           ->  Broadcast Motion 3:3  (slice1; segments: 3)
-                                 ->  Seq Scan on t2_12512
+   ->  HashAggregate
+         Group Key: t_12512.ctid, x.ctid
+         ->  Hash Join
+               Hash Cond: (x.x = t2_12512.b)
+               ->  Nested Loop
+                     ->  Seq Scan on t_12512
+                     ->  Function Scan on x
+               ->  Hash
+                     ->  Broadcast Motion 3:3  (slice1; segments: 3)
+                           ->  Seq Scan on t2_12512
  Optimizer: Postgres query optimizer
-(13 rows)
+(12 rows)
 
 update t_12512 set b = 1
     from
@@ -231,23 +230,22 @@ where e.x in
     select b from t2_12512
     )
 ;
-                                QUERY PLAN                                 
----------------------------------------------------------------------------
+                             QUERY PLAN                              
+---------------------------------------------------------------------
  Update on t_12512
-   ->  Explicit Redistribute Motion 3:3  (slice2; segments: 3)
-         ->  HashAggregate
-               Group Key: t_12512.ctid, "*VALUES*".ctid
-               ->  Hash Join
-                     Hash Cond: ("*VALUES*".column1 = t2_12512.b)
-                     ->  Nested Loop
-                           ->  Seq Scan on t_12512
-                           ->  Materialize
-                                 ->  Values Scan on "*VALUES*"
-                     ->  Hash
-                           ->  Broadcast Motion 3:3  (slice1; segments: 3)
-                                 ->  Seq Scan on t2_12512
+   ->  HashAggregate
+         Group Key: t_12512.ctid, "*VALUES*".ctid
+         ->  Hash Join
+               Hash Cond: ("*VALUES*".column1 = t2_12512.b)
+               ->  Nested Loop
+                     ->  Seq Scan on t_12512
+                     ->  Materialize
+                           ->  Values Scan on "*VALUES*"
+               ->  Hash
+                     ->  Broadcast Motion 3:3  (slice1; segments: 3)
+                           ->  Seq Scan on t2_12512
  Optimizer: Postgres query optimizer
-(14 rows)
+(13 rows)
 
 update t_12512 set b = 1
     from

src/test/regress/expected/gporca.out

@@ -11861,19 +11861,18 @@ select b, count(*) from gpexp_hash group by b order by b;
 (11 rows)
 
 explain update gpexp_rand set b=(select b from gpexp_hash where gpexp_rand.a = gpexp_hash.a);
-                                                  QUERY PLAN                                                   
----------------------------------------------------------------------------------------------------------------
+                                               QUERY PLAN                                                
+---------------------------------------------------------------------------------------------------------
  Update on gpexp_rand  (cost=0.00..133.75 rows=25 width=14)
-   ->  Explicit Redistribute Motion 2:2  (slice2; segments: 2)  (cost=0.00..133.75 rows=25 width=14)
-         ->  Seq Scan on gpexp_rand  (cost=0.00..133.75 rows=25 width=14)
-               SubPlan 1  (slice2; segments: 2)
-                 ->  Result  (cost=0.00..2.63 rows=1 width=4)
-                       Filter: (gpexp_rand.a = gpexp_hash.a)
-                       ->  Materialize  (cost=0.00..2.63 rows=1 width=4)
-                             ->  Broadcast Motion 2:2  (slice1; segments: 2)  (cost=0.00..2.62 rows=1 width=4)
-                                   ->  Seq Scan on gpexp_hash  (cost=0.00..2.62 rows=1 width=4)
+   ->  Seq Scan on gpexp_rand  (cost=0.00..133.75 rows=25 width=14)
+         SubPlan 1  (slice0; segments: 2)
+           ->  Result  (cost=0.00..2.63 rows=1 width=4)
+                 Filter: (gpexp_rand.a = gpexp_hash.a)
+                 ->  Materialize  (cost=0.00..2.63 rows=1 width=4)
+                       ->  Broadcast Motion 2:2  (slice1; segments: 2)  (cost=0.00..2.62 rows=1 width=4)
+                             ->  Seq Scan on gpexp_hash  (cost=0.00..2.62 rows=1 width=4)
  Optimizer: Postgres query optimizer
-(10 rows)
+(9 rows)
 
 update gpexp_rand set b=(select b from gpexp_hash where gpexp_rand.a = gpexp_hash.a);
 select b, count(*) from gpexp_rand group by b order by b;