示例来源: Neo4j in Action.

0 准备数据

0.1 node

(user1 { name: 'John Johnson', type: 'User', email: 'jsmith@example.org', age: 35})

with Label:

(user1:Users { name: 'John Johnson', type: 'User', email: 'jsmith@example.org', age: 35})

0.2 relationship

(user1) -[:IS_FRIEND_OF]-> (user2)

with property:

(user1) -[:HAS_SEEN {stars: 5}]-> (movie1)

0.3 sample

create (user1:Users { name: 'John Johnson', type: 'User', email: 'jsmith@example.org', age: 35}),
(user2:Users { name: 'Kate Smith', type: 'User', email: 'ksmith@example.org', age: 35}),
(user3:Users { name: 'Jack Jeffries', type: 'User', email: 'jjeffries@example.org', age: 34}),
(movie1:Movies { name: 'Fargo', type: 'Movie'}),
(movie2:Movies { name: 'Alien', type: 'Movie'}),
(movie3:Movies { name: 'Heat', type: 'Movie'}),
(user1) -[:IS_FRIEND_OF]-> (user2),
(user1) -[:IS_FRIEND_OF]-> (user3),
(user1) -[:HAS_SEEN {stars: 5}]-> (movie1),
(user2) -[:HAS_SEEN {stars: 3}]-> (movie3),
(user3) -[:HAS_SEEN {stars: 4}]-> (movie1),
(user3) -[:HAS_SEEN {stars: 5}]-> (movie2)

1 模式匹配

1.1 使用node和relationship标识符

start user=node(1)
match (user)-[r:HAS_SEEN]->(movie)
return movie; 

//匿名relationship
start user=node(1)
match (user)-[:HAS_SEEN]->(movie)
return movie;

//匿名node
start user=node(1)
match (user)-[r:HAS_SEEN]->()
return r;

1.2 复杂的模式匹配

// 3 nodes, 2 relationships
start john=node(1)
match john-[:IS_FRIEND_OF]->()-[:HAS_SEEN]->(movie)
return movie;

//同一查询中多个模式
start john=node(1)
match
    john-[:IS_FRIEND_OF]->()-[:HAS_SEEN]->(movie),
    john-[r:HAS_SEEN]->(movie)
return movie;

// where条件过滤
start john=node:users(name = "John Johnson")
match john-[:IS_FRIEND_OF]->(user)-[:HAS_SEEN]->(movie)
where NOT john-[:HAS_SEEN]->(movie)
return movie.name;

2 定位起始node

2.1 Id

start john=node(1)
return john;

2.2 Ids

start user=node(1, 3)
match user-[:HAS_SEEN]->movie
return distinct movie;

2.3 index

// index `users`
start john=node:users(name = "John Johnson")
return john;

// native Lucene query
start john=node:users("name:John Johnson")
return john;

// a complex Lucene query
start john=node:users("name:John* AND yearOfBirth<1980")
return john;

2.4 schema-based index

基于Label的索引只能用于查找整个属性值。

match (john:USER)
where john.name='John Johnson'
return john;

2.5 多个起始node

start john=node:users("name:John Johnson"),
    jack=node:users("name:Jack Jeffries")
match john-[:HAS_SEEN]->movie, jack-[:HAS_SEEN]->movie
return movie;

3 过滤数据

// node和relationship的属性值过滤
start john=node:users("name:John Johnson")
match john-[:IS_FRIEND_OF]-(friend)
where friend.yearOfBirth > 1980
return friend;

//使用正则表达式
start john=node:users("name:John Johnson")
match john-[:IS_FRIEND_OF]-(friend)
where friend.email =~ /.*@gmail.com/
return friend;

//使用Cypher内建函数
start john=node:users("name:John Johnson")
match john-[IS_FRIEND_OF]-friend
where has(friend.twitter)
return friend

4 获取结果

4.1 返回property

