Neo4j 3.2开发者指南：从入门到Cypher详解

需积分: 13 21 浏览量更新于2024-07-19 收藏 7.03MB PDF 举报

Neo4j图数据库官网开发手册（英文版）是专为Neo4j 3.2版本设计的一份详尽指南，由Neo4j团队编写。该手册主要分为以下几个核心部分： 1. **介绍**：这部分着重于介绍图数据库的基本概念以及Neo4j在图数据处理领域的独特优势。它帮助读者理解图数据模型如何与传统关系型数据库不同，以及Neo4j如何利用其强大的链接数据能力。 2. ** Neo4j亮点**：此处列出了Neo4j的特色功能和优点，可能包括高性能查询、实时分析、复杂关系处理等，以展示其在实际应用中的价值。 3. **图形数据库概念**：这部分深入探讨了图数据库的基础理论，如节点、边、属性、子图等核心概念，为开发者提供构建和理解图数据结构的坚实基础。 4. **入门指南**：针对初次接触Neo4j的用户，提供了安装步骤和使用Cypher（Neo4j的查询语言）的简明教程，帮助快速上手。 5. **Cypher**：这部分是手册的核心内容，详细介绍了Cypher语言的语法、句法、常用语句、函数、模式匹配、查询优化等，这对于进行数据查询和操作至关重要。 6. **执行计划**：讲解如何理解和优化查询执行过程，通过执行计划来提升性能。 7. **术语表**：为确保一致性，提供了术语定义，帮助读者在阅读过程中准确理解技术名词。 8. **驱动程序**：介绍如何使用不同的客户端应用程序与Neo4j服务器交互，包括REST API和图形库驱动。 9. **会话与事务**：涵盖了如何管理连接、开启事务以及事务相关的最佳实践。 10. **Cypher值处理**：指导如何正确处理Cypher中的值类型，包括变量、常量和数据类型。 11. **HTTP API**：讨论了通过HTTP接口执行事务性Cypher命令的方法，以及安全方面的考虑。 12. **身份验证和授权**：涵盖了安全设置，如用户认证和访问控制策略。 13. **扩展性**：介绍了如何通过编写存储过程、自定义函数和插件来增强Neo4j的功能。 14. **附录**：包含参考信息，如状态代码列表和术语表，以供查阅。总结来说，Neo4j图数据库官网开发手册为开发者提供了全面的工具和指南，无论你是初次接触图数据库还是希望深入了解它的高级用法，都能从中找到所需的知识。这份文档是开发、维护和优化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

2014 Year node.

4.3. Getting correct results

• Filtering results

• Returning results

• Aggregating information

• Ordering and pagination

• Collecting aggregation

Let’s first get some data in to retrieve results from:

CREATE (matrix:Movie { title:"The Matrix",released:1997 })

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

CREATE (forrestGump:Movie { title:"Forrest Gump",released:1994 })

CREATE (keanu:Person { name:"Keanu Reeves", born:1964 })

CREATE (robert:Person { name:"Robert Zemeckis", born:1951 })

CREATE (tom:Person { name:"Tom Hanks", born:1956 })

CREATE (tom)-[:ACTED_IN { roles: ["Forrest"]}]->(forrestGump)

CREATE (tom)-[:ACTED_IN { roles: ['Zachry']}]->(cloudAtlas)

CREATE (robert)-[:DIRECTED]->(forrestGump)

This is the data we will start out with:

Movie

title = 'The Matrix'

released = 1997

Movie

title = 'Cloud Atlas'

released = 2012

Movie

title = 'Forrest Gump'

released = 1994

Person

name = 'Keanu Reeves'

born = 1964

Person

name = 'Robert Zemeckis'

born = 1951

DIRECTED

Person

name = 'Tom Hanks'

born = 1956

ACTED_IN

roles = ['Zachry']

ACTED_IN

roles = ['Forrest']

4.3.1. Filtering results

So far we’ve matched patterns in the graph and always returned all results we found. Quite often

there are conditions in play for what we want to see. Similar to in SQL those filter conditions are

expressed in a WHERE clause. This clause allows to use any number of boolean expressions (predicates)

combined with AND, OR, XOR and NOT. The simplest predicates are comparisons, especially equality.

MATCH (m:Movie)

WHERE m.title = "The Matrix"

RETURN m

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

| m |

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

| Node[0]{title:"The Matrix",released:1997} |

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

1 row

For equality on one or more properties, a more compact syntax can be used as well:

MATCH (m:Movie { title: "The Matrix" })

RETURN m

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), toInt("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.

剩余323页未读，继续阅读

艾尔aier

粉丝: 16
资源: 19

Neo4j 3.2开发者指南：从入门到Cypher详解

Neo4j官方开发手册

Neo4j官方中文文档-翻译

spring-data-neo4j-4.0官方开发手册

neo4j图数据库官方使用手册-3.0

Neo4j 图形数据库手册 v2.1.2

Neo4j图数据库概述.pdf

neo4j-ansible:Ansible Playbooks 用于启动运行 neo4j 图形数据库系统的服务器

Neo4j图形数据库：社交系统设计与Java/Python应用指南

neo4j-ogm2.0官方开发手册

Neo4j开发手册

最新资源