Repair problem with multi-action rules in combination with any nontrivial

manipulation of rtable/jointree by planner.  Rewriter was generating
actions that shared rtable/jointree substructure, which caused havoc
when planner got to the later actions that it'd already mucked up.

diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index 2787b9ce553e9a51f72a59c4f2dac687d882632e..d78334d83d3cfa7f47997d0eb9a4686eefa8a84b 100644 (file)
--- a/src/backend/rewrite/rewriteHandler.c
+++ b/src/backend/rewrite/rewriteHandler.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.93 2001/05/03 17:47:49 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.94 2001/06/12 18:54:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -82,7 +82,7 @@ gatherRewriteMeta(Query *parsetree,
 
    /*
     * Adjust rule action and qual to offset its varnos, so that we can
-    * merge its rtable into the main parsetree's rtable.
+    * merge its rtable with the main parsetree's rtable.
     *
     * If the rule action is an INSERT...SELECT, the OLD/NEW rtable entries
     * will be in the SELECT part, and we have to modify that rather than
@@ -99,23 +99,19 @@ gatherRewriteMeta(Query *parsetree,
                   PRS2_OLD_VARNO + rt_length, rt_index, 0);
 
    /*
-    * We want the main parsetree's rtable to end up as the concatenation
-    * of its original contents plus those of all the relevant rule
-    * actions.  Also store same into all the rule_action rtables. Some of
-    * the entries may be unused after we finish rewriting, but if we
-    * tried to clean those out we'd have a much harder job to adjust RT
-    * indexes in the query's Vars.  It's OK to have unused RT entries,
-    * since planner will ignore them.
+    * Generate expanded rtable consisting of main parsetree's rtable
+    * plus rule action's rtable; this becomes the complete rtable for the
+    * rule action.  Some of the entries may be unused after we finish
+    * rewriting, but if we tried to clean those out we'd have a much harder
+    * job to adjust RT indexes in the query's Vars.  It's OK to have unused
+    * RT entries, since planner will ignore them.
     *
-    * NOTE KLUGY HACK: we assume the parsetree rtable had at least one entry
-    * to begin with (OK enough, else where'd the rule come from?).
-    * Because of this, if multiple rules nconc() their rtable additions
-    * onto parsetree->rtable, they'll all see the same rtable because
-    * they all have the same list head pointer.
+    * NOTE: because planner will destructively alter rtable, we must ensure
+    * that rule action's rtable is separate and shares no substructure with
+    * the main rtable.  Hence do a deep copy here.
     */
-   parsetree->rtable = nconc(parsetree->rtable,
-                             sub_action->rtable);
-   sub_action->rtable = parsetree->rtable;
+   sub_action->rtable = nconc((List *) copyObject(parsetree->rtable),
+                              sub_action->rtable);
 
    /*
     * Each rule action's jointree should be the main parsetree's jointree
@@ -128,6 +124,9 @@ gatherRewriteMeta(Query *parsetree,
     * data for the quals.  We don't want the original rtindex to be
     * joined twice, however, so avoid keeping it if the rule action
     * mentions it.
+    *
+    * As above, the action's jointree must not share substructure with
+    * the main parsetree's.
     */
    if (sub_action->jointree != NULL)
    {
@@ -193,13 +192,13 @@ gatherRewriteMeta(Query *parsetree,
  * occurrence of the given rt_index as a top-level join item (we do not look
  * for it within join items; this is OK because we are only expecting to find
  * it as an UPDATE or DELETE target relation, which will be at the top level
- * of the join).  Returns modified jointree list --- original list is not
- * changed.
+ * of the join).  Returns modified jointree list --- this is a separate copy
+ * sharing no nodes with the original.
  */
 static List *
 adjustJoinTreeList(Query *parsetree, bool removert, int rt_index)
 {
-   List       *newjointree = listCopy(parsetree->jointree->fromlist);
+   List       *newjointree = copyObject(parsetree->jointree->fromlist);
    List       *jjt;
 
    if (removert)