neo4j-查询示例

• 查找名为"Cloud Atlas"的电影

match(cloudAtlas {title:"Cloud Atlas"}) return cloudAtlas

• 查找1990年-2000年发行的电影的名称

match(movies:Movie) where movies.released > 1990 and movies.released <2000 return movies.title

• 查找"Tom"参演过的电影,返回电影名,tom,关系

match(ps:Person {name:"Tom"})-[ac:acted_in]->(movie:Movie) return ps,ac,movie.title

• 查找谁导演了电影"Cloud Atlas"

match(ps:Person)-[:directed]->(movie:Movie {title:"Cloud Atlas"}) return ps.name

• 查找与"tom"同出演过电影的人

match(tom:Person {name:"Tom"}) -[:acted_in]->(m:Movie)<-[:acted_in]-[other:Person] return other.name

• 查找与电影"Cloud Atlas"相关的所有人

match (people:Person) -[relatedTo]-(:Movie {title:"Cloud Atlas"})
return people.name,  Type(relatedTo),relatedTo

Type 返回关系的标签,比如是参演了电影还是导演了电影还是监制.而 relatedTo 返回的是关系的属性
这里所说的标签,就是书里所说的类型
执行过程:
首先匹配节点类型为Person类型的节点,然后再匹配节点类型为Movie类型,且节点属性title为Cloud Atlas的电影节点
最后匹配他们之间的所有关系,返回的结果是三列,对应返回的字段
╒══════════════════╤═════════════════╤══════════════════════════════════════════════════════════════════════╕
│"people.name"     │"Type(relatedTo)"│"relatedTo"                                                           │
╞══════════════════╪═════════════════╪══════════════════════════════════════════════════════════════════════╡
│"Jessica Thompson"│"REVIEWED"       │{"summary":"An amazing journey","rating":95}                          │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Jim Broadbent"   │"ACTED_IN"       │{"roles":["Vyvyan Ayrs","Captain Molyneux","Timothy Cavendish"]}      │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Halle Berry"     │"ACTED_IN"       │{"roles":["Luisa Rey","Jocasta Ayrs","Ovid","Meronym"]}               │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Lilly Wachowski" │"DIRECTED"       │{}                                                                    │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Tom Tykwer"      │"DIRECTED"       │{}                                                                    │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Hugo Weaving"    │"ACTED_IN"       │{"roles":["Bill Smoke","Haskell Moore","Tadeusz Kesselring","Nurse Noa│
│                  │                 │kes","Boardman Mephi","Old Georgie"]}                                 │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Tom Hanks"       │"ACTED_IN"       │{"roles":["Zachry","Dr. Henry Goose","Isaac Sachs","Dermot Hoggins"]} │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"David Mitchell"  │"WROTE"          │{}                                                                    │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Lana Wachowski"  │"DIRECTED"       │{}                                                                    │
├──────────────────┼─────────────────┼──────────────────────────────────────────────────────────────────────┤
│"Stefan Arndt"    │"PRODUCED"       │{}                                                                    │
└──────────────────┴─────────────────┴──────────────────────────────────────────────────────────────────────┘

• 查找与演员"Kevin Bacon" 存在4条及以内关系的任何演员和电影

match(people:People {name:"Kevin Bacon"}) - [*1..4] - (something)
return distinct something

执行过程:
首先匹配节点类型为People,属性name为Kevin Bacon的节点,然后将关系深度限制为从1到4再进行遍历,最后返回匹配的所有节点(去重)

• 查找与演员Kevin Bacon与Meg Ryan之间的最短路径

match p= shortestPath((:Person {name:"Kevin Bacon"}) -[*]- (:Person {name:"Meg Ryan"}))  return p

shortestPath 方法是返回找出返回的所有路径中最短的一条

关系推荐小案例

比如要为Tom推荐新的合作伙伴,一个比较好的办法就是通过认识Tom的人的人脉来寻找新的合作伙伴
分析:

1. 先找到Tom还没有合作过的演员,但Tom的合作伙伴曾经与其合作过
2. 找到一个可以向Tom介绍新合作伙伴的人 或者说 找到一个可以向新合作伙伴介绍Tom的人

• 查找没有与Tom合作过的演员

match(tom:Person {name:"Tom Hanks"}) -[:ACTED_IN]->(m:Movie) <-[:ACTED_IN]-(middleman:Person),
(middleman:Person)-[:ACTED_IN]->(n:Movie)<-[:ACTED_IN]-(new_friend:Person)
where not (tom) -[:acted_in]->(n)
return new_friend as new , count(*) as Strength
order by Strength desc

╒═════════════════════════════════════════════╤══════════╕
│"new"                                        │"Strength"│
╞═════════════════════════════════════════════╪══════════╡
│{"name":"Tom Hanks","born":1956}             │12        │
├─────────────────────────────────────────────┼──────────┤
│{"name":"Zach Grenier","born":1954}          │5         │
├─────────────────────────────────────────────┼──────────┤
├─────────────────────────────────────────────┼──────────┤
│{"name":"Jack","born":1962}                  │5         │
├─────────────────────────────────────────────┼──────────┤

分析:
count(*) 是新伙伴与中间人合作的次数
然后根据合作的次数进行排序

• 找人将Tom介绍给Jack

match(tom:Person {name:"Tom"}) -[:ACTED_IN] -> (m:Movie) <-[:ACTED_IN] - (middleman:Person),
(middleman:Person) -[:ACTED_IN] -> (n:Movie) <-[:ACTED_IN] - (jack:Person {name:"Jack"})
return tom,m,middleman,n,jack

清空数据库

注意有关系存在的节点,必须要清除关系后才能清除节点,或者同时清除都可以,这就相当于mysql中的外键联系,必须要删除外键后才能删除数据
下面演示删除所有Person,Movie节点及其所有关系

match(a:Person),(m:Movie) optional match (a)-[r1]-(), (m) - [r2] - () delete r1,r2,a,m

节点写(),代表任何类型的节点.
关系没有箭头,代表任何方向的关系.
关系没有写类型,代表存在的任何关系

清空数据之后,如果想要确认是否都删除完毕,可以使用全量查询检测一下
match(n) return (n)   返回所有类型的所有节点