性能建议

始终指定目标数据库

在所有查询中，无论是 Driver.executeQuery() 调用还是创建新会话时，都请使用 database 参数指定目标数据库。如果未提供数据库，驱动程序将不得不向服务器发送额外请求以确定默认数据库是什么。单个查询的开销很小，但当查询数量达到数百个时，开销将变得非常显著。

良好实践

await driver.executeQuery('<QUERY>', {}, {database: '{neo4j-database-name}'})
driver.session({database: '{neo4j-database-name}'})

不良实践

await driver.executeQuery('<QUERY>')
driver.session()

注意事务的开销

通过 .executeQuery() 或通过 .executeRead/Write() 提交查询时，服务器会自动将它们封装在一个事务中。这种行为可确保数据库始终处于一致状态，无论事务执行期间发生什么情况（电源中断、软件崩溃等）。

在一系列查询周围创建安全的执行上下文会产生开销，如果驱动程序只是向服务器发送查询并希望它们能顺利通过，则不会存在此开销。开销虽小，但随着查询数量的增加，它会累积。因此，如果您的用例更重视吞吐量而非数据完整性，您可以通过在单个（自动提交）事务中运行所有查询来进一步提升性能。您可以通过创建会话并使用 session.run() 运行所需数量的查询来做到这一点。

优先考虑吞吐量而非数据完整性
let session = driver.session({database: '{neo4j-database-name}'})
for(let i=0; i<1000; i++) {
    await session.run("<QUERY>")
}
session.close()
优先考虑数据完整性而非吞吐量
for(let i=0; i<1000; i++) {
    await driver.executeQuery("<QUERY>", {}, {database: '{neo4j-database-name}'})
    // or session.executeRead/Write() calls
}

将读取查询路由到集群读取器

在集群中，将读取查询路由到任何读取器节点。您可以通过以下方式实现：

良好实践

await driver.executeQuery(
  'MATCH (p:Person) RETURN p.name',
  {},
  {
    routing: 'READ',  // short for neo4j.routing.READ
    database: 'neo4j'
  }
)
let session = driver.session({ database: 'neo4j' })
await session.executeRead(async tx => {
  return await tx.run('MATCH (p:Person) RETURN p.name', {})
})

不良实践

await driver.executeQuery(
  'MATCH (p:Person) RETURN p.name',
  {},
  {
    database: 'neo4j'
  }
)
// defaults to routing = writers
let session = driver.session({ database: 'neo4j' })
await session.executeRead(async tx => {
  return await tx.run('MATCH (p:Person) RETURN p.name', {})
})
// don't ask to write on a read-only operation

创建索引

为您经常用作过滤条件的属性创建索引。例如，如果您经常通过 name 属性查找 Person 节点，则在 Person.name 上创建索引会很有益。您可以使用 CREATE INDEX Cypher 函数为节点和关系创建索引。

// Create an index on Person.name
await driver.executeQuery('CREATE INDEX personName FOR (n:Person) ON (n.name)')

更多信息，请参阅搜索性能索引。

分析查询

分析您的查询以找出可以改进性能的查询。您可以通过在查询前加上 PROFILE 来分析查询。服务器输出可在 ResultSummary 对象的 profile 属性中找到。

const result = await driver.executeQuery('PROFILE MATCH (p {name: $name}) RETURN p', { name: 'Alice' })
console.log(result.summary.profile.arguments['string-representation'])
/*
Planner COST
Runtime PIPELINED
Runtime version 5.0
Batch size 128

+-----------------+----------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+
| Operator        | Details        | Estimated Rows | Rows | DB Hits | Memory (Bytes) | Page Cache Hits/Misses | Time (ms) | Pipeline            |
+-----------------+----------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+
| +ProduceResults | p              |              1 |    1 |       3 |                |                        |           |                     |
| |               +----------------+----------------+------+---------+----------------+                        |           |                     |
| +Filter         | p.name = $name |              1 |    1 |       4 |                |                        |           |                     |
| |               +----------------+----------------+------+---------+----------------+                        |           |                     |
| +AllNodesScan   | p              |             10 |    4 |       5 |            120 |                 9160/0 |   108.923 | Fused in Pipeline 0 |
+-----------------+----------------+----------------+------+---------+----------------+------------------------+-----------+---------------------+

Total database accesses: 12, total allocated memory: 184
*/

如果某些查询速度过慢，以至于您无法在合理的时间内运行它们，您可以改为在查询前加上 EXPLAIN。这将返回服务器用于运行查询的*计划*，但不会实际执行查询。服务器输出可在 ResultSummary 对象的 plan 属性中找到。

const result = await driver.executeQuery('EXPLAIN MATCH (p {name: $name}) RETURN p', { name: 'Alice' })
console.log(result.summary.plan.arguments['string-representation'])
/*
Planner COST
Runtime PIPELINED
Runtime version 5.0
Batch size 128

+-----------------+----------------+----------------+---------------------+
| Operator        | Details        | Estimated Rows | Pipeline            |
+-----------------+----------------+----------------+---------------------+
| +ProduceResults | p              |              1 |                     |
| |               +----------------+----------------+                     |
| +Filter         | p.name = $name |              1 |                     |
| |               +----------------+----------------+                     |
| +AllNodesScan   | p              |             10 | Fused in Pipeline 0 |
+-----------------+----------------+----------------+---------------------+

Total database accesses: ?
*/

