Address Copilot round 2: NULL-list guard, single() comment, pg_aggregate.h

1. Add NULL-list guard for all predicate functions (all/any/none/single).
   Wraps the result with CASE WHEN list IS NULL THEN NULL ELSE <result>
   END in the grammar layer.  This fixes single(x IN null WHERE ...)
   returning false instead of NULL.  The expr pointer is safely shared
   between the NullTest and the predicate function node because AGE's
   expression transformer creates new nodes without modifying the
   parse tree in-place.

2. Fix single() block comment in transform_cypher_predicate_function:
   described LIMIT 2 optimization but implementation uses plain
   count(*).  Updated comment to match actual implementation.

3. Keep #include "catalog/pg_aggregate.h" -- Copilot suggested removal
   but AGGKIND_NORMAL macro requires it (build fails without it).

Regression test: predicate_functions OK.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: gregfelice

regress/expected/predicate_functions.out

@@ -155,9 +155,9 @@ $$) AS (result agtype);
 (1 row)
 
 --
--- NULL list input: all/any/none return null, single returns false
--- (unnest of NULL produces zero rows; aggregates return NULL over
--- empty input, but count(*) returns 0)
+-- NULL list input: all four return null
+-- (NULL-list guard in the grammar produces CASE WHEN expr IS NULL
+-- THEN NULL ELSE <subquery> END)
 --
 SELECT * FROM cypher('predicate_functions', $$
     RETURN all(x IN null WHERE x > 0)
@@ -188,7 +188,7 @@ SELECT * FROM cypher('predicate_functions', $$
 $$) AS (result agtype);
  result 
 --------
- false
+ 
 (1 row)
 
 --
@@ -271,13 +271,13 @@ $$) AS (result agtype);
  false
 (1 row)
 
--- single() with null list: count(*) = 0, 0 = 1 -> false
+-- single() with null list: NULL (same as other predicate functions)
 SELECT * FROM cypher('predicate_functions', $$
     RETURN single(x IN null WHERE x > 0)
 $$) AS (result agtype);
  result 
 --------
- false
+ 
 (1 row)
 
 --

regress/sql/predicate_functions.sql

@@ -100,9 +100,9 @@ SELECT * FROM cypher('predicate_functions', $$
 $$) AS (result agtype);
 
 --