//node属性
start john= node:users(name = "John Johnson")
match john-[:IS_FRIEND_OF]->(user)-[:HAS_SEEN]->(movie)
where not john-[:HAS_SEEN]->(movie)
return movie.name;

//relationship属性
start john=node:users("name:John Johnson")
match john-[r:HAS_SEEN]-(movie)
return r.stars

4.2 返回relathinship

start john=node:users("name:John Johnson")
match john-[r:HAS_SEEN]-(movie)
return r;

4.3 返回path

// path: `recPath`
start john=node:users(name = "John Johnson")
match recPath = john-[:IS_FRIEND_OF]->(user)-[:HAS_SEEN]->(movie)
where not john-[r:HAS_SEEN]->(movie)
return movie.name, recPath;

4.4 结果分页

start john=node:users("name:John Johnson")
match john-[:HAS_SEEN]->(movie)
return movie
order by movie.name // order
skip 20             // skip 2 pages
limit 10            // 10 in a page

下面涉及更新操作(5-7)。

5 创建新实体

//创建node
create newuser
{
    name: 'Grace Spencer',
    yearOfBirth: 1982,
    email: 'grace@mycompany.com'
}
return newuser;

//创建relationship
start john = node:users(name = "John Johnson"), grace = node(10)
create john-[r:IS_FRIEND_OF]->grace
return r;

// 同时创建node和relationship
start john = node:users(name = "John Johnson")
create john -[r:IS_FRIEND_OF]->
    (grace {
    name: 'Grace Spencer',
    yearOfBirth: 1982, email: 'grace@mycompany.com'
    })
return r, grace;

//使用`unique`仅创建模式中不存在的实体
start john = node:users(name = "John Johnson")
create unique john -[r:IS_FRIEND_OF]->
    (grace {
        name: 'Grace Spencer',
        yearOfBirth: 1982,
        email: 'grace@mycompany.com'
    })
return r, grace;

6 删除数据

//删除node，仅在node没有relationship时
start grace = node(10)
delete grace

//删除node和relationship
start grace = node(10)
match grace-[r]-()
delete grace, r

7 更新node和relationship属性

//更新node属性
start john=node:users(name = "John Johnson")
set john.yearOfBirth = 1973;

//更新多个node的属性
start user=node(1,2)
set user.group = 'ADMINISTRATOR'

//删除node属性,Neo4j不允许null属性值
    start n=node(1)
delete n.group;

下面是Cypher的高级用法(8-11)。

8 聚合

//按`user`聚合，即结果中非所有非聚合字段
start user=node(*)
match user-[:IS_FRIEND_OF]-()
return user, count(*)
order by count(*) desc;

其他数值聚合函数:SUM, AVG, MAX, MIN。

start john=node:users(name = "John Johnson")
match john-[:IS_FRIEND_OF]-(friend)
where HAS(friend.yearOfBirth)
return avg(2014-friend.yearOfBirth);

9 函数

9.1 实体内部属性

ID(node), TYPE(relationship)

//relationship的类型
start n=node:users(name='John Johnson)
match n-[rel]-()
return TYPE(rel), count(*);

9.2 集合函数

HAS(graphEntity.propertyName)
NODES(path):将path转换为node集合
ALL(x in collection where predicate(x))
NONE(x in collection where predicate(x))
ANY(x in collection where predicate(x))
SINGLE(x in collection where predicate(x))

start john=node:users(name = "John Johnson"),
    kate= node:users(name = "Kate Smith"),
match p=john-[:IS_FRIEND_OF*1..3]-(kate)
where ALL(
    user in NODES(p)
    where HAS(user.facebookId)
    )
return p;

10 用WITH子句管道化

// simulate SQL `HAVING` clause
start n=node(1)
match n-[rel]-()
with TYPE(rel) as type, count(*) as count
where count > 1
return type, count;

11 Cypher兼容性

//指定Neo4j的版本
CYPHER 1.8 start n=node(1)
match n-[rel]-()
with TYPE(rel) as type, count(*) as count
where count > 1
return type, count;