I have one set of node node1 and node2
(node1) <- rel1 - (node2)
(node1) <- rel2 - (node2)
(node1) <- rel3 - (node2)
(node1) <- rel4 - (node2)
I can get all type of relations between them by
MATCH (a:node1) -[r] - (b:node2) RETURN DISTINCT a, b
Now I only want rel1 and rel2 between these nodes
How i can achive this?
Its working like this
MATCH (a:node1) <-[:rel2 | :rel1] - (b:node2) RETURN DISTINCT a, b
Related
I'm pretty new in neo4j and I have troubles to get a well result for my query. I have the next model:
Player <- HAS_PLAYERS - Game
Node Player: playerId, name,...etc
Node Game: gameId, gameDate
Rel. HAS_PLAYERS: result
Note that a Game could have 1-4 players.
I would like to make a query to suggest future opponents to a player ordered by:
Previous opponents ordered by gameDate (more recent) and then opponents of opponents ordered by gameDate.
For example:
PlayerA <- 2021/02/01 -> PlayerB*
PlayerA <- 2021/02/01 -> PlayerC*
PlayerA <- 2021/02/11 -> PlayerB
PlayerB <- 2021/02/04 -> PlayerC
PlayerB <- 2021/02/20 -> PlayerD
PlayerC <- 2021/02/15 -> PlayerD
PlayerC <- 2021/12/01 -> PlayerE
PlayerD <- 2021/02/07 -> PlayerE
PlayerD <- 2021/02/23 -> PlayerF
* = Same game
The result would be:
PlayerB
PlayerC
PlayerE
PlayerD
Explanation:
PlayerB and PlayerC have been opponents before but PlayerB is the first one because the last game was more recent than PlayerC.
PlayerE and PlayerD are opponents-of-opponents and PlayerE is before because the next game will be in December.
I have the next query but my problem is the query returns duplicated nodes:
# Getting direct opponents
MATCH (p:Player {userId: "PlayerA"})<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(o:Player)
WITH p, o, g ORDER BY g.gameDate DESC
WITH p, COLLECT(o) AS opponents
# Getting opponents-of-opponents (ops)
MATCH (p)-[:HAS_PLAYERS*3]-(gops:Game)--(ops:Player)
WHERE p.userId <> ops.userId AND NOT ops IN opponents
# Trying to remove duplicated nodes
WITH DISTINCT ops, opponents, gops
WITH opponents, ops, gops ORDER BY gops.gameDate DESC
# Concat both lists: opponents and opponents-of-opponents
WITH REDUCE(s = opponents, o2 IN COLLECT(ops) | s + o2) as listAllOpponents
UNWIND listAllOpponents as opPlayer
RETURN opPlayer
It returns something like:
PlayerB
PlayerC
PlayerD
PlayerE
PlayerD
Any help would be appreciated.
When you aggregate the nodes, it will not remove duplicates so adding the keyword "distinct" will fix it. Instead of COLLECT(o), use COLLECT(DISTINCT o) as opponents and COLLECT(DISTINCT ops).
// Getting direct opponents
MATCH (p:Player {userId: "34618"})<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(o:Player)
WITH p, o, g ORDER BY g.gameDate DESC
WITH p, COLLECT(DISTINCT o) AS opponents
// Getting opponents-of-opponents (ops)
MATCH (p)-[:HAS_PLAYERS*3]-(gops:Game)--(ops:Player)
WHERE p.userId <> ops.userId AND NOT ops IN opponents
// Trying to remove duplicated nodes
WITH DISTINCT ops, opponents, gops
WITH opponents, ops, gops ORDER BY gops.gameDate DESC
// Concat both lists: opponents and opponents-of-opponents
WITH REDUCE(s = opponents, o2 IN COLLECT(DISTINCT ops) | s + o2) as listAllOpponents
UNWIND listAllOpponents as opPlayer
RETURN opPlayer
Result:
PlayerB
PlayerC
PlayerE
PlayerD
This is my solution:
# Getting direct opponents
MATCH (p:Player {userId: "PlayerA"})<-[:HAS_PLAYERS]-(g:Game)-[:HAS_PLAYERS]->(o:Player)
WITH p, o, max(g.gameDate) as maxDate
WITH p, o ORDER BY maxDate DESC
WITH p, COLLECT(o) AS opponents
# Getting opponents-of-opponents (ops)
OPTIONAL MATCH (p)-[:HAS_PLAYERS*3]-(gops:Game)--(ops:Player)
WHERE p.userId <> ops.userId AND NOT ops IN opponents
WITH opponents, ops, max(gops.start) as maxDate
WITH opponents, ops ORDER BY maxDate DESC
WITH opponents, COLLECT(ops) AS opponentsOfOpponents
# Concat both lists: opponents and opponents-of-opponents
UNWIND (opponents + opponentsOfOpponents) AS player
RETURN player
I have a tree-like graph as shown below
Now let's say I start from the root node R and want to find all the paths from 1 to the nearest type B node. In the example graph, the result should be
path-1: 1,2
path-2: 1,3,6,10,13
path-3: 1,3,7,10,13
How can I do this?
Keep the node type in the label - (:A) and (:B), relationships between nodes are of type 'connect'.
// Find all paths from Root to all B-nodes
MATCH (A:A {name:1}), p = (A)-[:connect*]->(B:B)
// Get all node labels for each path
WITH A, p, extract( n in nodes(p) | labels(n) ) as pathLabels
// We find the number of occurrences of B-node in each path
WITH A, p, reduce( bCount = 0, Labels in pathLabels |
CASE WHEN 'B' IN Labels THEN 1 ELSE 0 END + bCount
) as bCount
// Return only the path in which the B-node is in the end of the path
WHERE bCount = 1
RETURN p
Example data query:
MERGE (A1:A {name:1})-[:connect]-(B2:B {name:2}) MERGE (A1)-[:connect]-(A3:A {name:3}) MERGE (B2)-[:connect]-(A4:A {name:4}) MERGE (B2)-[:connect]-(A5:A {name:5}) MERGE (A4)-[:connect]-(B8:B {name:8}) MERGE (B8)-[:connect]-(A11:A {name:11}) MERGE (B8)-[:connect]-(A12:A {name:12}) MERGE (A5)-[:connect]-(A9:A {name:9}) MERGE (A3)-[:connect]-(A6:A {name:6}) MERGE (A3)-[:connect]-(A7:A {name:7}) MERGE (A6)-[:connect]-(A10:A {name:10}) MERGE (A7)-[:connect]-(A10) MERGE (A10)-[:connect]-(B13:B {name:13}) RETURN *
Update (searching not A-type nodes):
// Find all paths from Root to all not A-nodes
MATCH (A:A {name:1}), p = (A)-[:connect*]->(B) WHERE NOT 'A' IN labels(B)
// Get all node labels for each path
WITH A, p, extract( n in nodes(p) | labels(n) ) as pathLabels
// We find the number of occurrences of A-node in each path
WITH A, p, reduce( aCount = 0, Labels in pathLabels |
CASE WHEN 'A' IN Labels THEN 1 ELSE 0 END + aCount
) as aCount
// Return only the path in which the count of A-node
// is 1 less the total number of nodes in the path.
WHERE aCount = length(p)
RETURN p
Let's say, I have a path A->B->C->D and the relationships have a property val.
Now, I have to pick any two nodes from the path and if the rel.val>0.8
and if it is true for all the pair of nodes, then return the path
Ex:
P = A-->B-->C-->D
All nodes = [A,B,C,D]
return p if{
rel.val of (A,B) >0.8
rel.val of (A,C) >0.8
rel.val of (A,D) >0.8
rel.val of (B,C) >0.8
rel.val of (B,D) >0.8
rel.val of (C,D) >0.8
}
Here is my query, (of course the query is wrong):
MATCH p=(a{word:"quality"})-[r*1..2]->(b)
WHERE NONE (n IN nodes(p) WHERE size(filter(x IN nodes(p) WHERE n = x))> 1)
MATCH q = (a)-[r:coocr]->(b) where a in nodes(p) AND b in nodes(p) AND NOT b = a AND None(rel IN rels(q) WHERE rel.val < 0.8 )
RETURN p
In summary, you want to MATCH a path and then make sure that all pairs of nodes in your path are connected by a relationship which fullfills a certain criterion (rel.val > 0.8).
Interesting question, I think this is not really straightforward. Maybe I am overlooking something obvious?
Here is an idea how to approach the problem. You first MATCH your path, then MATCH between all nodes in the path and count the number of relationships with rel.val > 0.8. This number has to be the size of the factorial of the number of nodes (num relationships == (num nodes)!, number of possible combinations of 2).
The following query returns the number of relationships, but I don't know how to compare this to the factorial of the number of nodes:
// match your path like before
MATCH p=(a:Uselabel {word:"quality"})-[r:USETYPE*1..2]->(b)
// use unwind to get the nodes from the path
UNWIND nodes(path) AS x
// do this twice to match the nodes onto themselves
UNWIND nodes(path) AS y
// match your relationship
MATCH (x)-[rel:USETYPE]-(y)
// criterion for your relationship
WHERE rel.val > 0.8
// only if two different nodes
WHERE x <> y
// get the count of pairs
WITH p, count(DISTINCT rel) AS num_pairs
// now I don't know how to get/compare the factorial of the number of nodes :)
RETURN num_pairs
I didn't find a built-in function for the factorial, so you have to look into this.
I am running the following query that is meant to compare two collections nodes set1 and set2. All nodes in set2 are in set1, and I would like to identify all the nodes in set1 that are NOT in set2. However, the query returns a set of nodes that includes some of the nodes in set1. I am running this query on v2.1.7. Suggestions?
Query:
MATCH p=(a:ObjectConcept{sctid:233604007})<-[:ISA*]-(b:ObjectConcept)
with nodes(p) as set1, p
MATCH q=(a:ObjectConcept{sctid:34020007})<-[:ISA*]-(b:ObjectConcept)
with nodes(q) as set2,set1, p
WHERE ALL(x in set2 WHERE NOT x in set1)
with nodes(p) as pneumo
UNWIND pneumo AS pneumolist
RETURN distinct pneumolist.FSN,pneumolist.sctid
Alternative query, same result:
Query:
MATCH p=(a:ObjectConcept{sctid:233604007})<-[:ISA*]-(b:ObjectConcept)
with nodes(p) as set1, p
MATCH q=(a:ObjectConcept{sctid:34020007})<-[:ISA*]-(b:ObjectConcept)
with nodes(q) as set2,set1, p
WHERE NONE(x in set2 WHERE x in set1)
with nodes(p) as pneumo
UNWIND pneumo AS pneumolist
RETURN distinct pneumolist.FSN,pneumolist.sctid
Your matches don't return just one row as you might expect but many rows,
and your comparison is done between the cross product of those many row combinations. You probably want to create a set for each of your two subtrees first with a combination of unwind + collect(distinct)
The code below will not be as fast, as cypher internally doesn't have a Set concept yet.
try this
MATCH p=(a:ObjectConcept{sctid:233604007})<-[:ISA*]-(b:ObjectConcept)
unwind nodes(p) as n
with collect(distinct n) as set1
MATCH q=(a:ObjectConcept{sctid:34020007})<-[:ISA*]-(b:ObjectConcept)
unwind nodes(q) as m
with collect(distinct m) as set2
WHERE NONE(x in set2 WHERE x in set1)
UNWIND set1 AS pneumolist
RETURN distinct pneumolist.FSN,pneumolist.sctid
The following query was successful, and addresses Michael's discussion regarding cross products (above).
MATCH p=(a:ObjectConcept{sctid:233604007})<-[:ISA*]-(b:ObjectConcept)
with distinct nodes(p) as set1
UNWIND set1 as x1
with collect(DISTINCT x1) as set11
MATCH q=(a:ObjectConcept{sctid:34020007})<-[:ISA*]-(b:ObjectConcept)
with distinct nodes(q) as set2,set11
UNWIND set2 as x2
with collect(distinct x2) as set22,set11
with REDUCE(pneumo=[],x in set11|case when x in set22 then pneumo else pneumo
+ [x] END) AS pneumo
return pneumo
I want to find all paths given a start node
MATCH path=(n)-[rels*1..10]-(m)
with the following 2 conditions on path inlcusion:
true if relationship between subsequent nodes in path has property PROP='true'
if type(relationship)=SENDS then true if direction of the relationship is outgoing (from one path node to the next node in the path)
Another way of phrasing this is that direction doesn't matter unless the relationship name is SENDS
I can do condition 1 with WHERE ALL (r IN rels WHERE r.PROP='true') however ive no idea how to do condition 2.
The only way I can think of to filter on relationship direction without declaring direction in the match pattern is by comparing the start node of each relationship in the path with the node at the corresponding index of the nodes() collection from the path. For this you need the relationship and node collections from the path, an index counter and some boolean evaluation equivalent to ALL(). One way to do it is to use REDUCE with a collection for the accumulator, so you can accumulate index and maintain a true/false value for the path at the same time. Here's an example, the accumulator starts at [0,1] where the 0 is the index for testing that startNode(r) equals the node at the corresponding index in the node collection (i.e. it's an outgoing relationship) and the 1 represents true, which signifies that the path has not yet failed your conditions. For each relationship the index value is incremented and the CASE/WHEN clause multiplies the 'boolean' with 1 if your conditions are satisfied, with 0 if not. The evaluation of the path is then the evaluation of the second value in the collection returned by REDUCE -- if 1 then yay, if 0 then boo.
MATCH path = (n)-[*1..10]-(m)
WITH path, nodes(path) as ns, relationships(path) as rs
WHERE REDUCE(acc = [0,1], r IN rs |
[acc[0]+1, CASE WHEN
r.PROP='true' AND
(type(r) <> "SENDS" OR startNode(r) = ns[acc[0]]) THEN acc[1]*1 ELSE acc[1]*0 END]
)[1] = 1
RETURN path
or maybe this is more readable
WHERE REDUCE(acc = [0,1], r IN rs |
CASE WHEN
r.PROP=true AND
(type(r) <> "SENDS" OR startNode(r) = ns[acc[0]])
THEN [acc[0]+1, acc[1]*1]
ELSE [acc[0]+1, acc[1]*0]
END
)[1] = 1
Here's a console: http://console.neo4j.org/?id=v3kgz9
For completeness I've answered the question using jjaderberg correct solution plus a condition to fix the start node and ensure that no zero length paths are included
MATCH p = (n)-[*1..10]-(m)
WHERE ALL(n in nodes(p) WHERE 1=length(filter(m in nodes(p) WHERE m=n)))
AND (id(n)=1)
WITH p, nodes(p) as ns, relationships(p) as rs
WHERE REDUCE(acc = [0,1], r IN rs | [acc[0]+1,
CASE WHEN r.PROP='true' AND (type(r) <> "SEND" OR startNode(r) = ns[acc[0]])
THEN acc[1]*1
ELSE acc[1]*0
END])[1] = 1
RETURN nodes(p);
Or my alternative answer based on jjaderbags answer but does not use accumulator but which is slightly slower
MATCH p=(n)-[rels*1..10]-(m)
WHERE ALL(n in nodes(p) WHERE 1=length(filter(m in nodes(p) WHERE m=n)))
AND( ALL (r IN rels WHERE r.PROP='true')
AND id(n)=1)
WITH p, range(0,length(p)-1) AS idx, nodes(p) as ns, relationships(p) as rs
WHERE ALL (i in idx WHERE
CASE type(rs[i])='SEND'
WHEN TRUE THEN startnode(rs[i])=ns[i]
ELSE TRUE
END)
RETURN nodes(p);