From ee5a6ac59386a81e7bb1e3187645cd28d538d716 Mon Sep 17 00:00:00 2001
From: Tomas Vondra <tomas@vondra.me>
Date: Sun, 15 Nov 2026 21:03:11 +0100
Subject: [PATCH v1 01/11] Test SQL/JSON strictness during optimization

Check plans and SQL NULL results for JSON_VALUE, JSON_QUERY and
JSON_EXISTS during outer-join pull-up and STRICT SQL inlining.
Cover PASSING/default Vars, PlaceHolderVars and Params, plus
nonstrict context and path expressions.

A NULL value of a PASSING argument does not force a NULL result, and
neither does a NULL in the DEFAULT expression of ON EMPTY or ON ERROR.
The planner currently treats the JsonExpr as strict, as long as all
functions in it are strict, which produces wrong results.

Add tests for subquery pull-up from the nullable side of an outer join,
for a range of different cases:

* DEFAULT with a LATERAL subquery, as DEFAULT can only reference
  columns of an outer query level

* inlining of STRICT SQL functions, using DEFAULT with ON EMPTY for
  JSON_VALUE() and with ON ERROR for JSON_QUERY() (JSON_EXISTS() has no
  DEFAULT value)

The tests check both the plans and the results. The expected output
records the correct results, so the tests fail until fixed by the
following commit.
---
 .../regress/expected/sqljson_queryfuncs.out   | 263 ++++++++++++++++++
 src/test/regress/sql/sqljson_queryfuncs.sql   | 138 +++++++++
 2 files changed, 401 insertions(+)

