Neo4j开发者手册3.3：JavaScript版

需积分: 9 161 浏览量更新于2024-07-19 收藏 7.01MB PDF 举报

"Neo4j Developer Manual v3.3 是一本详细介绍如何使用 Neo4j 图数据库，特别是与 JavaScript 集成的指南。该手册涵盖了从安装 Neo4j 到查询优化，再到扩展 Neo4j 的各个核心知识点，并提供了 Cypher 查询语言的详细语法和用例。此外，还涉及了客户端应用程序、HTTP API、事务处理以及自定义函数和插件的开发。此版本手册发布于2017年10月28日，由 Neo4j 团队编写，适用于希望深入理解和使用 Neo4j 的开发者。" Neo4j 是一个领先的图形数据库系统，它利用图形数据模型来存储和检索数据。在 Neo4j 中，节点代表实体，边表示实体之间的关系，而属性则为这些实体和关系添加上下文信息。本手册的核心内容包括： 1. **Introduction** - 部分介绍了图形数据库的基本概念，解释了为什么图形数据库是处理复杂关系数据的理想选择，并概述了 Neo4j 的关键特性。 2. **Get started** - 提供了安装 Neo4j 的步骤，以及如何快速上手使用 Cypher，这是 Neo4j 的声明式图形查询语言。Cypher 用于创建、读取、更新和删除图中的节点和关系。 3. **Cypher** - 是手册的重点，详细介绍了 Cypher 的语法、子句、函数以及模式匹配。Cypher 的简洁语法使得查询和操作图形数据变得直观易懂。 4. **Drivers** - 讲解了如何使用 Neo4j 的驱动程序与数据库进行交互，这包括设置连接、执行查询和管理事务。 5. **HTTP API** - 描述了通过 Transactional Cypher HTTP endpoint 进行远程访问和管理 Neo4j 数据库的方法，以及认证和授权的相关配置。 6. **Extending Neo4j** - 包括自定义功能，如编写用户定义的函数和过程，以及认证和授权插件的开发，这允许开发者扩展 Neo4j 的核心功能以满足特定需求。此外，手册还包含了查询调优、执行计划分析，以及 Neo4j 的状态码参考和术语表，为开发者提供了全面的参考资料。对于任何使用 Neo4j 或考虑将其集成到 JavaScript 应用中的开发者来说，这份文档都是不可或缺的工具。它不仅帮助理解图形数据库的基本原理，还提供了一套完整的实践指南，帮助开发者充分利用 Neo4j 的强大功能。

4.2.2. Matching patterns

Matching patterns is a task for the MATCH statement. We pass the same kind of patterns we’ve used so

far to MATCH to describe what we’re looking for. It is similar to query by example, only that our examples

also include the structures.



A MATCH statement will search for the patterns we specify and return one row per

successful pattern match.

To find the data we’ve created so far, we can start looking for all nodes labeled with the Movie label.

MATCH (m:Movie)

RETURN m

Here’s the result:

This should show both The Matrix and Forrest Gump.

We can also look for a specific person, like Keanu Reeves.

MATCH (p:Person { name:"Keanu Reeves" })

RETURN p

This query returns the matching node:

Note that we only provide enough information to find the nodes, not all properties are required. In

most cases you have key-properties like SSN, ISBN, emails, logins, geolocation or product codes to

look for.

We can also find more interesting connections, like for instance the movies titles that Tom Hanks acted

in and the roles he played.

MATCH (p:Person { name:"Tom Hanks" })-[r:ACTED_IN]->(m:Movie)

RETURN m.title, r.roles

+------------------------------+

| m.title | r.roles |

+------------------------------+

| "Forrest Gump" | ["Forrest"] |

+------------------------------+

1 row

In this case we only returned the properties of the nodes and relationships that we were interested in.

You can access them everywhere via a dot notation identifer.property.

Of course this only lists his role as Forrest in Forrest Gump because that’s all data that we’ve added.

Now we know enough to connect new nodes to existing ones and can combine MATCH and CREATE to

attach structures to the graph.

4.2.3. Attaching structures

To extend the graph with new information, we first match the existing connection points and then

attach the newly created nodes to them with relationships. Adding Cloud Atlas as a new movie for Tom

Hanks could be achieved like this:

MATCH (p:Person { name:"Tom Hanks" })

CREATE (m:Movie { title:"Cloud Atlas",released:2012 })

CREATE (p)-[r:ACTED_IN { roles: ['Zachry']}]->(m)

RETURN p,r,m

Here’s what the structure looks like in the database:

Person

name = 'Tom Hanks'

born = 1956

Movie

title = 'Cloud Atlas'

released = 2012

ACTED_IN

roles = ['Zachry']



It is important to remember that we can assign variables to both nodes and

relationships and use them later on, no matter if they were created or matched.

It is possible to attach both node and relationship in a single CREATE clause. For readability it helps to

split them up though.



A tricky aspect of the combination of MATCH and CREATE is that we get one row per

matched pattern. This causes subsequent CREATE statements to be executed once for

each row. In many cases this is what you want. If that’s not intended, please move

the CREATE statement before the MATCH, or change the cardinality of the query with

means discussed later or use the get or create semantics of the next clause: MERGE.

4.2.4. Completing patterns

Whenever we get data from external systems or are not sure if certain information already exists in

the graph, we want to be able to express a repeatable (idempotent) update operation. In Cypher MERGE

has this function. It acts like a combination of MATCH or CREATE, which checks for the existence of data

first before creating it. With MERGE you define a pattern to be found or created. Usually, as with MATCH

you only want to include the key property to look for in your core pattern. MERGE allows you to provide

additional properties you want to set ON CREATE.

