Neo4j Cypher - Query partial fixed route and partial variable route - neo4j

Question

Let's say I have a graph network like shown here:
I can do a cypher query using something like
MATCH (a:A)-[]->(b:B)-[]->(c:C)-[]-(d1:D),
(a)-[]->(b)-[]->(c)-[]-(d2:D),
(a)-[]->(b)-[]->(c)-[]-(d3:D),
(a)-[]->(b)-[]->(c)-[]-(d4:D),
WHERE d1.val = '1' AND d2.val = '2' AND d3.val ='3', d4.val = '4'
RETURN a, b, c, d1, d2, d3, d4
Is there a way to simplify this query, without explicitly rewriting the relationship over and over again, which are identical. I am trying to find every relation which has all the D values I am expecting, which is large list so probably an IN clause would be appropriate.
Edit:
Sample data based on answer below
create (a1:A {name: 'A1'})
create (b1:B {name: 'B1'})
create (c1:C {name: 'C1'})
create (d1:D {name: 'D1', val: 1})
create (d2:D {name: 'D2', val: 2})
create (d3:D {name: 'D3', val: 3})
create (d4:D {name: 'D4', val: 4})
create (a1)-[:NEXT]->(b1)
create (b1)-[:NEXT]->(c1)
create (c1)-[:NEXT]->(d1)
create (c1)-[:NEXT]->(d2)
create (c1)-[:NEXT]->(d3)
create (c1)-[:NEXT]->(d4)
create (a2:A {name: 'A2'})
create (b2:B {name: 'B2'})
create (c2:C {name: 'C2'})
create (a2)-[:NEXT]->(b2)
create (b2)-[:NEXT]->(c2)
create (c2)-[:NEXT]->(d1)
create (c2)-[:NEXT]->(d2)
create (a3:A {name: 'A3'})
create (b3:B {name: 'B3'})
create (c3:C {name: 'C3'})
create (a3)-[:NEXT]->(b3)
create (b3)-[:NEXT]->(c3)
create (c3)-[:NEXT]->(d1)
create (c3)-[:NEXT]->(d2)
create (c3)-[:NEXT]->(d3)
create (c3)-[:NEXT]->(d4)
return *
So the query should result in A1-->B1-->C1-->D1,D2,D3,D4 and A3-->B3-->C3-->D1,D2,D3,D4
Since A2-->B2--C2 links with only D1,D2 and not D3,D4 it should not be in the result.

Answer 1

The beginning of the path is always the same, so you don't need to repeat it. Then, based on a list of values, you want to check if you can find a D for each and every one of them: it could be a job for all.
Mixing all that, we get:
MATCH (a:A)-->(b:B)-->(c:C)-->(d:D)
WHERE d.val IN {values}
WITH a, b, c, collect(d) AS dList
WHERE all(value IN values WHERE any(d IN dList WHERE d.val = value))
RETURN a, d, c, dList
However, if n is the number of values, that's an O(n^2) algorithm because of the second WHERE.
Let's collect the values of the nodes while collecting the nodes themselves, to avoid the double loop and turn it into a O(n) algorithm:
MATCH (a:A)-->(b:B)-->(c:C)-->(d:D)
WHERE d.val IN {values}
WITH a, b, c, collect(d) AS dList, collect(DISTINCT d.val) AS dValues
WHERE all(value IN values WHERE value in dValues)
RETURN a, d, c, dList
Assuming the list of values passed as a parameter only contains distinct values, we can even change that into an O(1) algorithm by simply comparing the size of the input list and the distinct values found:
MATCH (a:A)-->(b:B)-->(c:C)-->(d:D)
WHERE d.val IN {values}
WITH a, b, c, collect(d) AS dList, collect(DISTINCT d.val) AS dValues
WHERE size({values}) = size(dValues)
RETURN a, d, c, dList
Because dValues ⊂ values, if the 2 sets have the same size, they're equal.
If D.val are globally unique, or at least unique for all the D nodes connected to a single C, it can be further simplified:
MATCH (a:A)-->(b:B)-->(c:C)-->(d:D)
WHERE d.val IN {values}
WITH a, b, c, collect(d) AS dList
WHERE size({values}) = size(dList)
RETURN a, d, c, dList
If the values are globally unique, the query will be faster with the unicity constraint as it will also index the values:
CREATE CONSTRAINT ON (d:D) ASSERT d.val IS UNIQUE

Answer 2

If every D node has a unique val property (if any), this should work:
WITH [1,2,3,4] AS desired
MATCH (a:A)-->(b:B)-->(c:C)-->(d:D)
WHERE d.val IN desired
WITH a, b, c, COLLECT(DISTINCT d) AS ds
WHERE SIZE(ds) = SIZE(desired)
RETURN a, b, c, ds
The result will have a row for every matched A, B, C combination, along with the collection of D nodes.

Answer 3

Assuming the following data set...
create (a:A {name: 'A'})
create (b:B {name: 'B'})
create (c:C {name: 'C'})
create (d1:D {name: 'D1', val: 1})
create (d2:D {name: 'D2', val: 2})
create (d3:D {name: 'D3', val: 3})
create (d4:D {name: 'D4', val: 4})
create (a)-[:NEXT]->(b)
create (b)-[:NEXT]->(c)
create (c)-[:NEXT]->(d1)
create (c)-[:NEXT]->(d2)
create (c)-[:NEXT]->(d3)
create (c)-[:NEXT]->(d4)
return *
You could execute a query something like this to match all of the specific D nodes in a particular value range.
match (a:A)-->(b:B)-->(c:C)-->(d:D)
where d.val in range(1,4)
return *
Here is an updated query based on your updated question. I collected the D values for each A,B,C chain of nodes.
match (a:A)-->(b:B)-->(c:C)-->(d:D)
where d.val in range(1,4)
with a, b, c, d
order by a.name, b.name, c.name, d.name
return a, b, c, collect(d) as d
order by a.name, b.name, c.name