diff --git a/src/test/regress/expected/sqljson_queryfuncs.out b/src/test/regress/expected/sqljson_queryfuncs.out
index 19db825c8ab..af2f6683868 100644
--- a/src/test/regress/expected/sqljson_queryfuncs.out
+++ b/src/test/regress/expected/sqljson_queryfuncs.out
@@ -1842,3 +1842,266 @@ SELECT JSON_VALUE(x, '$' RETURNING jsonb) FROM (VALUES ('1'::jsonb), (NULL), ('2
  2
 (3 rows)
 
+-- Non-strict context and path expressions need null-extension protection.
+SELECT a.x, b.context_expr, b.path_expr
+FROM (VALUES (0), (1)) AS a(x)
+LEFT JOIN (
+  SELECT v.x,
+         JSON_VALUE(COALESCE(v.js, '0'::jsonb), '$' RETURNING int) AS context_expr,
+         JSON_VALUE('0'::jsonb, COALESCE(v.p, '$'::jsonpath)
+                    RETURNING int) AS path_expr
+  FROM (VALUES (0, '0'::jsonb, '$'::jsonpath), (2, '2', '$')) AS v(x, js, p)
+) AS b ON a.x = b.x
+ORDER BY a.x;
+ x | context_expr | path_expr 
+---+--------------+-----------
+ 0 |            0 |         0
+ 1 |              |          
+(2 rows)
+
+-- A constant-valued PlaceHolderVar in PASSING still counts as a nullable
+-- input; inspecting only its expression would miss null-extension.
+SELECT a.x, b.j
+FROM (VALUES (0), (1)) AS a(x)
+LEFT JOIN (
+  SELECT v.x, JSON_VALUE('0'::jsonb, '$' PASSING p.k AS p RETURNING int) AS j
+  FROM (VALUES (0), (2)) AS v(x)
+  LEFT JOIN (SELECT x, 1 AS k FROM (VALUES (0), (2)) AS w(x)) AS p USING (x)
+) AS b ON a.x = b.x
+ORDER BY a.x;
+ x | j 
+---+---
+ 0 | 0
+ 1 |  
+(2 rows)
+
+-- A NULL PASSING argument or DEFAULT expression doesn't force a NULL result,
+-- so the planner must not consider them strict.  When a subquery is pulled up
+-- from the nullable side of an outer join, its output expressions must be
+-- evaluated below the join.
+-- pull-up with a PASSING argument: JSON_VALUE() is computed below the join
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_VALUE(jsonb '1', '$' PASSING y AS v RETURNING int) AS jv
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+                                                              QUERY PLAN                                                               
+---------------------------------------------------------------------------------------------------------------------------------------
+ Merge Left Join
+   Output: "*VALUES*".column1, "*VALUES*_1".column1, (JSON_VALUE('1'::jsonb, '$' PASSING "*VALUES*_1".column1 AS v RETURNING integer))
+   Merge Cond: ("*VALUES*".column1 = "*VALUES*_1".column1)
+   ->  Sort
+         Output: "*VALUES*".column1
+         Sort Key: "*VALUES*".column1
+         ->  Values Scan on "*VALUES*"
+               Output: "*VALUES*".column1
+   ->  Sort
+         Output: "*VALUES*_1".column1, (JSON_VALUE('1'::jsonb, '$' PASSING "*VALUES*_1".column1 AS v RETURNING integer))
+         Sort Key: "*VALUES*_1".column1
+         ->  Values Scan on "*VALUES*_1"
+               Output: "*VALUES*_1".column1, JSON_VALUE('1'::jsonb, '$' PASSING "*VALUES*_1".column1 AS v RETURNING integer)
+(13 rows)
+
+-- so jv is NULL for the unmatched x = 1
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_VALUE(jsonb '1', '$' PASSING y AS v RETURNING int) AS jv
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+ x | y | jv 
+---+---+----
+ 1 |   |   
+ 2 | 2 |  1
+(2 rows)
+
+-- JSON_QUERY() and JSON_EXISTS() with PASSING are computed below the join too
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jq, je
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_QUERY(jsonb '[1]', '$' PASSING y AS v) AS jq,
+                       JSON_EXISTS(jsonb '2', '$ ? (@ == $v)' PASSING y AS v) AS je
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+                                                                                                                   QUERY PLAN                                                                                                                    
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Merge Left Join
+   Output: "*VALUES*".column1, "*VALUES*_1".column1, (JSON_QUERY('[1]'::jsonb, '$' PASSING "*VALUES*_1".column1 AS v RETURNING jsonb WITHOUT WRAPPER KEEP QUOTES)), (JSON_EXISTS('2'::jsonb, '$?(@ == $"v")' PASSING "*VALUES*_1".column1 AS v))
+   Merge Cond: ("*VALUES*".column1 = "*VALUES*_1".column1)
+   ->  Sort
+         Output: "*VALUES*".column1
+         Sort Key: "*VALUES*".column1
+         ->  Values Scan on "*VALUES*"
+               Output: "*VALUES*".column1
+   ->  Sort
+         Output: "*VALUES*_1".column1, (JSON_QUERY('[1]'::jsonb, '$' PASSING "*VALUES*_1".column1 AS v RETURNING jsonb WITHOUT WRAPPER KEEP QUOTES)), (JSON_EXISTS('2'::jsonb, '$?(@ == $"v")' PASSING "*VALUES*_1".column1 AS v))
+         Sort Key: "*VALUES*_1".column1
+         ->  Values Scan on "*VALUES*_1"
+               Output: "*VALUES*_1".column1, JSON_QUERY('[1]'::jsonb, '$' PASSING "*VALUES*_1".column1 AS v RETURNING jsonb WITHOUT WRAPPER KEEP QUOTES), JSON_EXISTS('2'::jsonb, '$?(@ == $"v")' PASSING "*VALUES*_1".column1 AS v)
+(13 rows)
+
+-- so jq and je are NULL for the unmatched x = 1
+SELECT x, y, jq, je
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_QUERY(jsonb '[1]', '$' PASSING y AS v) AS jq,
+                       JSON_EXISTS(jsonb '2', '$ ? (@ == $v)' PASSING y AS v) AS je
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+ x | y | jq  | je 
+---+---+-----+----
+ 1 |   |     | 
+ 2 | 2 | [1] | t
+(2 rows)
+
+-- pull-up with a DEFAULT expression: JSON_VALUE() is computed below the join.
+-- DEFAULT can only reference outer-level columns, which become columns of the
+-- parent query once the inner subquery is pulled up.
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jv
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_VALUE(jsonb '{"a": 1}', '$.a' RETURNING int
+                                                DEFAULT y + 0 ON EMPTY) AS jv) s) ss
+     ON x = y
+ORDER BY x;
+                                                                         QUERY PLAN                                                                         
+------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Merge Left Join
+   Output: "*VALUES*".column1, "*VALUES*_1".column1, (JSON_VALUE('{"a": 1}'::jsonb, '$."a"' RETURNING integer DEFAULT ("*VALUES*_1".column1 + 0) ON EMPTY))
+   Merge Cond: ("*VALUES*".column1 = "*VALUES*_1".column1)
+   ->  Sort
+         Output: "*VALUES*".column1
+         Sort Key: "*VALUES*".column1
+         ->  Values Scan on "*VALUES*"
+               Output: "*VALUES*".column1
+   ->  Sort
+         Output: "*VALUES*_1".column1, (JSON_VALUE('{"a": 1}'::jsonb, '$."a"' RETURNING integer DEFAULT ("*VALUES*_1".column1 + 0) ON EMPTY))
+         Sort Key: "*VALUES*_1".column1
+         ->  Values Scan on "*VALUES*_1"
+               Output: "*VALUES*_1".column1, JSON_VALUE('{"a": 1}'::jsonb, '$."a"' RETURNING integer DEFAULT ("*VALUES*_1".column1 + 0) ON EMPTY)
+(13 rows)
+
+-- so jv is NULL for the unmatched x = 1
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jv
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_VALUE(jsonb '{"a": 1}', '$.a' RETURNING int
+                                                DEFAULT y + 0 ON EMPTY) AS jv) s) ss
+     ON x = y
+ORDER BY x;
+ x | y | jv 
+---+---+----
+ 1 |   |   
+ 2 | 2 |  1
+(2 rows)
+
+-- JSON_QUERY() with DEFAULT ... ON ERROR is computed below the join too
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jq
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jq
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_QUERY(jsonb '{"a": [1]}', '$.a'
+                                                DEFAULT to_jsonb(y) ON ERROR) AS jq) s) ss
+     ON x = y
+ORDER BY x;
+                                                                                         QUERY PLAN                                                                                         
+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Merge Left Join
+   Output: "*VALUES*".column1, "*VALUES*_1".column1, (JSON_QUERY('{"a": [1]}'::jsonb, '$."a"' RETURNING jsonb WITHOUT WRAPPER KEEP QUOTES DEFAULT to_jsonb("*VALUES*_1".column1) ON ERROR))
+   Merge Cond: ("*VALUES*".column1 = "*VALUES*_1".column1)
+   ->  Sort
+         Output: "*VALUES*".column1
+         Sort Key: "*VALUES*".column1
+         ->  Values Scan on "*VALUES*"
+               Output: "*VALUES*".column1
+   ->  Sort
+         Output: "*VALUES*_1".column1, (JSON_QUERY('{"a": [1]}'::jsonb, '$."a"' RETURNING jsonb WITHOUT WRAPPER KEEP QUOTES DEFAULT to_jsonb("*VALUES*_1".column1) ON ERROR))
+         Sort Key: "*VALUES*_1".column1
+         ->  Values Scan on "*VALUES*_1"
+               Output: "*VALUES*_1".column1, JSON_QUERY('{"a": [1]}'::jsonb, '$."a"' RETURNING jsonb WITHOUT WRAPPER KEEP QUOTES DEFAULT to_jsonb("*VALUES*_1".column1) ON ERROR)
+(13 rows)
+
+-- so jq is NULL for the unmatched x = 1
+SELECT x, y, jq
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jq
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_QUERY(jsonb '{"a": [1]}', '$.a'
+                                                DEFAULT to_jsonb(y) ON ERROR) AS jq) s) ss
+     ON x = y
+ORDER BY x;
+ x | y | jq  
+---+---+-----
+ 1 |   | 
+ 2 | 2 | [1]
+(2 rows)
+
+-- STRICT SQL functions using arguments in PASSING or DEFAULT must not be
+-- inlined, as that would make them return non-NULL for NULL input
+CREATE FUNCTION queryfuncs_strict_passing(int) RETURNS int
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_VALUE(jsonb '1', '$' PASSING $1 AS v RETURNING int) $$;
+CREATE FUNCTION queryfuncs_strict_default(jsonb, int) RETURNS int
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_VALUE($1, '$.a' RETURNING int DEFAULT $2 + 0 ON EMPTY) $$;
+-- the plan shows the functions are not inlined
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, queryfuncs_strict_passing(x), queryfuncs_strict_default('{"a": 1}', x)
+FROM (VALUES (1), (NULL)) v(x);
+                                                                  QUERY PLAN                                                                   
+-----------------------------------------------------------------------------------------------------------------------------------------------
+ Values Scan on "*VALUES*"
+   Output: "*VALUES*".column1, queryfuncs_strict_passing("*VALUES*".column1), queryfuncs_strict_default('{"a": 1}'::jsonb, "*VALUES*".column1)
+(2 rows)
+
+-- so they are not called for NULL input, and the results are NULL
+SELECT x, queryfuncs_strict_passing(x), queryfuncs_strict_default('{"a": 1}', x)
+FROM (VALUES (1), (NULL)) v(x);
+ x | queryfuncs_strict_passing | queryfuncs_strict_default 
+---+---------------------------+---------------------------
+ 1 |                         1 |                         1
+   |                           |                          
+(2 rows)
+
+-- STRICT SQL functions using JSON_QUERY() and JSON_EXISTS() (with variable
+-- PASSING/default inputs) must not be inlined either.  The one calling
+-- to_jsonb() is STABLE, as IMMUTABLE functions with STABLE expressions are
+-- never inlined.
+CREATE FUNCTION queryfuncs_strict_passing_query(int) RETURNS jsonb
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_QUERY(jsonb '[1]', '$' PASSING $1 AS v) $$;
+CREATE FUNCTION queryfuncs_strict_passing_exists(int) RETURNS bool
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_EXISTS(jsonb '1', '$ ? (@ == $v)' PASSING $1 AS v) $$;
+CREATE FUNCTION queryfuncs_strict_default_query(jsonb, int) RETURNS jsonb
+  LANGUAGE sql STABLE STRICT
+  AS $$ SELECT JSON_QUERY($1, '$.a' DEFAULT to_jsonb($2) ON ERROR) $$;
+-- the plan shows the functions are not inlined
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, queryfuncs_strict_passing_query(x),
+       queryfuncs_strict_passing_exists(x),
+       queryfuncs_strict_default_query('{"a": [1]}', x)
+FROM (VALUES (1), (NULL)) v(x);
+                                                                                                    QUERY PLAN                                                                                                     
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Values Scan on "*VALUES*"
+   Output: "*VALUES*".column1, queryfuncs_strict_passing_query("*VALUES*".column1), queryfuncs_strict_passing_exists("*VALUES*".column1), queryfuncs_strict_default_query('{"a": [1]}'::jsonb, "*VALUES*".column1)
+(2 rows)
+
+-- so the results are NULL for NULL input
+SELECT x, queryfuncs_strict_passing_query(x),
+       queryfuncs_strict_passing_exists(x),
+       queryfuncs_strict_default_query('{"a": [1]}', x)
+FROM (VALUES (1), (NULL)) v(x);
+ x | queryfuncs_strict_passing_query | queryfuncs_strict_passing_exists | queryfuncs_strict_default_query 
+---+---------------------------------+----------------------------------+---------------------------------
+ 1 | [1]                             | t                                | [1]
+   |                                 |                                  | 
+(2 rows)
+
+DROP FUNCTION queryfuncs_strict_passing_query, queryfuncs_strict_passing_exists,
+  queryfuncs_strict_default_query;
+DROP FUNCTION queryfuncs_strict_passing, queryfuncs_strict_default;
diff --git a/src/test/regress/sql/sqljson_queryfuncs.sql b/src/test/regress/sql/sqljson_queryfuncs.sql
index 5c675d98235..cc1fae1b908 100644
--- a/src/test/regress/sql/sqljson_queryfuncs.sql
+++ b/src/test/regress/sql/sqljson_queryfuncs.sql
@@ -625,3 +625,141 @@ SELECT JSON_VALUE(x, '$' RETURNING json) FROM (VALUES ('1'::json), ('null'), ('2
 SELECT JSON_VALUE(x, '$.a' RETURNING jsonb) FROM (VALUES ('{"a": 1}'::jsonb), ('{}'), ('{"a": 2}')) v(x);
 SELECT JSON_VALUE(x, 'strict $.a' RETURNING jsonb) FROM (VALUES ('{"a": 1}'::jsonb), ('[]'), ('{"a": 2}')) v(x);
 SELECT JSON_VALUE(x, '$' RETURNING jsonb) FROM (VALUES ('1'::jsonb), (NULL), ('2')) v(x);
+
+-- Non-strict context and path expressions need null-extension protection.
+SELECT a.x, b.context_expr, b.path_expr
+FROM (VALUES (0), (1)) AS a(x)
+LEFT JOIN (
+  SELECT v.x,
+         JSON_VALUE(COALESCE(v.js, '0'::jsonb), '$' RETURNING int) AS context_expr,
+         JSON_VALUE('0'::jsonb, COALESCE(v.p, '$'::jsonpath)
+                    RETURNING int) AS path_expr
+  FROM (VALUES (0, '0'::jsonb, '$'::jsonpath), (2, '2', '$')) AS v(x, js, p)
+) AS b ON a.x = b.x
+ORDER BY a.x;
+
+-- A constant-valued PlaceHolderVar in PASSING still counts as a nullable
+-- input; inspecting only its expression would miss null-extension.
+SELECT a.x, b.j
+FROM (VALUES (0), (1)) AS a(x)
+LEFT JOIN (
+  SELECT v.x, JSON_VALUE('0'::jsonb, '$' PASSING p.k AS p RETURNING int) AS j
+  FROM (VALUES (0), (2)) AS v(x)
+  LEFT JOIN (SELECT x, 1 AS k FROM (VALUES (0), (2)) AS w(x)) AS p USING (x)
+) AS b ON a.x = b.x
+ORDER BY a.x;
+
+-- A NULL PASSING argument or DEFAULT expression doesn't force a NULL result,
+-- so the planner must not consider them strict.  When a subquery is pulled up
+-- from the nullable side of an outer join, its output expressions must be
+-- evaluated below the join.
+-- pull-up with a PASSING argument: JSON_VALUE() is computed below the join
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_VALUE(jsonb '1', '$' PASSING y AS v RETURNING int) AS jv
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+-- so jv is NULL for the unmatched x = 1
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_VALUE(jsonb '1', '$' PASSING y AS v RETURNING int) AS jv
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+-- JSON_QUERY() and JSON_EXISTS() with PASSING are computed below the join too
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jq, je
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_QUERY(jsonb '[1]', '$' PASSING y AS v) AS jq,
+                       JSON_EXISTS(jsonb '2', '$ ? (@ == $v)' PASSING y AS v) AS je
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+-- so jq and je are NULL for the unmatched x = 1
+SELECT x, y, jq, je
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, JSON_QUERY(jsonb '[1]', '$' PASSING y AS v) AS jq,
+                       JSON_EXISTS(jsonb '2', '$ ? (@ == $v)' PASSING y AS v) AS je
+                FROM (VALUES (2), (3)) b(y)) ss ON x = y
+ORDER BY x;
+-- pull-up with a DEFAULT expression: JSON_VALUE() is computed below the join.
+-- DEFAULT can only reference outer-level columns, which become columns of the
+-- parent query once the inner subquery is pulled up.
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jv
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_VALUE(jsonb '{"a": 1}', '$.a' RETURNING int
+                                                DEFAULT y + 0 ON EMPTY) AS jv) s) ss
+     ON x = y
+ORDER BY x;
+-- so jv is NULL for the unmatched x = 1
+SELECT x, y, jv
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jv
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_VALUE(jsonb '{"a": 1}', '$.a' RETURNING int
+                                                DEFAULT y + 0 ON EMPTY) AS jv) s) ss
+     ON x = y
+ORDER BY x;
+-- JSON_QUERY() with DEFAULT ... ON ERROR is computed below the join too
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, y, jq
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jq
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_QUERY(jsonb '{"a": [1]}', '$.a'
+                                                DEFAULT to_jsonb(y) ON ERROR) AS jq) s) ss
+     ON x = y
+ORDER BY x;
+-- so jq is NULL for the unmatched x = 1
+SELECT x, y, jq
+FROM (VALUES (1), (2)) a(x)
+     LEFT JOIN (SELECT y, jq
+                FROM (VALUES (2), (3)) b(y),
+                     LATERAL (SELECT JSON_QUERY(jsonb '{"a": [1]}', '$.a'
+                                                DEFAULT to_jsonb(y) ON ERROR) AS jq) s) ss
+     ON x = y
+ORDER BY x;
+-- STRICT SQL functions using arguments in PASSING or DEFAULT must not be
+-- inlined, as that would make them return non-NULL for NULL input
+CREATE FUNCTION queryfuncs_strict_passing(int) RETURNS int
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_VALUE(jsonb '1', '$' PASSING $1 AS v RETURNING int) $$;
+CREATE FUNCTION queryfuncs_strict_default(jsonb, int) RETURNS int
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_VALUE($1, '$.a' RETURNING int DEFAULT $2 + 0 ON EMPTY) $$;
+-- the plan shows the functions are not inlined
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, queryfuncs_strict_passing(x), queryfuncs_strict_default('{"a": 1}', x)
+FROM (VALUES (1), (NULL)) v(x);
+-- so they are not called for NULL input, and the results are NULL
+SELECT x, queryfuncs_strict_passing(x), queryfuncs_strict_default('{"a": 1}', x)
+FROM (VALUES (1), (NULL)) v(x);
+-- STRICT SQL functions using JSON_QUERY() and JSON_EXISTS() (with variable
+-- PASSING/default inputs) must not be inlined either.  The one calling
+-- to_jsonb() is STABLE, as IMMUTABLE functions with STABLE expressions are
+-- never inlined.
+CREATE FUNCTION queryfuncs_strict_passing_query(int) RETURNS jsonb
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_QUERY(jsonb '[1]', '$' PASSING $1 AS v) $$;
+CREATE FUNCTION queryfuncs_strict_passing_exists(int) RETURNS bool
+  LANGUAGE sql IMMUTABLE STRICT
+  AS $$ SELECT JSON_EXISTS(jsonb '1', '$ ? (@ == $v)' PASSING $1 AS v) $$;
+CREATE FUNCTION queryfuncs_strict_default_query(jsonb, int) RETURNS jsonb
+  LANGUAGE sql STABLE STRICT
+  AS $$ SELECT JSON_QUERY($1, '$.a' DEFAULT to_jsonb($2) ON ERROR) $$;
+-- the plan shows the functions are not inlined
+EXPLAIN (VERBOSE, COSTS OFF)
+SELECT x, queryfuncs_strict_passing_query(x),
+       queryfuncs_strict_passing_exists(x),
+       queryfuncs_strict_default_query('{"a": [1]}', x)
+FROM (VALUES (1), (NULL)) v(x);
+-- so the results are NULL for NULL input
+SELECT x, queryfuncs_strict_passing_query(x),
+       queryfuncs_strict_passing_exists(x),
+       queryfuncs_strict_default_query('{"a": [1]}', x)
+FROM (VALUES (1), (NULL)) v(x);
+DROP FUNCTION queryfuncs_strict_passing_query, queryfuncs_strict_passing_exists,
+  queryfuncs_strict_default_query;
+DROP FUNCTION queryfuncs_strict_passing, queryfuncs_strict_default;
-- 
2.56.0

