Neo4j 3.1开发者手册：从入门到深度探索

需积分: 0 190 浏览量更新于2024-07-20 收藏 5.31MB PDF 举报

《Neo4j开发者手册》第3.1版是针对Neo4j图数据库的专业指南，由Neo4j团队编撰，专为开发人员设计。该手册详细介绍了Neo4j 3.1的主要特性和功能，涵盖了图数据库的核心概念以及在实际项目中的应用。首先，"Neo4j highlights"部分概述了3.1版本的主要亮点，可能包括性能提升、新特性以及与先前版本相比的重要改进。这些亮点旨在帮助读者了解为何选择使用Neo4j及其在当前大数据时代的优势。 "Graph database concepts"章节深入浅出地介绍了图数据库的基础理论，如节点（Nodes）、关系（Relationships）和属性（Properties），这对于理解如何在复杂的数据结构中存储和查询数据至关重要。开发者可以借此学习如何设计和优化图模型。 "Get started"部分引导用户安装和配置Neo4j，为初学者提供了实践操作的步骤，包括设置环境、安装驱动器以及初次使用Cypher（Neo4j的查询语言）进行数据操作。 Cypher章节作为核心内容，分为两个部分：介绍和参考。Cypher部分详细解释了语法、常用语句（Clauses）、函数（Functions）、模式定义（Schema）以及查询优化（Query Tuning）。此外，还有关于执行计划（Execution Plans）的知识，帮助开发者理解和优化查询性能。 "Drivers"章节涉及与Neo4j的交互，介绍了不同编程语言的驱动程序，如何连接数据库、运行SQL-like查询以及处理结果。这部分内容对开发人员来说极其实用，特别是在使用Java、Python、Node.js等客户端语言时。 "HTTP API"部分介绍了Neo4j的非图形化接口，包括事务性Cypher HTTP端点，以及如何进行身份验证和授权，确保安全访问。 "Extending Neo4j"涵盖了如何扩展数据库的功能，包括编写自定义过程（Procedures）、用户定义函数（User-defined functions）以及利用第三方插件进行认证和授权。附录A提供了一个全面的参考文档，包括Neo4j的状态码列表，有助于解决开发过程中遇到的问题。附录B则定义了术语，确保读者对图数据库的概念有清晰的理解。《Neo4j开发者手册》第3.1版是一本实用的指南，无论你是初次接触图数据库还是寻求进阶学习，都能从中找到所需的资源。通过深入理解和掌握其中的知识点，开发人员将能更有效地利用Neo4j处理复杂的数据关系，提高应用程序的性能和可扩展性。

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.

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.

By default the expression itself will be used as label for the column, in many cases you want to alias

that with a more understandable name using expression AS alias. You can later on refer to that

column using its alias.

MATCH (p:Person)

RETURN p, p.name AS name, upper(p.name), coalesce(p.nickname,"n/a") AS nickname, { name: p.name,

Ê label:head(labels(p))} AS person

剩余274页未读，继续阅读

zhizh

粉丝: 2
资源: 18

Neo4j 3.1开发者手册：从入门到深度探索

neo4j-fiber：高效REST客户端驱动Neo4j数据库

Python库neo4j-driver-1.7.0rc2版本发布与安装指南

Neo4j服务器插件neo4j-rdf-plugin介绍与应用

neo4j-developer-manual-3.1-javascript

neo4j-developer-manual-3.1-python

neo4j-developer-manual-3.1-java

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

neo4j-developer-manual-3.3-java

neo4j-developer-manual-3.0-java

neo4j-developer-manual-3.3-javascript.pdf

最新资源