1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

// 创建用户节点
CREATE (alice:User {name: "Alice", age: 28, joined: date("2019-03-15")})
CREATE (bob:User {name: "Bob", age: 32, joined: date("2018-11-22")})
CREATE (charlie:User {name: "Charlie", age: 45, joined: date("2020-01-05")})
CREATE (david:User {name: "David", age: 23, joined: date("2021-07-30")})
CREATE (emma:User {name: "Emma", age: 37, joined: date("2017-06-12")})
CREATE (frank:User {name: "Frank", age: 26, joined: date("2020-10-18")})
CREATE (grace:User {name: "Grace", age: 31, joined: date("2019-08-24")})
CREATE (hannah:User {name: "Hannah", age: 29, joined: date("2018-05-11")})
CREATE (ian:User {name: "Ian", age: 42, joined: date("2021-02-09")})
CREATE (julia:User {name: "Julia", age: 35, joined: date("2017-12-03")})

// 创建帖子节点
CREATE (post1:Post {title: "Graph Databases", content: "Neo4j is amazing", created: datetime("2021-01-15T13:37:00")})
CREATE (post2:Post {title: "Cypher Tips", content: "Learn how to query effectively", created: datetime("2021-02-20T09:15:00")})
CREATE (post3:Post {title: "Data Modeling", content: "Nodes and relationships", created: datetime("2021-03-10T17:22:00")})
CREATE (post4:Post {title: "Complex Queries", content: "Advanced pattern matching", created: datetime("2021-04-05T11:05:00")})
CREATE (post5:Post {title: "Performance Tuning", content: "Optimizing your database", created: datetime("2021-05-12T14:30:00")})
CREATE (post6:Post {title: "Graph Algorithms", content: "Finding patterns in data", created: datetime("2021-06-08T10:45:00")})
CREATE (post7:Post {title: "Real-world Applications", content: "Case studies", created: datetime("2021-07-15T16:20:00")})
CREATE (post8:Post {title: "Getting Started", content: "First steps with Neo4j", created: datetime("2021-08-23T12:10:00")})

// 创建兴趣节点
CREATE (tech:Interest {name: "Technology", category: "Professional"})
CREATE (music:Interest {name: "Music", category: "Hobby"})
CREATE (sports:Interest {name: "Sports", category: "Hobby"})
CREATE (travel:Interest {name: "Travel", category: "Lifestyle"})
CREATE (cooking:Interest {name: "Cooking", category: "Hobby"})
CREATE (reading:Interest {name: "Reading", category: "Hobby"})

// 创建用户与帖子之间的关系（CREATED）
MATCH (alice:User {name: "Alice"}), (post1:Post {title: "Graph Databases"})
CREATE (alice)-[:CREATED]->(post1)

MATCH (bob:User {name: "Bob"}), (post2:Post {title: "Cypher Tips"})
CREATE (bob)-[:CREATED]->(post2)

MATCH (charlie:User {name: "Charlie"}), (post3:Post {title: "Data Modeling"})
CREATE (charlie)-[:CREATED]->(post3)

MATCH (david:User {name: "David"}), (post4:Post {title: "Complex Queries"})
CREATE (david)-[:CREATED]->(post4)

MATCH (emma:User {name: "Emma"}), (post5:Post {title: "Performance Tuning"})
CREATE (emma)-[:CREATED]->(post5)

MATCH (alice:User {name: "Alice"}), (post6:Post {title: "Graph Algorithms"})
CREATE (alice)-[:CREATED]->(post6)

MATCH (bob:User {name: "Bob"}), (post7:Post {title: "Real-world Applications"})
CREATE (bob)-[:CREATED]->(post7)

MATCH (charlie:User {name: "Charlie"}), (post8:Post {title: "Getting Started"})
CREATE (charlie)-[:CREATED]->(post8)

// 创建用户与帖子之间的关系（LIKED）
MATCH (alice:User {name: "Alice"}), (post2:Post {title: "Cypher Tips"})
CREATE (alice)-[:LIKED {on: date("2021-02-21")}]->(post2)

