Optimize id()/start_id()/end_id() with direct column access

NOTE: This PR was created with AI tools and a human

Add optimization to avoid rebuilding full vertex/edge objects when only
the id, start_id, or end_id is needed. Instead of calling age_id() on
a reconstructed _agtype_build_vertex/_agtype_build_edge, directly access
the underlying graphid column and wrap it with graphid_to_agtype().

Implementation:
- Export hidden columns (_age_default_varname_id_*, _age_default_varname_
  start_id_*, _age_default_varname_end_id_*) when entities pass between
  clauses via export_entity_hidden_columns()
- Store Var references (id_var, start_id_var, end_id_var) in transform_entity
- try_optimize_id_funcs() checks for these optimizable patterns:
  - Cross-clause: Use stored Var from previous clause export
  - Current-clause: Extract graphid Var from entity's build expression
- Validate Var references to prevent stale references after WITH clauses

Optimized patterns:
  MATCH (p) RETURN id(p)              -- cross-clause in RETURN
  MATCH (p) WHERE id(p) > 0 RETURN p  -- current-clause in WHERE
  MATCH (p) MATCH (q) WHERE id(p) > 0 -- cross-clause in WHERE

Query plan improvement:
  Before: Filter: age_id(_agtype_build_vertex(p.id, _label_name(...), p.properties))
  After:  Filter: graphid_to_agtype(p.id)

All original regression tests passed.
Added additional regression tests.

Files changed:
- src/include/parser/cypher_transform_entity.h: Add id_var, start_id_var,
  end_id_var, props_var fields to transform_entity struct
- src/backend/parser/cypher_clause.c: Add export_entity_hidden_columns()
  and integrate with handle_prev_clause()
- src/backend/parser/cypher_expr.c: Add try_optimize_id_funcs(),
  extract_id_var_from_entity_expr(), find_entity_in_current_cpstate()
