知识图谱使用Python驱动访问Neo4j

Posted 2021-12-12 ZSYL

使用Python驱动访问Neo4j

• 前言
• 1. 安装Python版本的Neo4j驱动
• 2. Driver对象
• 3. Session对象
• 4. StatementResult和Record
• 5. 示例代码

前言

neo4j官方驱动支持Python语言，驱动程序主要包含Driver类型和Session类型。

Driver对象包含Neo4j数据库的详细信息，包括主机url、安全验证等配置，还管理着连接池（Connection Pool）；

Session对象是执行事务单元的逻辑上下文，事务是在Session的上下文中执行的。由于Session不是线程安全的，并能够从Driver对象管理的连接池中回收利用（Recycle）连接，因此，Session对象是轻量级的（lightweight），用完之后应立即销毁（disposable）。

1. 安装Python版本的Neo4j驱动

如果不关注驱动的版本，可以安装最新版本的Python驱动。

pip install neo4j-driver

也可以在pip命令中指定python驱动的版本：

pip install neo4j-driver==$PYTHON_DRIVER_VERSION
pip install neo4j-driver==1.4.0

2. Driver对象

在安装neo4j驱动之后，在python代码中导入GraphDatabase模块，用于查询和更新图数据库：

from neo4j.v1 import GraphDatabase

1，创建Driver对象实例

输入neo4j数据库的uri，用户的安全验证，实例化Driver对象，并创建连接池：

from neo4j.v1 import GraphDatabase
uri = "bolt://localhost:7687"
_driver = GraphDatabase.driver(uri, auth=("neo4j", "password"))

使用close()函数关闭Driver对象分配的任何连接：

_driver.close()

2，使用Driver对象来创建Session对象

Driver对象从连接池中分配连接，创建Session对象：

_session = _driver.session()

3. Session对象

Session的创建是一个轻量级的操作，由于Session不是线程安全的，因此，Session通常应该在单个线程中短暂存续，用完之后立即销毁。

在Python中，推荐在with上下文中创建和销毁Session对象：

def add_person(name):
    with _driver.session() as session:
        session.run("CREATE (a:Person {name: $name})", name=name)

Session对象是执行事务的逻辑上下文，Cypher支持两种方式来提交事务。

1，以自动提交方式提交事务

以自动提交事务的方式执行Cypher查询，在Session对象执行Cypher语句之后，事务立即提交，因此，一次事务只能执行一个Cyper查询，返回的结果是StatementResult对象：

_session.run(statement, parameters=None)

2，以事务函数方式来提交事务

事务函数包含事务的工作单元，以事务函数方式提交事务是neo4j推荐的提交事务的方式，在事务函数方式中，一个事务可以执行多个Cypher查询。

首先，定义事务函数，传递相应的参数（Cypher语句和参数）：

def create_person_node(tx, name):
    tx.run("CREATE (a:Person {name: $name}) RETURN id(a)", name=name)

然后，在Session对象中启动写事务（write_transaction)来调用事务函数，返回的结果是StatementResult对象：

def add_person(driver, name):
    with _driver.session() as session:
        # Caller for transactional unit of work
        return session.write_transaction(create_person_node, name)

4. StatementResult和Record

Session对象执行Cypher查询的结果是StatementResult类型，该类型实际上是由Record对象构成的集合，该类型的常用函数如下：

• keys()：是由Record集合的Key构成的元组
• records()：是由Record对象构成的集合
• single()：从result变量中获取下一个记录，返回值是下一个Record或None
• peek()：从结果中获取下一个Record对象，而该对象仍然保留在结果缓存中，以便后续进行处理。

Record类型是一个有序的Key/Value对的序列，这意味着，Record对象类似于由Key：Value构成的列表，Key字段的值可以通过字段名称或索引来访问：

• items() ：是由元组(key,value)构成的列表
• keys()：是由一个Record对象的key构成的元组
• values()：是由一个Record对象的value构成的元组
• index(key)：返回指定Key在Record对象内的索引

5. 示例代码

class BookmarksExample(object):

    def __init__(self, uri, user, password):
        self._driver = GraphDatabase.driver(uri, auth=(user, password))

    def close(self):
        self._driver.close()

    # Create a person node.
    @classmethod
    def create_person(cls, tx, name):
        tx.run("CREATE (:Person {name: $name})", name=name)

    # Create an employment relationship to a pre-existing company node.
    # This relies on the person first having been created.
    @classmethod
    def employ(cls, tx, person_name, company_name):
        tx.run("MATCH (person:Person {name: $person_name}) "
               "MATCH (company:Company {name: $company_name}) "
               "CREATE (person)-[:WORKS_FOR]->(company)",
               person_name=person_name, company_name=company_name)

    # Create a friendship between two people.
    @classmethod
    def create_friendship(cls, tx, name_a, name_b):
        tx.run("MATCH (a:Person {name: $name_a}) "
               "MATCH (b:Person {name: $name_b}) "
               "MERGE (a)-[:KNOWS]->(b)",
               name_a=name_a, name_b=name_b)

    # Match and display all friendships.
    @classmethod
    def print_friendships(cls, tx):
        result = tx.run("MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name")
        for record in result:
            print("{} knows {}".format(record["a.name"] ,record["b.name"]))

    def main(self):
        saved_bookmarks = []  # To collect the session bookmarks

        # Create the first person and employment relationship.
        with self._driver.session() as session_a:
            session_a.write_transaction(self.create_person, "Alice")
            session_a.write_transaction(self.employ, "Alice", "Wayne Enterprises")
            saved_bookmarks.append(session_a.last_bookmark())

        # Create the second person and employment relationship.
        with self._driver.session() as session_b:
            session_b.write_transaction(self.create_person, "Bob")
            session_b.write_transaction(self.employ, "Bob", "LexCorp")
            saved_bookmarks.append(session_b.last_bookmark())

        # Create a friendship between the two people created above.
        with self._driver.session(bookmarks=saved_bookmarks) as session_c:
            session_c.write_transaction(self.create_friendship, "Alice", "Bob")
            session_c.read_transaction(self.print_friendships)



class Neo4jProvider:

    def __init__(self, uri, user, password):
        self._driver = GraphDatabase.driver(uri, auth=(user, password))

    def close(self):
        self._driver.close()

    def add_greeting_node(self, message):
        with self._driver.session() as session:
            session.write_transaction(self._create_greeting, message)

    @staticmethod
    def _create_greeting(tx, message):
        tx.run("CREATE (a:Greeting) SET a.message = $message ", message=message)

参考：https://www.cnblogs.com/ljhdo/p/10907941.html

---

加油!

感谢!

努力!