MATCH (bob:User {name: "Bob"}), (post1:Post {title: "Graph Databases"})
CREATE (bob)-[:LIKED {on: date("2021-01-16")}]->(post1)

MATCH (charlie:User {name: "Charlie"}), (post1:Post {title: "Graph Databases"})
CREATE (charlie)-[:LIKED {on: date("2021-01-17")}]->(post1)

MATCH (david:User {name: "David"}), (post1:Post {title: "Graph Databases"})
CREATE (david)-[:LIKED {on: date("2021-01-18")}]->(post1)

MATCH (emma:User {name: "Emma"}), (post1:Post {title: "Graph Databases"})
CREATE (emma)-[:LIKED {on: date("2021-01-20")}]->(post1)

MATCH (frank:User {name: "Frank"}), (post2:Post {title: "Cypher Tips"})
CREATE (frank)-[:LIKED {on: date("2021-02-22")}]->(post2)

MATCH (grace:User {name: "Grace"}), (post3:Post {title: "Data Modeling"})
CREATE (grace)-[:LIKED {on: date("2021-03-12")}]->(post3)

MATCH (hannah:User {name: "Hannah"}), (post4:Post {title: "Complex Queries"})
CREATE (hannah)-[:LIKED {on: date("2021-04-07")}]->(post4)

MATCH (ian:User {name: "Ian"}), (post5:Post {title: "Performance Tuning"})
CREATE (ian)-[:LIKED {on: date("2021-05-15")}]->(post5)

MATCH (julia:User {name: "Julia"}), (post6:Post {title: "Graph Algorithms"})
CREATE (julia)-[:LIKED {on: date("2021-06-10")}]->(post6)

// 创建用户与兴趣之间的关系（INTERESTED_IN）
MATCH (alice:User {name: "Alice"}), (tech:Interest {name: "Technology"})
CREATE (alice)-[:INTERESTED_IN {level: "Expert"}]->(tech)

MATCH (alice:User {name: "Alice"}), (music:Interest {name: "Music"})
CREATE (alice)-[:INTERESTED_IN {level: "Intermediate"}]->(music)

MATCH (bob:User {name: "Bob"}), (tech:Interest {name: "Technology"})
CREATE (bob)-[:INTERESTED_IN {level: "Expert"}]->(tech)

MATCH (bob:User {name: "Bob"}), (sports:Interest {name: "Sports"})
CREATE (bob)-[:INTERESTED_IN {level: "Beginner"}]->(sports)

MATCH (charlie:User {name: "Charlie"}), (tech:Interest {name: "Technology"})
CREATE (charlie)-[:INTERESTED_IN {level: "Expert"}]->(tech)

MATCH (charlie:User {name: "Charlie"}), (reading:Interest {name: "Reading"})
CREATE (charlie)-[:INTERESTED_IN {level: "Advanced"}]->(reading)

MATCH (david:User {name: "David"}), (tech:Interest {name: "Technology"})
CREATE (david)-[:INTERESTED_IN {level: "Intermediate"}]->(tech)

MATCH (emma:User {name: "Emma"}), (tech:Interest {name: "Technology"})
CREATE (emma)-[:INTERESTED_IN {level: "Expert"}]->(tech)

MATCH (emma:User {name: "Emma"}), (cooking:Interest {name: "Cooking"})
CREATE (emma)-[:INTERESTED_IN {level: "Advanced"}]->(cooking)

MATCH (frank:User {name: "Frank"}), (sports:Interest {name: "Sports"})
CREATE (frank)-[:INTERESTED_IN {level: "Expert"}]->(sports)

MATCH (grace:User {name: "Grace"}), (travel:Interest {name: "Travel"})
CREATE (grace)-[:INTERESTED_IN {level: "Advanced"}]->(travel)

MATCH (hannah:User {name: "Hannah"}), (music:Interest {name: "Music"})
CREATE (hannah)-[:INTERESTED_IN {level: "Expert"}]->(music)

