Fix behavior of stable functions called from a CALL's argument list.

If the CALL is within an atomic context (e.g. there's an outer
transaction block), _SPI_execute_plan should acquire a fresh snapshot
to execute any such functions with.  We failed to do that and instead
passed them the Portal snapshot, which had been acquired at the start
of the current SQL command.  This'd lead to seeing stale values of
rows modified since the start of the command.

This is arguably a bug in 84f5c2908: I failed to see that "are we in
non-atomic mode" needs to be defined the same way as it is further
down in _SPI_execute_plan, i.e. check !_SPI_current->atomic not just
options->allow_nonatomic.  Alternatively the blame could be laid on
plpgsql, which is unconditionally passing allow_nonatomic = true
for CALL/DO even when it knows it's in an atomic context.  However,
fixing it in spi.c seems like a better idea since that will also fix
the problem for any extensions that may have copied plpgsql's coding
pattern.

While here, update an obsolete comment about _SPI_execute_plan's
snapshot management.

Per report from Victor Yegorov.  Back-patch to all supported versions.

Discussion: https://postgr.es/m/CAGnEboiRe+fG2QxuBO2390F7P8e2MQ6UyBjZSL_w1Cej+E4=Vw@mail.gmail.com

diff --git a/src/backend/executor/spi.c b/src/backend/executor/spi.c
index d8a754050f08eab2c158b0c90344ff379cf5799b..59f77471432decda231a08b20fe2d22f831e4555 100644 (file)
--- a/src/backend/executor/spi.c
+++ b/src/backend/executor/spi.c
@@ -2209,12 +2209,18 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI,
    uint64      my_processed = 0;
    SPITupleTable *my_tuptable = NULL;
    int         res = 0;
-   bool        allow_nonatomic = plan->no_snapshots;   /* legacy API name */
+   bool        allow_nonatomic;
    bool        pushed_active_snap = false;
    ErrorContextCallback spierrcontext;
    CachedPlan *cplan = NULL;
    ListCell   *lc1;
 
+   /*
+    * We allow nonatomic behavior only if plan->no_snapshots is set
+    * *and* the SPI_OPT_NONATOMIC flag was given when connecting.
+    */
+   allow_nonatomic = plan->no_snapshots && !_SPI_current->atomic;
+
    /*
     * Setup error traceback support for ereport()
     */
@@ -2232,12 +2238,17 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI,
     * snapshot != InvalidSnapshot, read_only = false: use the given snapshot,
     * modified by advancing its command ID before each querytree.
     *
