Filter nodes by properity list using intersection

Neo4j Graph Platform Cypher
,
1

Hi guys!
I have nodes of types Subject , Object and verbs as relations
verb relation has a property of type list called Synonyms = ["syn1", "syn2","syn3"]
I want to get all nodes of type Subject that are related to Object by any relationship that has a name == passed verb or one of its synonyms that are passed through the query as a list ( i get them from an ontology).
So I need to get the intersection between the passed list and the relation property Synonyms list.
if result is not empty return the Subject
What is the best way to do that please?

Something similar to this pseudocode

MATCH (s:Subject)-[r]->(o:Object)
with r
call apoc.coll.intersection(r.synonyms, ["make", "do"]) as res
if res is not empty
RETURN s.name

Thanks in advance

2 
r.synonyms is not a collection. First you have to collect all distinct r.synonyms 
with collect(distinct r.synonyms) as synonyms
call apoc.coll.intersection(synonyms, ["make", "do"]) as res
1 Like
3

You can use the 'any' list predicate.

MATCH (s:Subject)-[r]->(o:Object)
WHERE any(i in r.synonyms where i in ["make", "do"])
RETURN s.name

Test data:

create(s:Subject{name:"a"}),
(s)-[:REL{synonyms:['hi','by']}]->(:Object{id:0}),
(s)-[:REL{synonyms:['two','do']}]->(:Object{id:1}),
(s)-[:REL{synonyms:['make','no']}]->(:Object{id:2})

Screen Shot 2024-01-03 at 9.02.44 PM
Screen Shot 2024-01-03 at 9.02.44 PM1742×596 45.9 KB

1 Like
4

In case you prefer the apoc approach, you can try this. Note, the intersection is a function, not a procedure; therefore, it doesn’t use a ‘call’.

MATCH (s:Subject)-[r]->(o:Object)
WHERE size(apoc.coll.intersection(r.synonyms, ["make", "do"])) > 0
RETURN s.name
1 Like
5

Thank you very much, you have saved me a lot of time and effort

6

I am still learning while creating my project. Please, according to your experience, which of the two solutions is better in terms of speed and computational complexity, assuming that the size of the data is much larger?

7

I would think the list predicate approach, as it will stop searching once one element in the first list is found in the second list. All elements in one list need to be compared to the other list to determine the intersection, so once a first element is found to be in the intersection the algorithm will continue instead of stopping.

Another benefit is you do not have a dependency on the APOC library.

If it is known a priori, set the smaller list as the one that the list predicate function iterates over. That may help performance if the is a large difference in the size of the two lists.

1 Like
8

Thank you very much @glilienfield for your response

1 Like