零、相关资料

zhuanlan.zhihu.com/p/398323729

blog.csdn.net/u013250861/…

一、命令介绍

命令	描述
CREATE	用于创建节点和关系。
MATCH	用于检索节点和关系。
MERGE	用于检索或创建节点和关系，如果它们不存在，则创建它们。
WHERE	用于过滤数据，根据条件筛选节点和关系。
DELETE	用于删除节点和关系。
SORT	用于对结果进行排序。
RETURN	用于指定要从查询中返回的数据。
WITH	用于在查询中创建中间结果，并将这些结果传递给后续操作。
字符串函数	包括SUBSTRING、TOUPPER、TOLOWER等，用于处理字符串属性的值。
聚合函数	包括COUNT、SUM、AVG、MIN和MAX等，用于执行聚合操作。
FOREACH	用于对集合中的每个元素执行操作。
UNWIND	用于展开集合以进行处理。
CASE	用于执行条件分支操作。
DISTINCT	用于返回唯一的结果。
LIMIT	用于限制返回结果的数量。
SKIP	用于跳过查询结果的前几行。
START	用于启动匹配节点的查询。
INDEX	用于创建和删除索引以加速查询。
ORDER BY	用于按指定属性排序查询结果。
COLLECT	用于将结果收集到集合中。

1.1 一些前置函数

from py2neo import Graph
"""
host:服务器ip地址，默认为'localhost'
http_port:http协议——服务器监听端口，默认7474
https_port:https协议——服务器监听端口，默认7473
user:登录用户名，默认'neo4j'
password:登录密码，无默认值，故若数据库其他参数都为默认值，则可直接通过密码登录
"""
def connect():
    graph = Graph('http://localhost:7474', auth=("neo4j", "88888888"), name="neo4j")
    return graph

import connect
def deleteAll():
    g = connect.connect()
    query = "MATCH (n) DETACH DELETE n"
    g.run(query)
    print("删除结点成功")

二、CREATE

from py2neo import Node
import connect
graph = connect.connect()
# 示例1
# 使用graph.run执行CREATE命令创建一个节点
query = "CREATE (p:Person {name: $name, age: $age})"
parameters = {"name": "Alice", "age": 30}
graph.run(query, parameters=parameters)
print("示例1运行完成")


# 示例2
# 创建名为"Bob"的Person节点
person_node = Node("Person", name="Bob")
graph.create(person_node)

# 创建名为"ABC Corp"的Company节点
company_node = Node("Company", name="ABC Corp")
graph.create(company_node)

# 使用graph.run执行CREATE命令创建一个关系，使用占位符%s传递变量
query = "MATCH (p:Person {name: '%s'}), (c:Company {name: '%s'}) CREATE (p)-[:WORKS_FOR]->(c)" % ("Bob", "ABC Corp")
graph.run(query)
print("示例2运行完成")

命令形式：

创建结点：CREATE (p:Person {name: Alice, age: 30})

创建关系：MATCH (p:Person {name: 'Bob'}), (c:Company {name: 'ABC Corp'}) CREATE (p)-[:WORKS_FOR]->(c)

三、MATCH

from py2neo import Node
import connect
import delete
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建一个Product节点
product_node = Node("Product", name="Widget")
graph.create(product_node)

# 使用graph.run执行MATCH命令，使用%传参
query = "MATCH (n:%s) RETURN n" % "Product"
result = graph.run(query)

# 打印结果
for record in result:
    print(record["n"])
print("示例1完成")

四、MERGE

from py2neo import Node
import connect
import delete
delete.deleteAll()
graph = connect.connect()

#示例1
# 使用MERGE命令创建Company节点，如果不存在则创建
query = "MERGE (c:Company {name: 'ABC Corp'}) RETURN c"
result = graph.run(query)

# 打印结果
for record in result:
    print(record["c"])
print("完成示例1")

#示例2
# 创建一个Person节点
query = "CREATE (p:Person {name: 'Alice'})"
graph.run(query)

# 使用MERGE命令创建Person节点，如果已存在则返回现有节点
query = "MERGE (p:Person {name: 'Alice'}) RETURN p"
result = graph.run(query)

# 打印结果
for record in result:
    print(record["p"])
print("完成示例2")

#示例3
# 创建两个节点
query = "CREATE (p:Person {name: 'Bob'}), (c:Company {name: 'XYZ Inc'})"
graph.run(query)

# 使用MERGE命令创建关系边，如果关系已存在则返回现有关系
query = "MATCH (p:Person {name: 'Bob'}), (c:Company {name: 'XYZ Inc'}) MERGE (p)-[:WORKS_FOR]->(c)"
graph.run(query)

# 查询创建的关系
query = "MATCH (p:Person {name: 'Bob'})-[r:WORKS_FOR]->(c:Company {name: 'XYZ Inc'}) RETURN r"
result = graph.run(query)

# 打印结果
for record in result:
    print(record["r"])
print("完成示例3")

五、WHERE