指定节点标签

在所有查询中指定节点标签。要了解如何组合标签，请参阅Cypher → 标签表达式。

良好实践

await driver.executeQuery(
  'MATCH (p:Person|Animal {name: $name}) RETURN p',
  { name: 'Alice' }
)
let session = driver.session({database: '{neo4j-database-name}'})
await session.run(
  'MATCH (p:Person|Animal {name: $name}) RETURN p',
  { name: 'Alice' }
)

不良实践

await driver.executeQuery(
  'MATCH (p {name: $name}) RETURN p',
  { name: 'Alice' }
)
let session = driver.session({database: '{neo4j-database-name}'})
await session.run(
  'MATCH (p {name: $name}) RETURN p',
  { name: 'Alice' }
)

批量数据创建

使用 WITH 和 UNWIND Cypher 子句在创建大量记录时批量处理查询。

良好实践

numbers = []
for(let i=0; i<10000; i++) {
  numbers.push({value: Math.random()})
}
await driver.executeQuery(`
    UNWIND $numbers AS node
    MERGE (:Number {value: node.value})
    `, { numbers: numbers }
)

不良实践

for(let i=0; i<10000; i++) {
  await driver.executeQuery(
    'MERGE (:Number {value: $value})',
    { value: Math.random() }
  )
}
将大量数据首次导入新数据库最有效的方式是使用 neo4j-admin database import 命令。

使用查询参数

使用查询参数，而不是将值硬编码或拼接进查询中。这有助于利用数据库的查询缓存。

良好实践

await driver.executeQuery(
  'MATCH (p:Person {name: $name}) RETURN p',
  { name: 'Alice' }  // query parameters
)
let session = driver.session({database: '{neo4j-database-name}'})
await session.run(
  'MATCH (p:Person {name: $name}) RETURN p',
  { name: 'Alice' }  // query parameters
)

不良实践

await driver.executeQuery('MATCH (p:Person {name: "Alice"}) RETURN p')

let name = "Alice"
await driver.executeQuery('MATCH (p:Person {name: "' + name + '"}) RETURN p')
let session = driver.session({database: '{neo4j-database-name}'})
await session.run(
  'MATCH (p:Person {name: "Alice"}) RETURN p',
  // or 'MATCH (p:Person {name: ' + name + '}) RETURN p'
  {}
)

并发

使用异步查询。如果您在应用程序中并行化复杂且耗时的查询，这可能会对性能产生更大的影响，但如果只是运行许多简单查询，则影响不大。

仅在需要时使用 MERGE 进行创建

Cypher 子句 MERGE 方便进行数据创建，因为它允许在给定模式的精确克隆已存在时避免重复数据。然而，它要求数据库运行*两个*查询：它首先需要 MATCH 模式，然后才能 CREATE 它（如果需要）。

如果您已经知道要插入的数据是新数据，请避免使用 MERGE，而是直接使用 CREATE —— 这实际上可以将数据库查询的数量减半。

过滤通知

过滤服务器应生成的通知类别和/或严重性。

词汇表

LTS

长期支持 (LTS) 版本是保证在数年内获得支持的版本。Neo4j 4.4 是 LTS 版本，Neo4j 5 也将有一个 LTS 版本。

Aura

Aura 是 Neo4j 的全托管云服务。它提供免费和付费计划。

Cypher

Cypher 是 Neo4j 的图查询语言，可让您从数据库中检索数据。它类似于 SQL，但适用于图。

APOC

Awesome Procedures On Cypher (APOC) 是一个包含（许多）无法在 Cypher 本身中轻松表达的函数的库。

Bolt

Bolt 是用于 Neo4j 实例和驱动程序之间交互的协议。默认情况下，它侦听端口 7687。

ACID

原子性、一致性、隔离性、持久性 (ACID) 是保证数据库事务可靠处理的属性。符合 ACID 的 DBMS 可确保数据库中的数据即使在发生故障时也保持准确和一致。

最终一致性

如果数据库提供所有集群成员将在某个时间点存储最新版本数据的保证，则该数据库是最终一致的。

因果一致性

如果集群的每个成员都以相同的顺序看到读写查询，则数据库是因果一致的。这比最终一致性更强。

NULL

null 标记不是一种类型，而是值缺失的占位符。有关更多信息，请参阅Cypher → 处理 null。

事务

事务是工作的一个单元，它要么整体提交，要么在失败时回滚。一个例子是银行转账：它涉及多个步骤，但所有步骤都必须成功或被撤销，以避免资金从一个账户中扣除但未添加到另一个账户的情况发生。

反压

反压是阻止数据流动的力。它确保客户端不会因数据流速过快而无法处理。

事务函数

事务函数是由 executeRead 或 executeWrite 调用执行的回调。在服务器故障时，驱动程序会自动重新执行该回调。

驱动程序

一个 Driver 对象包含建立与 Neo4j 数据库连接所需的详细信息。

© . All rights reserved.