-    * snapshot == InvalidSnapshot, read_only = true: use the entry-time
-    * ActiveSnapshot, if any (if there isn't one, we run with no snapshot).
+    * snapshot == InvalidSnapshot, read_only = true: do nothing for queries
+    * that require no snapshot.  For those that do, ensure that a Portal
+    * snapshot exists; then use that, or use the entry-time ActiveSnapshot if
+    * that exists and is different.
     *
-    * snapshot == InvalidSnapshot, read_only = false: take a full new
-    * snapshot for each user command, and advance its command ID before each
-    * querytree within the command.
+    * snapshot == InvalidSnapshot, read_only = false: do nothing for queries
+    * that require no snapshot.  For those that do, ensure that a Portal
+    * snapshot exists; then, in atomic execution (!allow_nonatomic) take a
+    * full new snapshot for each user command, and advance its command ID
+    * before each querytree within the command.  In allow_nonatomic mode we
+    * just use the Portal snapshot unmodified.
     *
     * In the first two cases, we can just push the snap onto the stack once
     * for the whole plan list.
@@ -2247,7 +2258,8 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI,
     */
    if (snapshot != InvalidSnapshot)
    {
-       Assert(!allow_nonatomic);
+       /* this intentionally tests the plan field not the derived value */
+       Assert(!plan->no_snapshots);
        if (read_only)
        {
            PushActiveSnapshot(snapshot);
@@ -2435,14 +2447,13 @@ _SPI_execute_plan(SPIPlanPtr plan, ParamListInfo paramLI,
                ProcessUtilityContext context;
 
                /*
-                * If the SPI context is atomic, or we were not told to allow
-                * nonatomic operations, tell ProcessUtility this is an atomic
-                * execution context.
+                * If we're not allowing nonatomic operations, tell
+                * ProcessUtility this is an atomic execution context.
                 */
-               if (_SPI_current->atomic || !allow_nonatomic)
-                   context = PROCESS_UTILITY_QUERY;
-               else
+               if (allow_nonatomic)
                    context = PROCESS_UTILITY_QUERY_NONATOMIC;
+               else
+                   context = PROCESS_UTILITY_QUERY;
 
                ProcessUtility(stmt,
                               plansource->query_string,

diff --git a/src/pl/plpgsql/src/expected/plpgsql_call.out b/src/pl/plpgsql/src/expected/plpgsql_call.out
index 83d59731359a770e55f4617b6bcbdb5e38b813ed..f3527855c74482774414bc0aa82daa993bff452a 100644 (file)
--- a/src/pl/plpgsql/src/expected/plpgsql_call.out
+++ b/src/pl/plpgsql/src/expected/plpgsql_call.out
@@ -457,3 +457,53 @@ NOTICE:  inner_p(44)
  
 (1 row)
 
+-- Check that stable functions in CALL see the correct snapshot
+CREATE TABLE t_test (x int);
+INSERT INTO t_test VALUES (0);
+CREATE FUNCTION f_get_x () RETURNS int
+AS $$
+DECLARE l_result int;
+BEGIN
+  SELECT x INTO l_result FROM t_test;
+  RETURN l_result;
+END
+$$ LANGUAGE plpgsql STABLE;
+CREATE PROCEDURE f_print_x (x int)
+AS $$
+BEGIN
+  RAISE NOTICE 'f_print_x(%)', x;
+END
+$$ LANGUAGE plpgsql;
+-- test in non-atomic context
+DO $$
+BEGIN
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+  ROLLBACK;
+END
+$$;
+NOTICE:  f_get_x(1)
+NOTICE:  f_print_x(1)
+NOTICE:  f_get_x(2)
+NOTICE:  f_print_x(2)
+-- test in atomic context
+BEGIN;
+DO $$
+BEGIN
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+END
+$$;
+NOTICE:  f_get_x(1)
+NOTICE:  f_print_x(1)
+NOTICE:  f_get_x(2)
+NOTICE:  f_print_x(2)
+ROLLBACK;

diff --git a/src/pl/plpgsql/src/sql/plpgsql_call.sql b/src/pl/plpgsql/src/sql/plpgsql_call.sql
index 6825f59dbcae773f8015666a57bf150d9e5a6ebd..6d18896b8dd1104105d8cb4d1d0209a9e2ecdf3e 100644 (file)
--- a/src/pl/plpgsql/src/sql/plpgsql_call.sql
+++ b/src/pl/plpgsql/src/sql/plpgsql_call.sql
@@ -425,3 +425,53 @@ CREATE FUNCTION f(int) RETURNS int AS $$ SELECT $1 + 2 $$ LANGUAGE sql;
 
 CALL outer_p(42);
 SELECT outer_f(42);
+
+-- Check that stable functions in CALL see the correct snapshot
+
+CREATE TABLE t_test (x int);
+INSERT INTO t_test VALUES (0);
+
+CREATE FUNCTION f_get_x () RETURNS int
+AS $$
+DECLARE l_result int;
+BEGIN
+  SELECT x INTO l_result FROM t_test;
+  RETURN l_result;
+END
+$$ LANGUAGE plpgsql STABLE;
+
+CREATE PROCEDURE f_print_x (x int)
+AS $$
+BEGIN
+  RAISE NOTICE 'f_print_x(%)', x;
+END
+$$ LANGUAGE plpgsql;
+
+-- test in non-atomic context
+DO $$
+BEGIN
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+  ROLLBACK;
+END
+$$;
+
+-- test in atomic context
+BEGIN;
+
+DO $$
+BEGIN
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+  UPDATE t_test SET x = x + 1;
+  RAISE NOTICE 'f_get_x(%)', f_get_x();
+  CALL f_print_x(f_get_x());
+END
+$$;
+
+ROLLBACK;