import delete
import connect
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建两个Person节点
query = "CREATE (p1:Person {name: 'Alice', age: 25}), (p2:Person {name: 'Bob', age: 30})"
graph.run(query)

# 使用WHERE命令过滤满足条件的Person节点
query = "MATCH (p:Person) WHERE p.age > 28 RETURN p"
result = graph.run(query)

# 打印结果
for record in result:
    print(record["p"])
print("示例1完成")

#示例2
# 创建两个节点和关系
query = "CREATE (p1:Person {name: 'Alice'}), (p2:Person {name: 'Bob'}), (p1)-[:FRIENDS]->(p2)"
graph.run(query)

# 使用WHERE命令过滤满足条件的关系边
query = "MATCH (p1:Person)-[r:FRIENDS]->(p2:Person) WHERE p1.name = 'Alice' RETURN r"
result = graph.run(query)

# 打印结果
for record in result:
    print(record["r"])
print("示例2完成")

六、DELETE

import delete
import connect
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建一个Person节点
query = "CREATE (p:Person {name: 'Alice'})"
graph.run(query)

# 使用DELETE命令删除特定Person节点
query = "MATCH (p:Person {name: 'Alice'}) DELETE p"
graph.run(query)

# 检查节点是否已被删除
query = "MATCH (p:Person {name: 'Alice'}) RETURN p"
result = graph.run(query)

# 打印结果
for record in result:
    print(record)
print("完成示例1")

#示例2
# 创建两个节点和关系边
query = "CREATE (p1:Person {name: 'Alice'}), (p2:Person {name: 'Bob'}), (p1)-[:FRIENDS]->(p2)"
graph.run(query)

# 使用DELETE命令删除特定FRIENDS关系边
query = "MATCH (p1:Person)-[r:FRIENDS]->(p2:Person) WHERE p1.name = 'Alice' DELETE r"
graph.run(query)

# 检查关系边是否已被删除
query = "MATCH (p1:Person)-[r:FRIENDS]->(p2:Person) WHERE p1.name = 'Alice' RETURN r"
result = graph.run(query)

# 打印结果
for record in result:
    print(record)
print("完成示例2")

七、ORDER BY

import delete
import connect

delete.deleteAll()
graph = connect.connect()

#示例1
# 创建多个Person节点，每个节点都有年龄属性
query = """
CREATE (:Person {name: 'Alice', age: 30}),
       (:Person {name: 'Bob', age: 25}),
       (:Person {name: 'Charlie', age: 35})
"""
graph.run(query)

# 使用SORT命令对节点按年龄升序排序
query = "MATCH (p:Person) RETURN p.name, p.age ORDER BY p.age"
result = graph.run(query)

# 打印排序后的结果
for record in result:
    print(f"Name: {record['p.name']}, Age: {record['p.age']}")
print("="*20)
print(record.data())
print(record.keys())
print(record.values())
print(record.items())
print("="*20)
print("示例1完成")

#示例2
# 创建多个Person节点，每个节点都有年龄属性
query = """
CREATE (:Person {name: 'lucy', age: 30}),
       (:Person {name: 'john', age: 25}),
       (:Person {name: 'mike', age: 35})
"""
graph.run(query)

# 使用SORT命令对节点按年龄降序排序
query = "MATCH (p:Person) RETURN p.name, p.age ORDER BY p.age DESC"
result = graph.run(query)

# 打印排序后的结果
for record in result:
    print(f"Name: {record['p.name']}, Age: {record['p.age']}")
print("示例2完成")

八、RETURN

上述案例已经提到过了

九、WITH

import delete
import connect
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建多个Person节点
query = """
CREATE (p1:Person {name: 'Alice'}),
       (p2:Person {name: 'Bob'}),
       (p3:Person {name: 'Charlie'}),
       (p4:Person {name: 'David'})
"""
graph.run(query)

# 创建Friend关系
query = """
MATCH (p1:Person {name: 'Alice'}), (p2:Person {name: 'Bob'})
CREATE (p1)-[:FRIEND]->(p2)
"""
graph.run(query)

# 使用WITH命令筛选节点
query = """
MATCH (p:Person)-[:FRIEND]->(friend:Person)
WITH p, friend
WHERE p.name = 'Alice'
RETURN p.name, friend.name
"""
result = graph.run(query)
# 返回Alice的名字和她的朋友的名字

# 打印结果
for record in result:
    print(f"{record['p.name']} is friends with {record['friend.name']}")
print("完成示例1")


#示例2
# 创建多个Person节点
query = """
CREATE (p1:Person {name: 'Alice'}),
       (p2:Person {name: 'Bob'}),
       (p3:Person {name: 'Charlie'}),
       (p4:Person {name: 'David'})
"""
graph.run(query)

# 创建Friend关系
query = """
MATCH (p1:Person {name: 'Alice'}), (p2:Person {name: 'Bob'})
CREATE (p1)-[:FRIEND]->(p2)
"""
graph.run(query)

