Fix AcquireRewriteLocks to be sure that it acquires the right lock strength

when FOR UPDATE is propagated down into a sub-select expanded from a view.
Similar bug to parser's isLockedRel issue that I fixed yesterday; likewise
seems not quite worth the effort to back-patch.

diff --git a/src/backend/rewrite/rewriteHandler.c b/src/backend/rewrite/rewriteHandler.c
index 8f5b3002278d1b36ec89b7444ec1d59666582e51..59205f4d5510e56ff75155a893613a6ab985bc6b 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.190 2009/10/28 14:55:43 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/rewrite/rewriteHandler.c,v 1.191 2009/10/28 17:36:50 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -55,7 +55,8 @@ static void markQueryForLocking(Query *qry, Node *jtnode,
                                        bool forUpdate, bool noWait, bool pushedDown);
 static List *matchLocks(CmdType event, RuleLock *rulelocks,
                   int varno, Query *parsetree);
-static Query *fireRIRrules(Query *parsetree, List *activeRIRs);
+static Query *fireRIRrules(Query *parsetree, List *activeRIRs,
+                                                  bool forUpdatePushedDown);
 
 
 /*
@@ -64,6 +65,10 @@ static Query *fireRIRrules(Query *parsetree, List *activeRIRs);
  *       These locks will ensure that the relation schemas don't change under us
  *       while we are rewriting and planning the query.
  *
+ * forUpdatePushedDown indicates that a pushed-down FOR UPDATE/SHARE applies
+ * to the current subquery, requiring all rels to be opened with RowShareLock.
+ * This should always be false at the start of the recursion.
+ *
  * A secondary purpose of this routine is to fix up JOIN RTE references to
  * dropped columns (see details below).  Because the RTEs are modified in
  * place, it is generally appropriate for the caller of this routine to have
@@ -91,7 +96,7 @@ static Query *fireRIRrules(Query *parsetree, List *activeRIRs);
  * construction of a nested join was O(N^2) in the nesting depth.)
  */
 void
-AcquireRewriteLocks(Query *parsetree)
+AcquireRewriteLocks(Query *parsetree, bool forUpdatePushedDown)
 {
        ListCell   *l;
        int                     rt_index;
@@ -129,7 +134,8 @@ AcquireRewriteLocks(Query *parsetree)
                                 */
                                if (rt_index == parsetree->resultRelation)
                                        lockmode = RowExclusiveLock;
-                               else if (get_parse_rowmark(parsetree, rt_index) != NULL)
+                               else if (forUpdatePushedDown ||
+                                                get_parse_rowmark(parsetree, rt_index) != NULL)
                                        lockmode = RowShareLock;
                                else
                                        lockmode = AccessShareLock;
@@ -206,7 +212,9 @@ AcquireRewriteLocks(Query *parsetree)
                                 * The subquery RTE itself is all right, but we have to
                                 * recurse to process the represented subquery.
                                 */
-                               AcquireRewriteLocks(rte->subquery);
+                               AcquireRewriteLocks(rte->subquery,
+                                                                       (forUpdatePushedDown ||
+                                                                        get_parse_rowmark(parsetree, rt_index) != NULL));
                                break;
 
                        default:
@@ -220,7 +228,7 @@ AcquireRewriteLocks(Query *parsetree)
        {
                CommonTableExpr *cte = (CommonTableExpr *) lfirst(l);
 
-               AcquireRewriteLocks((Query *) cte->ctequery);
+               AcquireRewriteLocks((Query *) cte->ctequery, false);
        }
 
        /*
@@ -245,7 +253,7 @@ acquireLocksOnSubLinks(Node *node, void *context)
                SubLink    *sub = (SubLink *) node;
 
                /* Do what we came for */
-               AcquireRewriteLocks((Query *) sub->subselect);
+               AcquireRewriteLocks((Query *) sub->subselect, false);
                /* Fall through to process lefthand args of SubLink */
        }
 
@@ -298,7 +306,7 @@ rewriteRuleAction(Query *parsetree,
        /*
         * Acquire necessary locks and fix any deleted JOIN RTE entries.
         */
-       AcquireRewriteLocks(rule_action);
+       AcquireRewriteLocks(rule_action, false);
        (void) acquireLocksOnSubLinks(rule_qual, NULL);
 
        current_varno = rt_index;
@@ -1134,7 +1142,8 @@ ApplyRetrieveRule(Query *parsetree,
                                  int rt_index,
                                  bool relation_level,
                                  Relation relation,
-                                 List *activeRIRs)
+                                 List *activeRIRs,
+                                 bool forUpdatePushedDown)
 {
        Query      *rule_action;
        RangeTblEntry *rte,
@@ -1148,18 +1157,25 @@ ApplyRetrieveRule(Query *parsetree,
        if (!relation_level)
                elog(ERROR, "cannot handle per-attribute ON SELECT rule");
 
+       /*
+        * If FOR UPDATE/SHARE of view, be sure we get right initial lock on the
+        * relations it references.
+        */
+       rc = get_parse_rowmark(parsetree, rt_index);
+       forUpdatePushedDown |= (rc != NULL);
+
        /*
         * Make a modifiable copy of the view query, and acquire needed locks on
         * the relations it mentions.
         */
        rule_action = copyObject(linitial(rule->actions));
 
-       AcquireRewriteLocks(rule_action);
+       AcquireRewriteLocks(rule_action, forUpdatePushedDown);
 
        /*
         * Recursively expand any view references inside the view.
         */
-       rule_action = fireRIRrules(rule_action, activeRIRs);
+       rule_action = fireRIRrules(rule_action, activeRIRs, forUpdatePushedDown);
 
        /*
         * VIEWs are really easy --- just plug the view query in as a subselect,
@@ -1192,8 +1208,11 @@ ApplyRetrieveRule(Query *parsetree,
         * If FOR UPDATE/SHARE of view, mark all the contained tables as
         * implicit FOR UPDATE/SHARE, the same as the parser would have done
         * if the view's subquery had been written out explicitly.
+        *
+        * Note: we don't consider forUpdatePushedDown here; such marks will be
+        * made by recursing from the upper level in markQueryForLocking.
         */
-       if ((rc = get_parse_rowmark(parsetree, rt_index)) != NULL)
+       if (rc != NULL)
                markQueryForLocking(rule_action, (Node *) rule_action->jointree,
                                                        rc->forUpdate, rc->noWait, true);
 
@@ -1281,7 +1300,7 @@ fireRIRonSubLink(Node *node, List *activeRIRs)
 
                /* Do what we came for */
                sub->subselect = (Node *) fireRIRrules((Query *) sub->subselect,
-                                                                                          activeRIRs);
+                                                                                          activeRIRs, false);
                /* Fall through to process lefthand args of SubLink */
        }
 