MATCH (ian:User {name: "Ian"}), (reading:Interest {name: "Reading"})
CREATE (ian)-[:INTERESTED_IN {level: "Intermediate"}]->(reading)

MATCH (julia:User {name: "Julia"}), (cooking:Interest {name: "Cooking"})
CREATE (julia)-[:INTERESTED_IN {level: "Expert"}]->(cooking)

// 创建用户之间的 FOLLOWS 关系
MATCH (alice:User {name: "Alice"}), (bob:User {name: "Bob"})
CREATE (alice)-[:FOLLOWS {since: date("2020-01-15")}]->(bob)

MATCH (alice:User {name: "Alice"}), (charlie:User {name: "Charlie"})
CREATE (alice)-[:FOLLOWS {since: date("2020-02-10")}]->(charlie)

MATCH (bob:User {name: "Bob"}), (david:User {name: "David"})
CREATE (bob)-[:FOLLOWS {since: date("2021-08-05")}]->(david)

MATCH (charlie:User {name: "Charlie"}), (emma:User {name: "Emma"})
CREATE (charlie)-[:FOLLOWS {since: date("2019-11-20")}]->(emma)

MATCH (david:User {name: "David"}), (alice:User {name: "Alice"})
CREATE (david)-[:FOLLOWS {since: date("2021-09-12")}]->(alice)

MATCH (emma:User {name: "Emma"}), (bob:User {name: "Bob"})
CREATE (emma)-[:FOLLOWS {since: date("2018-07-30")}]->(bob)

MATCH (frank:User {name: "Frank"}), (alice:User {name: "Alice"})
CREATE (frank)-[:FOLLOWS {since: date("2021-01-05")}]->(alice)

MATCH (grace:User {name: "Grace"}), (bob:User {name: "Bob"})
CREATE (grace)-[:FOLLOWS {since: date("2020-05-22")}]->(bob)

MATCH (hannah:User {name: "Hannah"}), (charlie:User {name: "Charlie"})
CREATE (hannah)-[:FOLLOWS {since: date("2019-09-15")}]->(charlie)

MATCH (ian:User {name: "Ian"}), (david:User {name: "David"})
CREATE (ian)-[:FOLLOWS {since: date("2021-08-18")}]->(david)

MATCH (julia:User {name: "Julia"}), (emma:User {name: "Emma"})
CREATE (julia)-[:FOLLOWS {since: date("2018-11-27")}]->(emma)

1
2
3
4

// 返回前 5 个用户
MATCH (u:User)
RETURN u.name, u.age
LIMIT 5

1
2
3
4

// 跳过前 5 个用户，返回其余用户
MATCH (u:User)
RETURN u.name, u.age
SKIP 5

1
2
3
4
5
6

// 返回第二页的用户（假设每页 3 个用户）
MATCH (u:User)
RETURN u.name, u.age
ORDER BY u.name
SKIP 3
LIMIT 3

1
2
3
4
5
6

// 找出发布帖子数最多的创作者（第二页，每页 2 条）
MATCH (u:User)-[:CREATED]->(p:Post)
RETURN u.name AS Creator, count(p) AS PostCount
ORDER BY PostCount DESC
SKIP 2
LIMIT 2

1
2
3

// 创建一个新用户（如果不存在的话）
MERGE (u:User {name: "Kevin"})
RETURN u

1
2
3
4
5

// 创建或更新用户
MERGE (u:User {name: "Kevin"})
ON CREATE SET u.age = 33, u.joined = date()
ON MATCH SET u.lastSeen = date()
RETURN u

1
2
3
4
5

// 确保 Kevin 对 Technology 有兴趣
MATCH (u:User {name: "Kevin"}), (i:Interest {name: "Technology"})
MERGE (u)-[r:INTERESTED_IN]->(i)
ON CREATE SET r.level = "Beginner", r.since = date()
RETURN u, r, i

1
2
3
4
5

