Make simpler-simple-expressions code cope with a Gather plan.

Commit 00418c612 expected that the plan generated for a simple-expression
query would always be a plain Result node.  However, if force_parallel_mode
is on, the planner might stick a Gather atop that.  Cope by looking through
the Gather.  For safety, assert that the Gather's tlist is trivial.

Per buildfarm.

Discussion: https://postgr.es/m/23425.1502822098@sss.pgh.pa.us

diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
index 4eb2dd284b7c8ecffe1580e465b27117714c37b0..616f5e30f8112d7d10624e34aae26be1a066227a 100644 (file)
--- a/src/pl/plpgsql/src/pl_exec.c
+++ b/src/pl/plpgsql/src/pl_exec.c
@@ -6553,7 +6553,7 @@ exec_save_simple_expr(PLpgSQL_expr *expr, CachedPlan *cplan)
 {
    PlannedStmt *stmt;
    Plan       *plan;
-   TargetEntry *tle;
+   Expr       *tle_expr;
 
    /*
     * Given the checks that exec_simple_check_plan did, none of the Asserts
@@ -6563,33 +6563,64 @@ exec_save_simple_expr(PLpgSQL_expr *expr, CachedPlan *cplan)
    /* Extract the single PlannedStmt */
    Assert(list_length(cplan->stmt_list) == 1);
    stmt = linitial_node(PlannedStmt, cplan->stmt_list);
-
-   /* Should be a trivial Result plan */
    Assert(stmt->commandType == CMD_SELECT);
+
+   /*
+    * Ordinarily, the plan node should be a simple Result.  However, if
+    * force_parallel_mode is on, the planner might've stuck a Gather node
+    * atop that.  The simplest way to deal with this is to look through the
+    * Gather node.  The Gather node's tlist would normally contain a Var
+    * referencing the child node's output ... but setrefs.c might also have
+    * copied a Const as-is.
+    */
    plan = stmt->planTree;
-   Assert(IsA(plan, Result));
-   Assert(plan->lefttree == NULL &&
-          plan->righttree == NULL &&
-          plan->initPlan == NULL &&
-          plan->qual == NULL &&
-          ((Result *) plan)->resconstantqual == NULL);
+   for (;;)
+   {
+       /* Extract the single tlist expression */
+       Assert(list_length(plan->targetlist) == 1);
+       tle_expr = castNode(TargetEntry, linitial(plan->targetlist))->expr;
 
-   /* Extract the single tlist expression */
-   Assert(list_length(plan->targetlist) == 1);
-   tle = (TargetEntry *) linitial(plan->targetlist);
+       if (IsA(plan, Result))
+       {
+           Assert(plan->lefttree == NULL &&
+                  plan->righttree == NULL &&
+                  plan->initPlan == NULL &&
+                  plan->qual == NULL &&
+                  ((Result *) plan)->resconstantqual == NULL);
+           break;
+       }
+       else if (IsA(plan, Gather))
+       {
+           Assert(plan->lefttree != NULL &&
+                  plan->righttree == NULL &&
+                  plan->initPlan == NULL &&
+                  plan->qual == NULL);
+           /* If setrefs.c copied up a Const, no need to look further */
+           if (IsA(tle_expr, Const))
+               break;
+           /* Otherwise, it better be an outer Var */
+           Assert(IsA(tle_expr, Var));
+           Assert(((Var *) tle_expr)->varno == OUTER_VAR);
+           /* Descend to the child node */
+           plan = plan->lefttree;
+       }
+       else
+           elog(ERROR, "unexpected plan node type: %d",
+                (int) nodeTag(plan));
+   }
 
    /*
     * Save the simple expression, and initialize state to "not valid in
     * current transaction".
     */
-   expr->expr_simple_expr = tle->expr;
+   expr->expr_simple_expr = tle_expr;
    expr->expr_simple_generation = cplan->generation;
    expr->expr_simple_state = NULL;
    expr->expr_simple_in_use = false;
    expr->expr_simple_lxid = InvalidLocalTransactionId;
    /* Also stash away the expression result type */
-   expr->expr_simple_type = exprType((Node *) tle->expr);
-   expr->expr_simple_typmod = exprTypmod((Node *) tle->expr);
+   expr->expr_simple_type = exprType((Node *) tle_expr);
+   expr->expr_simple_typmod = exprTypmod((Node *) tle_expr);
 }
 
 /*