--- NULL list input: all/any/none return null, single returns false
--- (unnest of NULL produces zero rows; aggregates return NULL over
--- empty input, but count(*) returns 0)
+-- NULL list input: all four return null
+-- (NULL-list guard in the grammar produces CASE WHEN expr IS NULL
+-- THEN NULL ELSE <subquery> END)
 --
 SELECT * FROM cypher('predicate_functions', $$
     RETURN all(x IN null WHERE x > 0)
@@ -169,7 +169,7 @@ SELECT * FROM cypher('predicate_functions', $$
     RETURN single(x IN [null, 5] WHERE x > 0)
 $$) AS (result agtype);
 
--- single() with null list: count(*) = 0, 0 = 1 -> false
+-- single() with null list: NULL (same as other predicate functions)
 SELECT * FROM cypher('predicate_functions', $$
     RETURN single(x IN null WHERE x > 0)
 $$) AS (result agtype);

src/backend/parser/cypher_clause.c

@@ -1776,8 +1776,9 @@ static Node *make_predicate_case_expr(ParseState *pstate, Node *pred,
  * Transform a cypher_predicate_function node into a query tree.
  *
  * Generates aggregate-based queries that preserve Cypher's three-valued
- * NULL semantics.  The grammar layer adds a CASE WHEN list IS NULL
- * THEN NULL ELSE (subquery) END guard for the null-list case.
+ * NULL semantics.  The grammar layer wraps the SubLink with a
+ * CASE WHEN list IS NULL THEN NULL ELSE (subquery) END guard so all
+ * four functions return NULL when the input list is NULL.
  *
  * For all()/any()/none():
  *   SELECT CASE WHEN bool_or(pred IS TRUE/FALSE) THEN ...
@@ -1786,13 +1787,11 @@ static Node *make_predicate_case_expr(ParseState *pstate, Node *pred,
  *   FROM unnest(list) AS x
  *
  * For single():
- *   SELECT count(*) FROM (
- *     SELECT 1 FROM unnest(list) AS x WHERE pred IS TRUE LIMIT 2
- *   ) sub
+ *   SELECT count(*)
+ *   FROM unnest(list) AS x
+ *   WHERE pred IS TRUE
  *
  * All four use EXPR_SUBLINK so the subquery returns a scalar value.
- * The LIMIT 2 in single() enables early termination: once two matches
- * are found, evaluation stops and count(*) = 2 != 1.
  */
 static Query *transform_cypher_predicate_function(cypher_parsestate *cpstate,
                                                   cypher_clause *clause)

src/backend/parser/cypher_gram.y

@@ -3404,6 +3404,7 @@ static Node *build_predicate_function_node(cypher_predicate_function_kind kind,
 {
     SubLink *sub;
     cypher_predicate_function *pred_func = NULL;
+    Node *result;
 
     /* build the predicate function node */
     pred_func = make_ag_node(cypher_predicate_function);
@@ -3422,6 +3423,10 @@ static Node *build_predicate_function_node(cypher_predicate_function_kind kind,
      * All predicate functions now use EXPR_SUBLINK: the transform layer
      * generates aggregate-based queries that return a scalar boolean
      * (for all/any/none) or integer (for single).
+     *
+     * The transform layer also wraps the result with a NULL-list guard
+     * (CASE WHEN list IS NULL THEN NULL ELSE <result> END) to ensure
+     * all four functions return NULL when the input list is NULL.
      */
     sub = makeNode(SubLink);
     sub->subLinkId = 0;
@@ -3443,15 +3448,50 @@ static Node *build_predicate_function_node(cypher_predicate_function_kind kind,
                                             (Node *) sub,
                                             make_int_const(1, location),
                                             location);
-        return (Node *) node_to_agtype(eq_expr, "boolean", location);
+        result = (Node *) node_to_agtype(eq_expr, "boolean", location);
     }
     else
     {
         /*
          * all()/any()/none(): the subquery returns a boolean directly
          * from the CASE+bool_or() aggregate expression.
          */
-        return (Node *) node_to_agtype((Node *) sub, "boolean", location);
+        result = (Node *) node_to_agtype((Node *) sub, "boolean", location);
+    }
+
+    /*
+     * NULL-list guard: CASE WHEN expr IS NULL THEN NULL ELSE result END
+     *
+     * Without this, unnest(NULL) produces zero rows, causing all/any/none
+     * to accidentally return NULL (via bool_or over empty input) and
+     * single to return false (count(*) = 0).  Cypher semantics require
+     * all four to return NULL when the input list is NULL.
+     *
+     * The expr pointer is shared with pred_func->expr.  This is safe
+     * because AGE's expression transformer (transform_cypher_expr_recurse)
+     * creates new nodes rather than modifying the parse tree in-place,
+     * so the two references are transformed independently.
+     */
+    {
+        NullTest *null_test = makeNode(NullTest);
+        CaseWhen *case_when = makeNode(CaseWhen);
+        CaseExpr *guard = makeNode(CaseExpr);
+
+        null_test->arg = (Expr *) expr;
+        null_test->nulltesttype = IS_NULL;
+        null_test->argisrow = false;
+        null_test->location = location;
+
+        case_when->expr = (Expr *) null_test;
+        case_when->result = (Expr *) make_null_const(location);
+        case_when->location = location;
+
+        guard->arg = NULL;
+        guard->args = list_make1(case_when);
+        guard->defresult = (Expr *) result;
+        guard->location = location;
+
+        return (Node *) guard;
     }
 }