combination queries

[matt-beanland]

Add Ash Neo4j support for Combination Queries

As per Ash Weekly Issue 16 Ash 3.5.9 now supports combination queries.
Combination queries allow a single result set to include 'stacked' queries, and require support in the datalayer.

The datalayer must have def can?(_, :combine), do: true and implement the combination_of(combinations, resource, domain) behaviour, as specified.

There is recent combination support in ETS and Postgres DataLayers.

Combination queries may include calculations which are yet to be supported in the Ash Neo4j, so unlikely in scope for this issue.

[matt-beanland]

https://neo4j.com/docs/cypher-manual/current/queries/combined-queries/ use UNION

[matt-beanland]

What Ash provides:

can?(, :combine) / can?(, {:combine, :union | :union_all | :intersection})
combination_of/3 callback — receives [{type, data_layer_query}] tuples, stores them in the query struct
run_query/2 detects combination_of and dispatches accordingly
Neo4j target Cypher — CALL subquery is the right tool because it allows per-branch ORDER BY/SKIP/LIMIT:

CALL {
MATCH (s:Label) WHERE [b0 filters] RETURN s ORDER BY ... SKIP N LIMIT N
UNION ALL
MATCH (s:Label) WHERE [b1 filters] RETURN s ORDER BY ... SKIP N LIMIT N
}
WITH s
OPTIONAL MATCH (s)-[r]-(d)
RETURN s, r, d
ORDER BY ... SKIP N LIMIT N
The one real complexity: parameter name collisions. Both branches would generate $s_name_0 for the same property. We need per-branch prefixes (b0_s_name_0, b1_s_name_0) and merge the params maps. This threads through the existing predicates/2 and node_clause functions.

Work breakdown:

Query struct — add combination_of: []

can?/2 — add :combine, {:combine, :union}, {:combine, :union_all}; leave :intersection false for now

combination_of/3 callback — trivial: {:ok, %Query{combination_of: combinations, ...}}

run_query/2 — detect non-empty combination_of, dispatch to new path

QueryHelper refactor — the main work:

Extract node_clause(query, param_prefix) from cypher/1 — returns {match_where_return_s, prefixed_params} (no OPTIONAL MATCH)
New combination_query_nodes(combinations, outer_query): builds the CALL {} block, merges params, appends outer sort/skip/limit, runs it
Tests — sandboxed, two branches with different filters, verify UNION deduplicates and UNION ALL doesn't

What we defer: :intersection — either in-memory post-fetch (like ETS) or Cypher 5's INTERSECT. Not needed for the first PR.

Risk: the OPTIONAL MATCH enrichment after CALL {} changes the result shape — need to verify convert_groups_to_resources still works correctly on the combined rows. Likely fine since the shape (s, r, d) is identical.

Would rather do intersection as well, erroring if we don't have current database capability. We should be able to find out from bolty:

raised 2 issues on bolty, diffo-dev/bolty#22 and diffo-dev/bolty#23, either would help, although 23 is a blunt instrument.