Neo4j 3.2开发者指南：掌握图数据库与Cypher操作

需积分: 15 56 浏览量更新于2024-07-18 收藏 6.91MB PDF 举报

Neo4j开发手册（v3.2）是一份全面的指南，专为想要深入理解和使用图数据库Neo4j的专业开发者设计。该手册首先介绍了 Neo4j 的核心特点和概念，帮助读者建立起对图数据库理论的理解。章节1“Neo4j亮点”概述了Neo4j在数据建模和查询处理方面的独特优势。在“Get started”部分（第8-16章），手册详细指导如何安装Neo4j（第9章），包括不同平台的安装步骤。接着，第10-12章聚焦于Cypher语言，这是Neo4j的主要查询语言。第10章从基础入门，介绍如何编写和执行基本的Cypher查询；第11章深入讲解执行计划，帮助优化查询性能；第12章列出了Cypher的关键字和术语 Glossary of keywords，便于查阅。 Cypher的语法和结构在第14-17章中逐步展开，包括查询语句、子句（如MATCH, CREATE, DELETE等）、函数使用，以及如何通过HTTP API（从第17章起）进行交互。这部分内容是实际编程和数据分析的核心，确保用户能熟练地与数据库进行沟通。在“Drivers”章节（第19-21章），手册涵盖了各种客户端应用程序的集成，如如何使用不同类型的驱动程序来连接到Neo4j服务器，并强调了会话管理和事务处理的重要性（第15-16章）。第18章讨论了安全性和权限管理，包括交易性Cypher HTTP端点、认证和授权机制。扩展Neo4j功能的部分（第201-21章）涉及自定义过程（Procedures）和用户定义函数（User-defined functions），以及针对特定需求的第三方插件，如身份验证和授权插件。手册还提供了两个附录：参考文献（A）列出Neo4j状态码，以及术语表（B），确保所有术语的一致性。总结来说，Neo4j开发手册（v3.2）是一个全面的工具，涵盖了从基础安装、语言操作到高级开发和安全性的方方面面，是任何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.

剩余322页未读，继续阅读

juncaofish

粉丝: 1
资源: 5

Neo4j 3.2开发者指南：掌握图数据库与Cypher操作

Neo4j官方开发手册

java连接neo4j图形数据库增删改数据demo

Neo4j官方开发手册3.1

知识图谱springboot neo4j开发

neo4j java开发快速指南

neo4j4.4.7 版本 开发

neo4j python开发汽车

neo4j与neo4j desktop

neo4j 账号neo4j 改成root

neo4j desktop和neo4j区别

最新资源

neo4j4.4.7 版本开发