Neo4J Cypher排除反向路径

Question

I have a simple graph where nodes are connected to other nodes eg

Person -[Shops_At]-> Shop

I would like find the number of customers each Shop has, I can do this by matching
Shop <-[Shops_At]- Person -[Shops_At]-> Shop
And counting the number of Person nodes. I can exclude the case where the Shops are the same.

In Cypher how do I stop getting both directions of the path. eg (with id's)

194 <-[Shops_At]- 18 -[Shops_At]-> 200
200 <-[Shops_At]- 18 -[Shops_At]-> 194

I only want each path once.

Update: So The reason I want to do the above query but only get each path once is that I ultimately want to generate a graph where the shops are connected together by an edge that has the weight of the number of shared customers.

So for the above.

200 -[Shares Customers, 18]- 194

I don't want the reverse path in the new graph.

Answer 1

I have determined a way of doing what I wanted.
In the cypher query I can insist on the ID of one shop being smaller than the other

match (n:`shop`)--(p:`person`)--(m:`shop`) WHERE id(n) < id(m) return n,count(p),m

Answer 2

You can do this with a simpler solution :

First match the shops, you'll not have duplicates and count the customers they have:

MATCH (shop:Shop)
MATCH (shop)<-[:Shops_At]-(customer)
RETURN shop, count(*)

EDIT :

Here is a query that will return you shops and the amount of shared customers to other shops in the form :

s       otherShop  weight
animi   libero  10
animi   modi    9
animi   ut  9
animi   nesciunt    8
animi   libero  6
aut tempore 14
aut animi   17
aut in  15
aut ut  11
aut quo 14


MATCH (s:Shop)
MATCH (s)<-[:SHOPS_AT]-(c)
MATCH (otherShop)<-[:SHOPS_AT]-(c)
WHERE otherShop <> s
WITH s, otherShop, count(distinct(c)) as sharedCustomers
RETURN s, otherShop, sharedCustomers as weight
ORDER BY s.name

You can test this query in the following Neo4j console : http://console.neo4j.org/?id=phsywr

Based from this query, you can easily adapt it (after testing the result is what you expect) create relationships between the shops :

MATCH (s:Shop)
MATCH (s)<-[:SHOPS_AT]-(c)
MATCH (otherShop)<-[:SHOPS_AT]-(c)
WHERE otherShop <> s
WITH s, otherShop, count(distinct(c)) as sharedCustomers
MERGE (s)-[:CROSS_SHOP {weight: sharedCustomers}]->(otherShop)