Avoid trying to lock OLD/NEW in a rule with FOR UPDATE.

transformLockingClause neglected to exclude the pseudo-RTEs for
OLD/NEW when processing a rule's query.  This led to odd errors
or even crashes later on.  This bug is very ancient, but it's
not terribly surprising that nobody noticed, since the use-case
for SELECT FOR UPDATE in a non-view rule is somewhere between
thin and non-existent.  Still, crashing is not OK.

Per bug #17151 from Zhiyong Wu.  Thanks to Masahiko Sawada
for analysis of the problem.

Discussion: https://postgr.es/m/17151-c03a3e6e4ec9aadb@postgresql.org

diff --git a/src/backend/parser/analyze.c b/src/backend/parser/analyze.c
index 438b077004d681af1bf8fe3c3bbce08abdcb0cb9..15669c82386a0f579fe694059e82eac98e3e57ef 100644 (file)
--- a/src/backend/parser/analyze.c
+++ b/src/backend/parser/analyze.c
@@ -3170,13 +3170,22 @@ transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
 
        if (lockedRels == NIL)
        {
-               /* all regular tables used in query */
+               /*
+                * Lock all regular tables used in query and its subqueries.  We
+                * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
+                * in rules.  This is a bit of an abuse of a mostly-obsolete flag, but
+                * it's convenient.  We can't rely on the namespace mechanism that has
+                * largely replaced inFromCl, since for example we need to lock
+                * base-relation RTEs even if they are masked by upper joins.
+                */
                i = 0;
                foreach(rt, qry->rtable)
                {
                        RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
 
                        ++i;
+                       if (!rte->inFromCl)
+                               continue;
                        switch (rte->rtekind)
                        {
                                case RTE_RELATION:
@@ -3206,7 +3215,11 @@ transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
        }
        else
        {
-               /* just the named tables */
+               /*
+                * Lock just the named tables.  As above, we allow locking any base
+                * relation regardless of alias-visibility rules, so we need to
+                * examine inFromCl to exclude OLD/NEW.
+                */
                foreach(l, lockedRels)
                {
                        RangeVar   *thisrel = (RangeVar *) lfirst(l);
@@ -3227,6 +3240,8 @@ transformLockingClause(ParseState *pstate, Query *qry, LockingClause *lc,
                                RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
 
                                ++i;
+                               if (!rte->inFromCl)
+                                       continue;
                                if (strcmp(rte->eref->aliasname, thisrel->relname) == 0)
                                {
                                        switch (rte->rtekind)

diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index def9651b341c90d7b032d5a9bd36eda65b34276a..ca70f676800453851f243503187e4e92d7749b25 100644 (file)
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -929,10 +929,10 @@ typedef struct PartitionCmd
  *       inFromCl marks those range variables that are listed in the FROM clause.
  *       It's false for RTEs that are added to a query behind the scenes, such
  *       as the NEW and OLD variables for a rule, or the subqueries of a UNION.
- *       This flag is not used anymore during parsing, since the parser now uses
- *       a separate "namespace" data structure to control visibility, but it is
- *       needed by ruleutils.c to determine whether RTEs should be shown in
- *       decompiled queries.
+ *       This flag is not used during parsing (except in transformLockingClause,
+ *       q.v.); the parser now uses a separate "namespace" data structure to
+ *       control visibility.  But it is needed by ruleutils.c to determine
+ *       whether RTEs should be shown in decompiled queries.
  *
  *       requiredPerms and checkAsUser specify run-time access permissions
  *       checks to be performed at query startup.  The user must have *all*

diff --git a/src/test/regress/expected/rules.out b/src/test/regress/expected/rules.out
index e5ab11275d99a6af317fac2806d2cc5985d90507..2fa00a3c29a584e50341019977cffc45b737b4ed 100644 (file)
--- a/src/test/regress/expected/rules.out
+++ b/src/test/regress/expected/rules.out
@@ -3026,6 +3026,31 @@ select * from only t1_2;
 (10 rows)
 
 reset constraint_exclusion;
+-- test FOR UPDATE in rules
+create table rules_base(f1 int, f2 int);
+insert into rules_base values(1,2), (11,12);
+create rule r1 as on update to rules_base do instead
+  select * from rules_base where f1 = 1 for update;
+update rules_base set f2 = f2 + 1;
+ f1 | f2 
+----+----
+  1 |  2
+(1 row)
+
+create or replace rule r1 as on update to rules_base do instead
+  select * from rules_base where f1 = 11 for update of rules_base;
+update rules_base set f2 = f2 + 1;
+ f1 | f2 
+----+----
+ 11 | 12
+(1 row)
+
+create or replace rule r1 as on update to rules_base do instead
+  select * from rules_base where f1 = 11 for update of old; -- error
+ERROR:  relation "old" in FOR UPDATE clause not found in FROM clause
+LINE 2:   select * from rules_base where f1 = 11 for update of old;
+                                                               ^
+drop table rules_base;
 -- test various flavors of pg_get_viewdef()
 select pg_get_viewdef('shoe'::regclass) as unpretty;
                     unpretty                    

diff --git a/src/test/regress/sql/rules.sql b/src/test/regress/sql/rules.sql
index 6ec37c4381102c07f02f9eebf5544b0a8f499990..b732833e63cf070f31f13ef79b79377a0e112ebf 100644 (file)
--- a/src/test/regress/sql/rules.sql
+++ b/src/test/regress/sql/rules.sql
@@ -992,6 +992,20 @@ select * from only t1_2;
 
 reset constraint_exclusion;
 
+-- test FOR UPDATE in rules
+
+create table rules_base(f1 int, f2 int);
+insert into rules_base values(1,2), (11,12);
+create rule r1 as on update to rules_base do instead
+  select * from rules_base where f1 = 1 for update;
+update rules_base set f2 = f2 + 1;
+create or replace rule r1 as on update to rules_base do instead
+  select * from rules_base where f1 = 11 for update of rules_base;
+update rules_base set f2 = f2 + 1;
+create or replace rule r1 as on update to rules_base do instead
+  select * from rules_base where f1 = 11 for update of old; -- error
+drop table rules_base;
+
 -- test various flavors of pg_get_viewdef()
 
 select pg_get_viewdef('shoe'::regclass) as unpretty;