[rjb32]

Lay every constant an op reads alone over the rows in flight with db.broadcast_constant, and run an op over constants alone on a single row.

MATCH (a:Person {name: 'Remy'})-[*2..2]->(b) RETURN 1

  before: db.output(%c)                              3 rows
  after:  %x = db.broadcast_constant(%c, %srcids)
          db.output(%x)                              4 rows

MATCH (a:Person)-[e*1..2]->(b)-->(c) RETURN 1                     16 -> 20 rows

ctest: 858 of 858 passed

[rjb32]

Note

AI-generated summary.

Summary

The rule: an op that reads constants alone runs over the rows of its region, which is one row at the top level. Codegen names every other case with the existing db.broadcast_constant:

 %1, %2, %3 = db.explore_paths(%0, {}) forward hops 2 to 2
 %4 = db.constant(1 : i64)
-db.output(%4)                                   // rows guessed from the innermost loop at lowering
+%5 = db.broadcast_constant(%4, %1)              // the exploration's rows, as a use
+db.output(%5)

codegen
  ConstantRowsListener (OpBuilder listener)      on every inserted op that reads constants alone,
    resolveRowCarryingColumn                     lays them over the rows in flight: past an aggregate
                                                 the groups, after a CREATE or MERGE the written entities
  generateOutput -> broadcastConstantProjection  RETURN 1 like WITH 1 AS x, before LIMIT / SKIP / DISTINCT
passes
  TrimUnreadColumns                  keeps one row column when an op's other operands are constants (UNWIND [1, 2])
  FuseFetchNodes                     re-drives broadcasts off the scan it replaces
  fuse_explore_distinct_ends         passes the rows on through a broadcast; the TUR-303 no-user guard is gone
  drive_broadcasts_from_row_sources  (new) drives a broadcast from its driver's row source past row-wise ops
                                     that cannot raise, and erases what only computed the driver
lowering
  _innermostCardinality -> _regionRows           set only by ops owning a region, no loop-nest updates
  lowerHopRegion                                 a hop predicate's region rows are the hop's edges
  lowerConstantOutput                            db.output(broadcast(%c, %d)) -> nl.output %c cardinality %d
  rowAlignGroupingKeys                           a constant key takes the rows of an aggregated column

The verifier first proposed for TUR-306 was dropped. It cannot check that a broadcast names the right rows, and it rejected sources whose lowering needs a constant (fetch_nodes over a constant id list).

Evidence

• Before (main before TUR-303: Cypher: return one row per path when the RETURN reads no pattern variable #1176): measured through the REST server on simpledb

  MATCH (a:Person {name: 'Remy'})-[*2..2]->(b) RETURN 1      3 rows
  MATCH (a:Person)-[e*1..2]->(b) RETURN 1                    24 rows
  MATCH (a:Person)-[e*1..2]->(b)-->(c) RETURN 1              16 rows
  MATCH (a:Person)-[e*1..2]->(b) WHERE b:Person RETURN 1      4 rows
  

  After: 4, 25, 20 and 5 rows. ConstantRowsTest (new) pins them, along with RETURN DISTINCT 1, LIMIT and SKIP, constants after an aggregate, UNWIND after an unread MATCH, and MATCH (n:Nothing) RETURN 1 / 0 returning no rows.
• The exploration in the first query stays non-distinct with no special case in fuse_explore_distinct_ends, because the broadcast is a user (readsTheExplorationThroughTheBroadcast). TUR-303: Cypher: return one row per path when the RETURN reads no pattern variable #1176's guard is removed and its ConstantProjectionRowsTest still passes.
• ConstantRowsPassesTest (new) runs MATCH ... RETURN 1 over the shape each pass rewrites and checks the row count against count(*) and the fused op in the plan: node scans, edge scans, factors, rerooting, the UNWIND and fetch fusions, the exploration fusions, an OPTIONAL MATCH hop. A raising constant (size('ab') - 1) in WHERE and inside every region kind gives the rows of the literal 1.

  MATCH (a:Person)((x)-[r]->(y) WHERE y.age > (size('ab') - 1)){1,3}(b)          0 -> 4 rows
  ... WHERE a.age > (size('ab') - 1) RETURN DISTINCT a.name, b.name               exploration distinct again
  UNWIND [0, 1] AS i MATCH (n) WHERE id(n) = i RETURN 1                           no per-row db.element_id
  

• DriveBroadcastsFromRowSourcesTest (new): past an element_id, past a property read and comparison, a driver read elsewhere, a division that may raise.
• 88 probe queries run against a build of main and this branch: identical db plans, identical rows.
• 7 hand-written programs in DBLoweringTest and MLIRCallProcedureTest that relied on the loop-nest guess now spell db.broadcast_constant.
• ctest: 866 of 866 passed.

Merge Danger

Door: two-way

No format or wire change. Reverting restores the old lowering.

Blast Radius: wide

Every v3 query whose projection, write or raising expression reads constants alone while rows are in flight now emits a broadcast, so EXPLAIN output changes for those queries. A pass that drops or moves a row column has to keep or re-drive the broadcasts that column drives. ConstantRowsPassesTest covers every such pass in the pipeline today; a new one needs a case there. A cut or sort over a constant-only projection now materialises the constant per chunk. A plain RETURN does not, through lowerConstantOutput.

[rjb32]

Closing: a broadcast's driver column stands in for a relation the db dialect has no value for, and every fix after the first commit compensated for that. TUR-306 becomes the design ticket for a first-class relation value; #1176's guard stays.