- regress/sql/cypher_match.sql: Add 13 WHERE optimization tests
- regress/sql/expr.sql: Add cross-clause optimization tests
- regress/expected/*.out: Update expected output

modified:   regress/expected/cypher_match.out
modified:   regress/expected/cypher_with.out
modified:   regress/sql/cypher_match.sql
modified:   regress/sql/cypher_with.sql
modified:   src/backend/parser/cypher_clause.c
modified:   src/backend/parser/cypher_expr.c
modified:   src/backend/parser/cypher_transform_entity.c
modified:   src/include/parser/cypher_transform_entity.h

Author: jrgemignani

regress/expected/cypher_match.out

@@ -3533,6 +3533,244 @@ SELECT * FROM cypher('test_enable_containment', $$ EXPLAIN (costs off) MATCH (x:
    Filter: ((agtype_access_operator(VARIADIC ARRAY[properties, '"school"'::agtype]) = '{"name": "XYZ College", "program": {"major": "Psyc", "degree": "BSc"}}'::agtype) AND (agtype_access_operator(VARIADIC ARRAY[properties, '"phone"'::agtype]) = '[123456789, 987654321, 456987123]'::agtype))
 (2 rows)
 
+--
+-- Test: WHERE clause id(), start_id(), end_id() optimizations in current clause
+-- These tests verify that id/start_id/end_id calls in WHERE clauses use direct
+-- column access (graphid_to_agtype) instead of rebuilding the full vertex/edge.
+--
+SELECT create_graph('test_where_opt');
+NOTICE:  graph "test_where_opt" has been created
+ create_graph 
+--------------
+ 
+(1 row)
+
+-- Create test data
+SELECT * FROM cypher('test_where_opt', $$
+    CREATE (:Person {name: 'Alice'})-[:KNOWS {since: 2020}]->(:Person {name: 'Bob'})
+$$) as (a agtype);
+ a 
+---
+(0 rows)
+
+-- Test 1: WHERE with id(vertex) in current clause - should use graphid_to_agtype
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)
+    WHERE id(p) > 0
+    RETURN p.name
+$$) as (name agtype);
+  name   
+---------
+ "Alice"
+ "Bob"
+(2 rows)
+
+-- Test 2: EXPLAIN to verify optimization (graphid_to_agtype instead of age_id)
+SELECT * FROM cypher('test_where_opt', $$
+    EXPLAIN (VERBOSE, COSTS OFF)
+    MATCH (p:Person)
+    WHERE id(p) > 0
+    RETURN p.name
+$$) as (plan agtype);
+                                                                  QUERY PLAN                                                                   
+-----------------------------------------------------------------------------------------------------------------------------------------------
+ Seq Scan on test_where_opt."Person" p
+   Output: agtype_access_operator(VARIADIC ARRAY[_agtype_build_vertex(p.id, _label_name('20334'::oid, p.id), p.properties), '"name"'::agtype])
+   Filter: (graphid_to_agtype(p.id) > '0'::agtype)
+(3 rows)
+
+-- Test 3: WHERE with id(edge) in current clause
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)-[e:KNOWS]->(q:Person)
+    WHERE id(e) > 0
+    RETURN p.name, q.name
+$$) as (name1 agtype, name2 agtype);
+  name1  | name2 
+---------+-------
+ "Alice" | "Bob"
+(1 row)
+
+-- Test 4: WHERE with start_id(edge) in current clause
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)-[e:KNOWS]->(q:Person)
+    WHERE start_id(e) > 0
+    RETURN p.name, q.name
+$$) as (name1 agtype, name2 agtype);
+  name1  | name2 
+---------+-------
+ "Alice" | "Bob"
+(1 row)
+
+-- Test 5: WHERE with end_id(edge) in current clause
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)-[e:KNOWS]->(q:Person)
+    WHERE end_id(e) > 0
+    RETURN p.name, q.name
+$$) as (name1 agtype, name2 agtype);
+  name1  | name2 
+---------+-------
+ "Alice" | "Bob"
+(1 row)
+
+-- Test 6: EXPLAIN to verify edge optimization (all three: id, start_id, end_id)
+SELECT * FROM cypher('test_where_opt', $$
+    EXPLAIN (VERBOSE, COSTS OFF)
+    MATCH (p:Person)-[e:KNOWS]->(q:Person)
+    WHERE id(e) > 0 AND start_id(e) > 0 AND end_id(e) > 0
+    RETURN p.name
+$$) as (plan agtype);
+                                                                                  QUERY PLAN                                                                                   
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ Hash Join
+   Output: agtype_access_operator(VARIADIC ARRAY[_agtype_build_vertex(p.id, _label_name('20334'::oid, p.id), p.properties), '"name"'::agtype])
+   Hash Cond: (q.id = e.end_id)
+   ->  Seq Scan on test_where_opt."Person" q
+         Output: q.id, q.properties
+   ->  Hash
+         Output: p.id, p.properties, e.end_id
+         ->  Hash Join
+               Output: p.id, p.properties, e.end_id
+               Hash Cond: (p.id = e.start_id)
+               ->  Seq Scan on test_where_opt."Person" p
+                     Output: p.id, p.properties
+               ->  Hash
+                     Output: e.start_id, e.end_id
+                     ->  Seq Scan on test_where_opt."KNOWS" e
+                           Output: e.start_id, e.end_id
+                           Filter: ((graphid_to_agtype(e.id) > '0'::agtype) AND (graphid_to_agtype(e.start_id) > '0'::agtype) AND (graphid_to_agtype(e.end_id) > '0'::agtype))
+(17 rows)
+
+-- Test 7: Combined WHERE with multiple id() calls on different entities
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)-[e:KNOWS]->(q:Person)
+    WHERE id(p) > 0 AND id(q) > 0 AND id(e) > 0
+    RETURN p.name, q.name
+$$) as (name1 agtype, name2 agtype);
+  name1  | name2 
+---------+-------
+ "Alice" | "Bob"
+(1 row)
+
+-- Test 8: WHERE with id() comparison between entities
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)-[e:KNOWS]->(q:Person)
+    WHERE start_id(e) = id(p) AND end_id(e) = id(q)
+    RETURN p.name, q.name
+$$) as (name1 agtype, name2 agtype);
+  name1  | name2 
+---------+-------
+ "Alice" | "Bob"
+(1 row)
+
+-- Test 9: WHERE with id() in complex expression
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)
+    WHERE id(p) > 0 AND id(p) < 9223372036854775807
+    RETURN p.name
+$$) as (name agtype);
+  name   
+---------
+ "Alice"
+ "Bob"
+(2 rows)
+
+-- Test 10: Cross-clause WHERE still works (entity from previous MATCH)
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)
+    MATCH (q:Person)
+    WHERE id(p) > 0
+    RETURN p.name, q.name
+$$) as (name1 agtype, name2 agtype);
+  name1  |  name2  
+---------+---------
+ "Alice" | "Alice"
+ "Bob"   | "Alice"
+ "Alice" | "Bob"
+ "Bob"   | "Bob"
+(4 rows)
+
+-- Test 11: EXPLAIN cross-clause to verify optimization
+SELECT * FROM cypher('test_where_opt', $$
+    EXPLAIN (VERBOSE, COSTS OFF)
+    MATCH (p:Person)
+    MATCH (q:Person)
+    WHERE id(p) > 0
+    RETURN p.name
+$$) as (plan agtype);
+                                                                  QUERY PLAN                                                                   
+-----------------------------------------------------------------------------------------------------------------------------------------------
+ Nested Loop
+   Output: agtype_access_operator(VARIADIC ARRAY[_agtype_build_vertex(p.id, _label_name('20334'::oid, p.id), p.properties), '"name"'::agtype])
+   ->  Seq Scan on test_where_opt."Person" q
+         Output: q.id, q.properties
+   ->  Materialize
+         Output: p.id, p.properties
+         ->  Seq Scan on test_where_opt."Person" p
+               Output: p.id, p.properties
+               Filter: (graphid_to_agtype(p.id) > '0'::agtype)
+(9 rows)
+
+-- Test 12: Combined cross-clause and current-clause WHERE optimization
+-- p is from previous clause (cross-clause), q and e are from current clause (intra-clause)
+SELECT * FROM cypher('test_where_opt', $$
+    MATCH (p:Person)
+    MATCH (q:Person)-[e:KNOWS]->(r:Person)
+    WHERE id(p) > 0 AND id(q) > 0 AND id(e) > 0 AND start_id(e) > 0
+    RETURN p.name, q.name, r.name
+$$) as (name1 agtype, name2 agtype, name3 agtype);
+  name1  |  name2  | name3 
+---------+---------+-------
+ "Alice" | "Alice" | "Bob"
+ "Bob"   | "Alice" | "Bob"
+(2 rows)
+
+-- Test 13: EXPLAIN combined cross-clause and current-clause WHERE
+SELECT * FROM cypher('test_where_opt', $$
+    EXPLAIN (VERBOSE, COSTS OFF)
+    MATCH (p:Person)
+    MATCH (q:Person)-[e:KNOWS]->(r:Person)
+    WHERE id(p) > 0 AND id(q) > 0 AND id(e) > 0 AND start_id(e) > 0
+    RETURN p.name
+$$) as (plan agtype);
+                                                                  QUERY PLAN                                                                   
+-----------------------------------------------------------------------------------------------------------------------------------------------
+ Nested Loop
+   Output: agtype_access_operator(VARIADIC ARRAY[_agtype_build_vertex(p.id, _label_name('20334'::oid, p.id), p.properties), '"name"'::agtype])
+   ->  Seq Scan on test_where_opt."Person" p
+         Output: p.id, p.properties
+         Filter: (graphid_to_agtype(p.id) > '0'::agtype)
+   ->  Materialize
+         ->  Nested Loop
+               Inner Unique: true
+               ->  Hash Join
+                     Output: e.end_id
+                     Inner Unique: true
+                     Hash Cond: (e.start_id = q.id)
+                     ->  Seq Scan on test_where_opt."KNOWS" e
+                           Output: e.id, e.start_id, e.end_id, e.properties
+                           Filter: ((graphid_to_agtype(e.id) > '0'::agtype) AND (graphid_to_agtype(e.start_id) > '0'::agtype))
+                     ->  Hash
+                           Output: q.id
+                           ->  Seq Scan on test_where_opt."Person" q
+                                 Output: q.id
+                                 Filter: (graphid_to_agtype(q.id) > '0'::agtype)
+               ->  Index Only Scan using "Person_pkey" on test_where_opt."Person" r
+                     Output: r.id
+                     Index Cond: (r.id = e.end_id)
+(23 rows)
+
+SELECT drop_graph('test_where_opt', true);
+NOTICE:  drop cascades to 4 other objects
+DETAIL:  drop cascades to table test_where_opt._ag_label_vertex
+drop cascades to table test_where_opt._ag_label_edge
+drop cascades to table test_where_opt."Person"
+drop cascades to table test_where_opt."KNOWS"
+NOTICE:  graph "test_where_opt" has been dropped
+ drop_graph 
+------------
+ 
+(1 row)
+
 --
 -- Clean up
 --