Revert ill-starred change of 13-Feb-02: it appeared to fix a problem of

incorrect permissions checking, but in fact disabled most all permissions
checks for view updates.  This corrects problems reported by Sergey
Yatskevich among others, at the cost of re-introducing the problem
previously reported by Tim Burgess.  However, since we'd lived with that
problem for quite awhile without knowing it, we can live with it awhile
longer until a proper fix can be made in 7.5.

diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index 4b4ad40a16ecfe96fb9d3adf06cf3c1738bb064e..3f69110a36a8d8093c12938449769dced2461ce5 100644 (file)
--- a/src/backend/rewrite/rewriteHandler.c
+++ b/src/backend/rewrite/rewriteHandler.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/rewrite/rewriteHandler.c,v 1.131 2003/11/29 19:51:55 pgsql Exp $
+ *   $PostgreSQL: pgsql/src/backend/rewrite/rewriteHandler.c,v 1.132 2004/01/14 03:39:22 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -70,11 +70,9 @@ rewriteRuleAction(Query *parsetree,
 {
    int         current_varno,
                new_varno;
-   List       *main_rtable;
    int         rt_length;
    Query      *sub_action;
    Query     **sub_action_ptr;
-   List       *rt;
 
    /*
     * Make modifiable copies of rule action and qual (what we're passed
@@ -109,32 +107,32 @@ rewriteRuleAction(Query *parsetree,
     * 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 remove them 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.
+    * rewriting, but we leave them all in place for two reasons:
+    *
+    *      * We'd have a much harder job to adjust the query's varnos
+    *        if we selectively removed RT entries.
+    *
+    *      * If the rule is INSTEAD, then the original query won't be
+    *        executed at all, and so its rtable must be preserved so that
+    *        the executor will do the correct permissions checks on it.
+    *
+    * RT entries that are not referenced in the completed jointree will be
+    * ignored by the planner, so they do not affect query semantics.  But
+    * any permissions checks specified in them will be applied during
+    * executor startup (see ExecCheckRTEPerms()).  This allows us to check
+    * that the caller has, say, insert-permission on a view, when the view
+    * is not semantically referenced at all in the resulting query.
+    *
+    * When a rule is not INSTEAD, the permissions checks done on its copied
+    * RT entries will be redundant with those done during execution of the
+    * original query, but we don't bother to treat that case differently.
     *
     * 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.
-    *
-    * Also, we must disable write-access checking in all the RT entries
-    * copied from the main query.  This is safe since in fact the rule
-    * action won't write on them, and it's necessary because the rule
-    * action may have a different commandType than the main query,
-    * causing ExecCheckRTEPerms() to make an inappropriate check.  The
-    * read-access checks can be left enabled, although they're probably
-    * redundant.
     */
-   main_rtable = (List *) copyObject(parsetree->rtable);
-
-   foreach(rt, main_rtable)
-   {
-       RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
-
-       rte->checkForWrite = false;
-   }
-
-   sub_action->rtable = nconc(main_rtable, sub_action->rtable);
+   sub_action->rtable = nconc((List *) copyObject(parsetree->rtable),
+                              sub_action->rtable);
 
    /*
     * Each rule action's jointree should be the main parsetree's jointree