neo4j create child node and link it to another childern - neo4j

Question

Intention:
Using neo4j, I would like to add a Child node to a Parent Node. If there are other existing children, I must link the child to all siblings
What I Tried:
Suppose we know for sure that Parent exists. We want to add generic nodes under it. I got this and modified it from:
here
match(tbl: Parent {name: "existing_node"})
optional match(c: Child {name: "generic_node"})
create(n: Child{name: "generic_node"})
FOREACH (o IN CASE WHEN c IS NOT NULL THEN [c] ELSE [] END |
CREATE (o)-[:SIBLING]->(n)
CREATE (n)-[:SIBLING]->(o)
)
Problem Description:
If I run the query multiple times, the following happens:
Creates a new node
Creates a new node and links it with previous node
Creates 2 new nodes and link one of them to the existing ones and to the newly created one. I was expecting it to create only 1 node and link it to all other nodes.
Creates 4 new nodes, and connects one of them to the existing nodes, and connects them as a chain. I was expecting only 1 node to be created and linked to all other nodes.
...
What I am not understanding is why many new nodes are being created? In the FOREACH, I was thinking that (n) would refer to the same newly created node and not create new nodes.
What would be the correct way to add a new sibling and connect it to all other ones if they exist?
Can someone explain why this one creates multiple nodes? There is something happening behind the scenes which I am not understanding.

Answer 1

This should do what you want (it will not create duplicates, no matter how many times the query is executed):
// Find the parent, p
MATCH (p:Parent {name: "existing_node"})
// Find or create Child, c, and ensure it is associated with p
MERGE (c:Person {name: "generic_node"})
MERGE (p)-[:HAS_CHILD]->(c)
// Find each child of p (other than c), and ensure it has a `SIBLING` relationship with c
WITH p, c
MATCH (p)-[:HAS_CHILD]->(n)
WHERE n <> c
MERGE (c)-[:SIBLING]-(n)
Note that there is no need to make two SIBLING relationships (one in each direction) between every pair of sibling nodes, since later on you can use non-directional MATCH queries that do not care about directionality. For example:
// Relationship pattern has no arrow, so matches relationship going in either direction
MATCH (c1:Child)-[:SIBLING]-(c2:Child)
...
Similarly, the MERGE (c)-[:SIBLING]-(n) clause above does not specify an arrow either, to ensure that 1 and only one relationship is created between c and n.

Answer 2

I think this might achieve what you trying to accomplish
// Find the parent
MATCH (tbl:Parent {name: "existing_node"})
// Optionally fin existing children and put them in a collection
OPTIONAL MATCH (tbl)<-[:CHILD]-(c:Child {name: "generic_node"})
WITH tbl, collect(c) AS children
// create the new child and the relationship to the found parent
CREATE (n:Child {name: "generic_node"})
CREATE (tbl)<-[:CHILD]-(n)
// create the sibling relationships to any pre-existing children
FOREACH (c IN children |
CREATE (c)-[:SIBLING]->(n)
)
Why your query created duplicates...
The first time you ran the optional match there were no children matched so you created a new child node and that was that.
The second time you run it the optional match finds the child you just created and then creates another one
The third time it finds both previous children in two rows and since you don't collect them to a single row your create statemetn is called two times. Now there are four children so the next time the create is called four times.
THe foreach only ends up operating on that one child node at a time because there is no collection of child nodes.