# 使用WITH命令处理聚合结果
query = """
MATCH (p:Person)-[:FRIEND]->(friend:Person)
WITH p, COUNT(friend) AS friendCount
RETURN p.name, friendCount
"""
result = graph.run(query)

# 返回alice的朋友的数量

# 打印结果
for record in result:
    print(f"{record['p.name']} has {record['friendCount']} friends")
print("完成示例2")

十、字符串函数

import delete
import connect
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建一个Person节点
query = "CREATE (p:Person {name: 'Alice'})"
graph.run(query)

# 使用Cypher查询和toUpper字符串函数将名称转换为大写
query = "MATCH (p:Person) SET p.name = toUpper(p.name) RETURN p.name"
result = graph.run(query)

# 打印结果
for record in result:
    print(f"Name (uppercase): {record['p.name']}")
print("完成示例1")


#示例2
# 创建一个Person节点
query = "CREATE (p:Person {name: 'Alice Johnson'})"
graph.run(query)

# 使用Cypher查询和substring字符串函数提取子字符串
query = "MATCH (p:Person) SET p.subname = substring(p.name, 1, 5) RETURN p.subname"
result = graph.run(query)

# 打印结果
for record in result:
    print(f"Substring: {record['p.subname']}")
print("完成示例2")

十一、聚合函数

import delete
import connect
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建多个Person节点
query = """
CREATE (p1:Person {name: 'Alice'}),
       (p2:Person {name: 'Bob'}),
       (p3:Person {name: 'Charlie'})
"""
graph.run(query)

# 使用Cypher查询和count聚合函数计算节点数量
query = "MATCH (p:Person) RETURN count(p) AS numberOfPeople"
result = graph.run(query)

# 打印结果
for record in result:
    print(f"Number of People: {record['numberOfPeople']}")
print("完成示例1")

#示例2
# 创建多个Product节点，每个节点都有价格属性
query = """
CREATE (p1:Product {name: 'Laptop', price: 1000}),
       (p2:Product {name: 'Phone', price: 500}),
       (p3:Product {name: 'Tablet', price: 300})
"""
graph.run(query)

# 使用Cypher查询和sum聚合函数计算价格总和
query = "MATCH (p:Product) RETURN sum(p.price) AS totalPrice"
result = graph.run(query)

# 打印结果
for record in result:
    print(f"Total Price: ${record['totalPrice']}")
print("完成示例2")

十二、FOREACH

import delete
import connect
delete.deleteAll()
graph = connect.connect()

# 创建多个 Person 节点的名称列表
people = ["Alice", "Bob", "Charlie"]

# 使用 FOREACH 循环创建节点并为它们添加属性
query = """
FOREACH (name IN $people |
    CREATE (p:Person {name: name, age: 30})
)
"""

graph.run(query, people=people)

十三、UNWIND

import delete
import connect
delete.deleteAll()
graph = connect.connect()

#示例1
# 创建多个Person节点
query = """
CREATE (p1:Person {name: 'john'}),
       (p2:Person {name: 'Bob'}),
       (p3:Person {name: 'Charlie'})
"""
graph.run(query)

# 使用FOREACH循环创建Friend关系边
friendships = [
    {"name1": "john", "name2": "Bob"},
    {"name1": "john", "name2": "Charlie"},
    {"name1": "Bob", "name2": "Charlie"}
]
query = """
UNWIND $friendships AS friendship
MATCH (p1:Person {name: friendship.name1})
MATCH (p2:Person {name: friendship.name2})
MERGE (p1)-[:FRIEND]->(p2)
"""
graph.run(query, friendships=friendships)
print("完成示例1")

十四、CASE

import delete
import connect
delete.deleteAll()
graph = connect.connect()
#示例1
# 创建一个 Person 节点并设置属性
isStudent = True  # 可以根据条件设定

query = """
CREATE (p:Person {name: 'Alice', age: 30,
    status: CASE
        WHEN $isStudent THEN 'Student'
        ELSE 'Employee'
    END
})
"""

graph.run(query, isStudent=isStudent)
print("完成案例1")

#示例2
# 创建一个 Person 节点
query = "CREATE (p:Person {name: 'Bob', age: 35})"

graph.run(query)

# 使用 CASE 语句设置节点属性
query = """
MATCH (p:Person {name: 'Bob'})
SET p.role = CASE
    WHEN p.age < 30 THEN 'Junior'
    WHEN p.age >= 30 AND p.age < 40 THEN 'Senior'
    ELSE 'Unknown'
END
"""

graph.run(query)
print("完成案例2")

十五、LIMIT

MATCH (n) RETURN n LIMIT 25

Cypher语言

零、相关资料

一、命令介绍

1.1 一些前置函数

二、CREATE

三、MATCH

四、MERGE

五、WHERE

六、DELETE

七、ORDER BY

八、RETURN

九、WITH

十、字符串函数

十一、聚合函数

十二、FOREACH

十三、UNWIND

十四、CASE

十五、LIMIT