If we wouldn’t know if our graph already contained Cloud Atlas we could merge it in again.

MERGE (m:Movie { title:"Cloud Atlas" })

ON CREATE SET m.released = 2012

RETURN m

+--------------------------------------------+

| m |

+--------------------------------------------+

| Node[5]{title:"Cloud Atlas",released:2012} |

+--------------------------------------------+

1 row

We get a result in any both cases: either the data (potentially more than one row) that was already in

the graph or a single, newly created Movie node.



A MERGE clause without any previously assigned variables in it either matches the full

pattern or creates the full pattern. It never produces a partial mix of matching and

creating within a pattern. To achieve a partial match/create, make sure to use

already defined variables for the parts that shouldn’t be affected.

So foremost MERGE makes sure that you can’t create duplicate information or structures, but it comes

with the cost of needing to check for existing matches first. Especially on large graphs it can be costly

to scan a large set of labeled nodes for a certain property. You can alleviate some of that by creating

supporting indexes or constraints, which we’ll discuss later. But it’s still not for free, so whenever

you’re sure to not create duplicate data use CREATE over MERGE.



MERGE can also assert that a relationship is only created once. For that to work you

have to pass in both nodes from a previous pattern match.

MATCH (m:Movie { title:"Cloud Atlas" })

MATCH (p:Person { name:"Tom Hanks" })

MERGE (p)-[r:ACTED_IN]->(m)

ON CREATE SET r.roles =['Zachry']

RETURN p,r,m

Person

name = 'Tom Hanks'

born = 1956

Movie

title = 'Cloud Atlas'

released = 2012

ACTED_IN

roles = ['Zachry']

In case the direction of a relationship is arbitrary, you can leave off the arrowhead. MERGE will then

check for the relationship in either direction, and create a new directed relationship if no matching

relationship was found.

If you choose to pass in only one node from a preceding clause, MERGE offers an interesting

functionality. It will then only match within the direct neighborhood of the provided node for the given

pattern, and, if not found create it. This can come in very handy for creating for example tree

structures.

CREATE (y:Year { year:2014 })

MERGE (y)<-[:IN_YEAR]-(m10:Month { month:10 })

MERGE (y)<-[:IN_YEAR]-(m11:Month { month:11 })

RETURN y,m10,m11

This is the graph structure that gets created:

Year

year = 2014

Month

month = 11

IN_YEAR

Month

month = 10

IN_YEAR

Here there is no global search for the two Month nodes; they are only searched for in the context of the

Other options are numeric comparisons, matching regular expressions and checking the existence of

values within a list.

The WHERE clause below includes a regular expression match, a greater than comparison and a test to

see if a value exists in a list.

MATCH (p:Person)-[r:ACTED_IN]->(m:Movie)

WHERE p.name =~ "K.+" OR m.released > 2000 OR "Neo" IN r.roles

RETURN p,r,m

+---------------------------------------------------------------------------------------------------------

----------+

| p | r | m

+---------------------------------------------------------------------------------------------------------

----------+

| Node[5]{name:"Tom Hanks",born:1956} | :ACTED_IN[1]{roles:["Zachry"]} | Node[1]{title:"Cloud

Atlas",released:2012} |

+---------------------------------------------------------------------------------------------------------

----------+

1 row

One aspect that might be a little surprising is that you can even use patterns as predicates. Where

MATCH expands the number and shape of patterns matched, a pattern predicate restricts the current

result set. It only allows the paths to pass that satisfy the additional patterns as well (or NOT).

MATCH (p:Person)-[:ACTED_IN]->(m)

WHERE NOT (p)-[:DIRECTED]->()

RETURN p,m

+-----------------------------------------------------------------------------------+

| p | m |

+-----------------------------------------------------------------------------------+

| Node[5]{name:"Tom Hanks",born:1956} | Node[1]{title:"Cloud Atlas",released:2012} |

| Node[5]{name:"Tom Hanks",born:1956} | Node[2]{title:"Forrest Gump",released:1994} |

+-----------------------------------------------------------------------------------+

2 rows

Here we find actors, because they sport an ACTED_IN relationship but then skip those that ever

DIRECTED any movie.

There are also more advanced ways of filtering like list-predicates which we will look at later on.

4.3.2. Returning results

So far we’ve returned only nodes, relationships, or paths directly via their variables. But the RETURN

clause can actually return any number of expressions. But what are actually expressions in Cypher?

The simplest expressions are literal values like numbers, strings and arrays as [1,2,3], and maps like

{name:"Tom Hanks", born:1964, movies:["Forrest Gump", …], count:13}. You can access individual

properties of any node, relationship, or map with a dot-syntax like n.name. Individual elements or

slices of arrays can be retrieved with subscripts like names[0] or movies[1..-1]. Each function

evaluation like length(array), toInteger("12"), substring("2014-07-01",0,4), or

coalesce(p.nickname,"n/a") is also an expression.

Predicates that you’d use in WHERE count as boolean expressions.

Of course simpler expressions can be composed and concatenated to form more complex

expressions.

剩余348页未读，继续阅读

「已注销」

粉丝: 6
资源: 9

Neo4j开发者手册3.3：JavaScript版

neo4j-community-4.4.25-windows

neo4j-community-4.x-unix.tar.gz and neo4j-community-4.x-windows.zip

neo4j-developer-manual-3.3-java

neo4j-operations-manual-3.3.pdf

neo4j-developer-manual-3.1-javascript

neo4j-developer-manual-3.1-java

neo4j-developer-manual-3.1-dotnet

neo4j-developer-manual-3.0-java

neo4j-developer-manual-3.1-python

neo4j-developer-manual-3.1-java开发手册

最新资源