For non-projecting plan node types such as Limit, set_plan_references

has to recopy the input plan node's targetlist if it removes a
SubqueryScan node just below the non-projecting node.  For simplicity
I made it recopy always.  Per bug report from Allan Wang and Michael Fuhr.

diff --git a/src/backend/optimizer/plan/setrefs.c b/src/backend/optimizer/plan/setrefs.c
index a07bae8b8421377dabea1ca5910de219e07e3a78..0cd41d6f1e69b6095da9500fc05afb2bc58b5295 100644 (file)
--- a/src/backend/optimizer/plan/setrefs.c
+++ b/src/backend/optimizer/plan/setrefs.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/optimizer/plan/setrefs.c,v 1.112 2005/08/27 18:04:49 tgl Exp $
+ *   $PostgreSQL: pgsql/src/backend/optimizer/plan/setrefs.c,v 1.113 2005/09/05 17:25:01 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -130,6 +130,7 @@ static void set_sa_opfuncid(ScalarArrayOpExpr *opexpr);
 Plan *
 set_plan_references(Plan *plan, List *rtable)
 {
+   bool        copy_lefttree_tlist = false;
    ListCell   *l;
 
    if (plan == NULL)
@@ -218,14 +219,13 @@ set_plan_references(Plan *plan, List *rtable)
 
            /*
             * These plan types don't actually bother to evaluate their
-            * targetlists (because they just return their unmodified
-            * input tuples).  The optimizer is lazy about creating really
-            * valid targetlists for them --- it tends to just put in a
-            * pointer to the child plan node's tlist.  Hence, we leave
-            * the tlist alone.  In particular, we do not want to process
-            * subplans in the tlist, since we will likely end up reprocessing
-            * subplans that also appear in lower levels of the plan tree!
-            *
+            * targetlists, because they just return their unmodified
+            * input tuples; so their targetlists should just be copies
+            * of their input plan nodes' targetlists.  The actual copying
+            * has to be done after we've finalized the input node.
+            */
+           copy_lefttree_tlist = true;
+           /*
             * Since these plan types don't check quals either, we should
             * not find any qual expression attached to them.
             */
@@ -238,6 +238,7 @@ set_plan_references(Plan *plan, List *rtable)
             * or quals.  It does have live expressions for limit/offset,
             * however.
             */
+           copy_lefttree_tlist = true;
            Assert(plan->qual == NIL);
            fix_expr_references(plan, ((Limit *) plan)->limitOffset);
            fix_expr_references(plan, ((Limit *) plan)->limitCount);
@@ -266,9 +267,10 @@ set_plan_references(Plan *plan, List *rtable)
 
            /*
             * Append, like Sort et al, doesn't actually evaluate its
-            * targetlist or check quals, and we haven't bothered to give it
-            * its own tlist copy. So, don't fix targetlist/qual. But do
-            * recurse into child plans.
+            * targetlist or check quals, so don't fix targetlist/qual.
+            * But do recurse into child plans.  (Unlike Sort et al, the
+            * correct tlist was made by createplan.c and we shouldn't
+            * replace it.)
             */
            Assert(plan->qual == NIL);
            foreach(l, ((Append *) plan)->appendplans)
@@ -315,6 +317,20 @@ set_plan_references(Plan *plan, List *rtable)
        sp->plan = set_plan_references(sp->plan, sp->rtable);
    }
 
+   /*
+    * If this is a non-projecting plan node, create a minimally valid
+    * targetlist for it.  Someday we might need to make this look really
+    * real, with Vars referencing the input node's outputs, but for now
+    * the executor only cares that the tlist has the right TargetEntry
+    * fields (resname, resjunk etc) and exprType results.  So we can
+    * get away with just copying the input node's tlist.  (Note:
+    * createplan.c already did copy the input, but we have to do it
+    * over in case we removed a SubqueryScan node: the new input plan
+    * node might have extra resjunk fields.)
+    */
+   if (copy_lefttree_tlist)
+       plan->targetlist = copyObject(plan->lefttree->targetlist);
+
    return plan;
 }