Correct error in rewriter that caused SELECT count(*) FROM view

to give wrong results: it should be looking at inJoinSet not inFromCl.
Also, make 'modified' flag be local to ApplyRetrieveRule: we should
append a rule's quals to the query iff that particular rule applies,
not if we have fired any previously-considered rule for the query!

diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index 714f08c26299ff040c4a8cc9361fb906cf66ec66..327d8c0aefee4a50c223796ecfe868db55282c5d 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.71 2000/04/12 17:15:32 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.72 2000/04/20 00:31:49 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -704,8 +704,7 @@ ApplyRetrieveRule(Query *parsetree,
                                  int rt_index,
                                  int relation_level,
                                  Relation relation,
-                                 bool relWasInJoinSet,
-                                 int *modified)
+                                 bool relWasInJoinSet)
 {
        Query      *rule_action = NULL;
        Node       *rule_qual;
@@ -714,6 +713,7 @@ ApplyRetrieveRule(Query *parsetree,
                           *l;
        int                     nothing,
                                rt_length;
+       int                     modified = false;
        int                     badsql = false;
 
        rule_qual = rule->qual;
@@ -809,18 +809,23 @@ ApplyRetrieveRule(Query *parsetree,
                parsetree = (Query *) apply_RIR_view((Node *) parsetree,
                                                                                         rt_index, rte,
                                                                                         rule_action->targetList,
-                                                                                        modified, 0);
+                                                                                        &modified, 0);
                rule_action = (Query *) apply_RIR_view((Node *) rule_action,
                                                                                           rt_index, rte,
                                                                                           rule_action->targetList,
-                                                                                          modified, 0);
+                                                                                          &modified, 0);
+               /* always apply quals of relation-level rules, whether we found a
+                * var to substitute or not.
+                */
+               modified = true;
        }
        else
        {
                HandleRIRAttributeRule(parsetree, rtable, rule_action->targetList,
-                                                          rt_index, rule->attrno, modified, &badsql);
+                                                          rt_index, rule->attrno, &modified, &badsql);
+               /* quals will be inserted only if we found uses of the attribute */
        }
-       if (*modified && !badsql)
+       if (modified && !badsql)
        {
                AddQual(parsetree, rule_action->qual);
                AddGroupClause(parsetree, rule_action->groupClause,
@@ -894,7 +899,6 @@ fireRIRrules(Query *parsetree)
        RewriteRule *rule;
        RewriteRule RIRonly;
        bool            relWasInJoinSet;
-       int                     modified = false;
        int                     i;
        List       *l;
 
@@ -910,18 +914,15 @@ fireRIRrules(Query *parsetree)
                rte = rt_fetch(rt_index, parsetree->rtable);
 
                /*
-                * If the table is not one named in the original FROM clause then
-                * it must be referenced in the query, or we ignore it. This
-                * prevents infinite expansion loop due to new rtable entries
-                * inserted by expansion of a rule.
+                * If the table is not referenced in the query, then we ignore it.
+                * This prevents infinite expansion loop due to new rtable entries
+                * inserted by expansion of a rule. A table is referenced if it is
+                * part of the join set (a source table), or is the result table,
+                * or is referenced by any Var nodes.
                 */
-               if (!rte->inFromCl && rt_index != parsetree->resultRelation &&
+               if (!rte->inJoinSet && rt_index != parsetree->resultRelation &&
                        !rangeTableEntry_used((Node *) parsetree, rt_index, 0))
-               {
-                       /* Make sure the planner ignores it too... */
-                       rte->inJoinSet = false;
                        continue;
-               }
 
                rel = heap_openr(rte->relname, AccessShareLock);
                rules = rel->rd_rules;
@@ -989,8 +990,7 @@ fireRIRrules(Query *parsetree)
                                                                                  rt_index,
                                                                                  RIRonly.attrno == -1,
                                                                                  rel,
-                                                                                 relWasInJoinSet,
-                                                                                 &modified);
+                                                                                 relWasInJoinSet);
                }
 
                heap_close(rel, AccessShareLock);