// 确保 Alice 关注 David（如果尚未关注的话）
MATCH (alice:User {name: "Alice"}), (david:User {name: "David"})
MERGE (alice)-[f:FOLLOWS]->(david)
ON CREATE SET f.since = date()
RETURN alice.name, "now follows", david.name

1
2
3

// 统计用户总数
MATCH (u:User)
RETURN count(u) AS TotalUsers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 按年龄段统计用户
MATCH (u:User)
RETURN 
  CASE
    WHEN u.age < 30 THEN "Under 30"
    WHEN u.age >= 30 AND u.age < 40 THEN "30-39"
    ELSE "40+"
  END AS AgeGroup,
  count(u) AS Count
ORDER BY AgeGroup

1
2
3
4
5
6

// 计算用户年龄的平均值、最小值和最大值
MATCH (u:User)
RETURN 
  avg(u.age) AS AverageAge,
  min(u.age) AS YoungestAge,
  max(u.age) AS OldestAge

1
2

// 收集每个用户的所有兴趣
MATCH (u:User)-[:INTERESTED_IN]->(i:Interest)

1
2
3
4
5
6
7
8
9

// 找出最受欢迎的兴趣，带分页
MATCH (i:Interest)<-[:INTERESTED_IN]-(u:User)
RETURN 
  i.name AS Interest,
  i.category AS Category,
  count(u) AS Popularity
ORDER BY Popularity DESC
SKIP 1
LIMIT 3

1
2
3
4
5

// 确保唯一的点赞关系并附带时间戳
MATCH (u:User {name: "Kevin"}), (p:Post {title: "Cypher Tips"})
MERGE (u)-[l:LIKED]->(p)
ON CREATE SET l.on = date()
RETURN u.name, "liked", p.title, "on", l.on

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 根据发帖数和点赞数查找最活跃的用户
MATCH (u:User)
OPTIONAL MATCH (u)-[:CREATED]->(p:Post)
OPTIONAL MATCH (u)-[:LIKED]->(liked:Post)
RETURN 
  u.name AS User,
  count(DISTINCT p) AS PostsCreated,
  count(DISTINCT liked) AS PostsLiked,
  count(DISTINCT p) + count(DISTINCT liked) AS ActivityScore
ORDER BY ActivityScore DESC
LIMIT 5

1
2
3
4
5
6
7
8
9

// 基于与帖子创建者共享的兴趣，为 Kevin 推荐帖子
MATCH (kevin:User {name: "Kevin"})-[:INTERESTED_IN]->(i:Interest)<-[:INTERESTED_IN]-(creator:User),
      (creator)-[:CREATED]->(p:Post)
WHERE NOT (kevin)-[:CREATED|LIKED]->(p)
WITH p, count(DISTINCT i) AS SharedInterests, collect(DISTINCT i.name) AS InterestList
ORDER BY SharedInterests DESC
LIMIT 3
MERGE (kevin:User {name: "Kevin"})
RETURN p.title AS RecommendedPost, SharedInterests, InterestList

1
2
3
4
5
6

// 深度分页的更好做法
MATCH (u:User)
WHERE u.joined > $lastJoinDate OR (u.joined = $lastJoinDate AND u.name > $lastName)
RETURN u.name, u.joined
ORDER BY u.joined, u.name
LIMIT 5

1
2
3
4

// 良好实践：先匹配节点，再合并关系
MATCH (u1:User {name: "Kevin"}), (u2:User {name: "Alice"})
MERGE (u1)-[f:FOLLOWS]->(u2)
ON CREATE SET f.since = date()

1
2
3
4
5
6
7

// 使用 WITH 进行复杂聚合
MATCH (u:User)-[:CREATED]->(p:Post)
WITH u, count(p) AS PostCount
WHERE PostCount > 1
MATCH (u)-[:INTERESTED_IN]->(i:Interest)
RETURN u.name AS User, PostCount, collect(i.name) AS Interests
ORDER BY PostCount DESC