What is the difference between multiple MATCH clauses and a comma in a Cypher query?

Question

In a Cypher query language for Neo4j, what is the difference between one MATCH clause immediately following another like this:

MATCH (d:Document{document_ID:2})
         


        

Answer 1

If a part of a query contains multiple disconnected patterns, this will build a cartesian product between all those parts. This may produce a large amount of data and slow down query processing. While occasionally intended, it may often be possible to reformulate the query that avoids the use of this cross product, perhaps by adding a relationship between the different parts or by using OPTIONAL MATCH (identifier is: (a)) . IN short their is NO Difference in this both query but used it very carefully.

Answer 2

In a more generic way, "The same relationship cannot be returned more than once in the same result record." [see 1.5. Cypher Result Uniqueness in the Cypher manual]

Both MATCH-after-MATCH, and single MATCH with comma-separated pattern should logically return a Cartesian product. Except, for comma-separated pattern, we must exclude those records for which we already added the relationship(s).

In Andy's answer, this is why we excluded repetitions of the same movie in the second case: because the second expression from each single MATCH was using there the same :WROTE relationship as the first expression.

Answer 3

There is a difference: comma separated matches are actually considered part of the same pattern. So for instance the guarantee that each relationship appears only once in resulting path is upheld here.

Separate MATCHes are separate operations whose paths don't form a single patterns and which don't have these guarantees.

Answer 4

There are no differences between these provided that the clauses are not linked to one another.

If you did this:

MATCH (a:Thing), (b:Thing) RETURN a, b;

That's the same as:

MATCH (a:Thing) MATCH (b:Thing) RETURN a, b;

Because (and only because) a and b are independent. If a and b were linked by a relationship, then the meaning of the query could change.

Answer 5

I think it's better to explain providing an example when there's a difference. Let's say we have the "Movie" database which is provided by official Neo4j tutorials. And there're 10 :WROTE relationships in total between :Person and :Movie nodes

MATCH (:Person)-[r:WROTE]->(:Movie) RETURN count(r); // returns 10

1) Let's try the next query with two MATCH clauses:

MATCH (p:Person)-[:WROTE]->(m:Movie) MATCH (p2:Person)-[:WROTE]->(m2:Movie)
RETURN p.name, m.title, p2.name, m2.title;

Sure you will see 10*10 = 100 records in the result.

2) Let's try the query with one MATCH clause and two patterns:

MATCH (p:Person)-[:WROTE]->(m:Movie), (p2:Person)-[:WROTE]->(m2:Movie) 
RETURN p.name, m.title, p2.name, m2.title;

Now you will see 90 records are returned. That's because in this case records where p = p2 and m = m2 with the same relationship between them (:WROTE) are excluded.

For example, there IS a record in the first case (two MATCH clauses)

p.name m.title p2.name m2.title

"Aaron Sorkin" "A Few Good Men" "Aaron Sorkin" "A Few Good Men"

while there's NO such a record in the second case (one MATCH, two patterns)