I am interpreting the question to be "how do get query from a node and get all the nodes it has relationships to without defining each relationship". Created a model that I think is what you're looking for. It connects five different nodes to a single node with five different relationships. The Cypher query pattern here is to anchor off the start node and not define relationship(s). The model has all nodes with the label Node (you should use a label in a query when you can in almost all cases):
CREATE
(`0` :Node {name:'start'}) ,
(`1` :Node {name:"associated_node1"}) ,
(`2` :Node {name:"associated_node2"}) ,
(`3` :Node {name:"associated_node3"}) ,
(`4` :Node {name:"associated_node4"}) ,
(`5` :Node {name:"associated_node5"}) ,
(`0`)-[:`REL1` ]->(`1`),
(`0`)-[:`REL2` ]->(`2`),
(`0`)-[:`REL3` ]->(`3`),
(`0`)-[:`REL4` ]->(`4`),
(`0`)-[:`REL5` ]->(`5`)
The image and rudimentary create code was built using the "arrows" tool found at: http://www.apcjones.com/arrows/
The simplest query would be to start with the node that has the name property value 'start', and get all nodes via any relationship to any other node with the label :Node:
MATCH path=(:Node {name: 'start'})-->(:Node) RETURN path
A more explicit approach would be to define how many relationship 'hops' you want the query to traverse from the start node. In this case there's only one level of relationships:
MATCH path=(:Node {name: 'start'})-[*..1]->(:Node) RETURN path
Or, get anything to any depth related to the node with label :Node with the property name:'start'
MATCH path=(:Node {name: 'start'})-[*]->() RETURN path
As always, you should PROFILE or EXPLAIN your queries to make sure they're efficient, using indexes where it makes sense to have them, etc.
Filter the relationship:
MATCH (n:Node {name:"start"})-[r]-(d)
WHERE type(r) <> "REL2"
RETURN n, d;
Result:
To get all:
MATCH (n:Node {name:"start"})-[r]-(d)
//WHERE type(r) <> "REL2"
RETURN n, d;
Result:
I have a similar problem that needs help with. I want all the related, distinct Users started from the uid=start User.
I started with a query like:
MATCH (u:User {uid: $uid}),
(u)-[*1..3]-(t:User)
RETURN count(DISTINCT t)
It ends up a huge number that doesn't match.
So I narrow it down into 3 queries:
// a match the 1 hop, the two way FOLLOWING relationships
MATCH (u:User {uid: $uid})--(t:User)
return count(distinct t)
// b match the 2 hops, start User's to Post relationships
MATCH (u:User {uid: $uid})-->(:Post)<--(t:User)
return count(distinct t)
// c match the 3 hops, the chat post relationships
MATCH (u:User {uid: $uid})-->(:Chat)<--(:Post)<--(t:User)
return count(distinct t)
Then I don't know how to get distinct count with a,b,c's target users.
Thank you for your reply! @andrew.bowman
I execute the query below:
MATCH (u:User {uid: $uid})--(t:User)
return count(distinct t)
UNION
MATCH (u:User {uid: $uid})-->(:Post)<--(t:User)
return count(distinct t)
UNION
MATCH (u:User {uid: $uid})-->(:Chat)<--(:Post)<--(t:User)
return count(distinct t)
Outputs:
╒═══════════════════╕
│"count(distinct t)"│
╞═══════════════════╡
│11 │
├───────────────────┤
│807 │
├───────────────────┤
│0 │
└───────────────────┘
By Adding three counts, it's a reasonable total related users counts. There might have maximum 818 related users if query a and query b don't have any duplicate users.
But I execute the query, i got a huge total.
MATCH (u:User {uid: $uid}), (u)-[*1..3]-(t:User) RETURN count(DISTINCT t)
Outputs:
╒═══════════════════╕
│"count(DISTINCT t)"│
╞═══════════════════╡
│35860 │
└───────────────────┘
And the Profile output
NODES 2022, Neo4j Online Education Summit
All the sessions of the conference are now available online