@@ -1299,7 +1318,7 @@ fireRIRonSubLink(Node *node, List *activeRIRs)
  *     Apply all RIR rules on each rangetable entry in a query
  */
 static Query *
-fireRIRrules(Query *parsetree, List *activeRIRs)
+fireRIRrules(Query *parsetree, List *activeRIRs, bool forUpdatePushedDown)
 {
        int                     rt_index;
        ListCell   *lc;
@@ -1329,7 +1348,9 @@ fireRIRrules(Query *parsetree, List *activeRIRs)
                 */
                if (rte->rtekind == RTE_SUBQUERY)
                {
-                       rte->subquery = fireRIRrules(rte->subquery, activeRIRs);
+                       rte->subquery = fireRIRrules(rte->subquery, activeRIRs,
+                                                                                (forUpdatePushedDown ||
+                                                                                 get_parse_rowmark(parsetree, rt_index) != NULL));
                        continue;
                }
 
@@ -1406,7 +1427,8 @@ fireRIRrules(Query *parsetree, List *activeRIRs)
                                                                                          rt_index,
                                                                                          rule->attrno == -1,
                                                                                          rel,
-                                                                                         activeRIRs);
+                                                                                         activeRIRs,
+                                                                                         forUpdatePushedDown);
                        }
 
                        activeRIRs = list_delete_first(activeRIRs);
@@ -1421,7 +1443,7 @@ fireRIRrules(Query *parsetree, List *activeRIRs)
                CommonTableExpr *cte = (CommonTableExpr *) lfirst(lc);
 
                cte->ctequery = (Node *)
-                       fireRIRrules((Query *) cte->ctequery, activeRIRs);
+                       fireRIRrules((Query *) cte->ctequery, activeRIRs, false);
        }
 
        /*
@@ -1850,7 +1872,7 @@ QueryRewrite(Query *parsetree)
        {
                Query      *query = (Query *) lfirst(l);
 
-               query = fireRIRrules(query, NIL);
+               query = fireRIRrules(query, NIL, false);
 
                /*
                 * If the query target was rewritten as a view, complain.

diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c
index 85e52293e76b8f8aa1bc799cc7740f27a338f82a..99dfd88ba5203b700c433228fae6bf199988020f 100644 (file)
--- a/src/backend/utils/adt/ruleutils.c
+++ b/src/backend/utils/adt/ruleutils.c
@@ -9,7 +9,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.311 2009/10/28 14:55:44 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.312 2009/10/28 17:36:50 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -2175,7 +2175,7 @@ make_ruledef(StringInfo buf, HeapTuple ruletup, TupleDesc rulettc,
                query = getInsertSelectQuery(query, NULL);
 
                /* Must acquire locks right away; see notes in get_query_def() */
-               AcquireRewriteLocks(query);
+               AcquireRewriteLocks(query, false);
 
                context.buf = buf;
                context.namespaces = list_make1(&dpns);
@@ -2320,7 +2320,7 @@ get_query_def(Query *query, StringInfo buf, List *parentnamespace,
         * consistent results.  Note we assume it's OK to scribble on the passed
         * querytree!
         */
-       AcquireRewriteLocks(query);
+       AcquireRewriteLocks(query, false);
 
        context.buf = buf;
        context.namespaces = lcons(&dpns, list_copy(parentnamespace));

diff --git a/src/include/rewrite/rewriteHandler.h b/src/include/rewrite/rewriteHandler.h
index 4caef86757862181d975d95754c950c7288fc60f..68e1ad8d6f292f1a9d5917120c430f9edc114812 100644 (file)
--- a/src/include/rewrite/rewriteHandler.h
+++ b/src/include/rewrite/rewriteHandler.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/rewrite/rewriteHandler.h,v 1.31 2009/01/01 17:24:01 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/rewrite/rewriteHandler.h,v 1.32 2009/10/28 17:36:50 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -18,7 +18,7 @@
 #include "nodes/parsenodes.h"
 
 extern List *QueryRewrite(Query *parsetree);
-extern void AcquireRewriteLocks(Query *parsetree);
+extern void AcquireRewriteLocks(Query *parsetree, bool forUpdatePushedDown);
 extern Node *build_column_default(Relation rel, int attrno);
 
 #endif   /* REWRITEHANDLER_H */