为何Cypher查询会创建多条无关关系？求官方文档依据

Great question—this behavior is rooted in how Cypher processes queries row-by-row, a core part of its execution model. Let me break down the official reasoning, your specific cases, and how this works across different match patterns.

Official Core Logic (From Neo4j's Cypher Specification) #

Cypher operates on a row-based execution model: every time your MATCH clauses produce a set of matching rows (each containing the variables defined in the match), any subsequent write operations (like CREATE, MERGE, SET) will run once per row.

Even if you don’t use all the variables from the MATCH clauses in your CREATE, each row still triggers the write operation independently. This is explicitly documented in Neo4j’s Cypher documentation as part of the query execution flow—matches generate rows, and each row drives the subsequent steps.

Breaking Down Your Examples #

First Query: 5 LIVE_IN Relationships & Places #

Your first query:

MATCH(p:Person {id:1}) 
MATCH (p)-[:KNOWS]-(s) 
CREATE (p)-[:LIVE_IN]->(:Place {name: 'Some Place'})

• The first MATCH finds 1 Person node (p).
• The second MATCH finds 5 nodes (s) connected to p via KNOWS (since -(s) is undirected, it counts both incoming and outgoing KNOWS relationships).
• Together, these two matches produce 5 rows (each row has p and one unique s).
• The CREATE runs once per row, so you get 5 Place nodes and 5 LIVE_IN relationships from p to each place.

Second Query: 15 LOVE Relationships & Places #

Your second query adds a third MATCH for Office nodes:

MATCH(p:Person {id:1}) 
MATCH (p)-[:KNOWS]-(s) 
MATCH (o:Office) 
CREATE (p)-[:LOVE]->(:Place {name: 'Any Place'})

• Now you have three match clauses: 1 p, 5 s, 3 o.
• The Cartesian product of these is 1 * 5 * 3 = 15 rows (every combination of p, s, and o).
• Again, CREATE runs once per row, leading to 15 Place nodes and 15 LOVE relationships.

CREATE Behavior in Complex Match Patterns #

This row-by-row logic applies regardless of the match pattern’s structure:

• Non-connected graphs: If you match two unrelated node sets (e.g., MATCH (a:LabelA), (b:LabelB)), you get a Cartesian product of all a and b nodes, and CREATE runs once for each combination.
• Tree structures: If your MATCH traverses a tree (e.g., MATCH (root)-[:CHILD*]->(leaf)), every path from root to leaf becomes a row, and CREATE runs once per path.
• Optional matches: OPTIONAL MATCH adds rows with NULL values for unmatched variables, so those rows still trigger CREATE unless you filter them out.

If you want to avoid this (e.g., run CREATE only once, regardless of matches), use WITH to limit the number of rows before the write operation. For example:

MATCH(p:Person {id:1}) 
MATCH (p)-[:KNOWS]-(s) 
WITH p LIMIT 1  // Keep only one row with p
CREATE (p)-[:LIVE_IN]->(:Place {name: 'Some Place'})

This will create just one Place and one LIVE_IN relationship, even if there are 5 s nodes.

Impact of KNOWS Relationship Direction #

The direction in your MATCH clause directly affects how many rows are generated:

• (p)-[:KNOWS]-(s): Undirected match, counts both p → s and p ← s relationships. If p has 3 outgoing and 2 incoming KNOWS relationships, this returns 5 rows.
• (p)-[:KNOWS]->(s): Directed match, only counts outgoing relationships from p to s. If p has 3 outgoing, this returns 3 rows.
• (p)<-[:KNOWS]-(s): Directed match, only counts incoming relationships to p from s. If p has 2 incoming, this returns 2 rows.

More rows mean more CREATE executions, so direction directly impacts the number of nodes/relationships created.

内容的提问来源于stack exchange，提问作者adnanmuttaleb