Neo4j开发手册：高性能图形数据库指南

需积分: 31 131 浏览量更新于2024-07-17 1 收藏 6.13MB PDF 举报

"Neo4j开发手册 v3.1" Neo4j是一个专注于图形数据库的高性能、NOSQL系统，它的核心特点是将数据以图的形式存储，而非传统的表格模式。这种设计使得它在处理复杂的关系数据时表现出色，特别适合于社交网络、推荐系统、知识图谱等场景。作为一款嵌入式的Java持久化引擎，Neo4j支持完全的事务特性，同时具备企业级数据库的稳定性和可靠性。手册中的内容分为多个部分，包括： 1. **Neo4j亮点** - 这部分可能介绍了Neo4j的主要优点，如其高性能、嵌入式、轻量级的特性，以及如何利用这些特性来解决实际问题。 2. **图数据库概念** - 这里会深入解析图数据库的基本原理，包括节点、关系和属性的概念，以及它们如何构建和查询图模型。 3. **开始使用** - 涵盖了安装Neo4j的步骤，以及如何快速上手，启动数据库并进行基本操作。 4. **Cypher介绍** - Cypher是Neo4j的查询语言，这部分将详细解释其语法、语句、函数和模式，帮助开发者理解和编写查询。 - **Cypher语法** - 描述了Cypher的基本语法结构，包括声明变量、创建节点和关系、查询等。 - **Cypher子句** - 详细介绍了如MATCH、CREATE、DELETE等不同类型的子句，用于执行不同的数据库操作。 - **Cypher函数** - 列出了可用于查询和操作数据的各种内置函数，如COUNT、AVG等统计函数，以及节点和关系的操作函数。 - **模式** - 讨论了如何定义和使用模式来简化查询，以及如何通过模式匹配来发现数据之间的关系。 5. **查询调优** - 提供了优化Cypher查询的策略和技术，以提高查询性能和效率。 6. **执行计划** - 解释了如何查看和理解Neo4j执行查询的内部工作，这对于调试和优化查询至关重要。 7. **驱动程序** - 阐述了如何使用不同的驱动（如Java、Python、.NET等）连接到Neo4j服务器，以及配置和执行查询的方法。 8. **HTTP API** - 描述了如何通过HTTP接口进行事务性Cypher查询，以及涉及到的身份验证和授权机制。 9. **扩展Neo4j** - 包括自定义过程和用户定义的函数，允许开发者扩展Neo4j的功能，以满足特定需求。 10. **附录** - 提供了参考信息，如Neo4j的状态代码和术语表，以增强开发者对系统的理解。该手册是 Neo4j Team 为v3.1版本编写的开发者指南，旨在帮助读者全面掌握Neo4j的使用和开发，从基础概念到高级功能，为使用和优化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

剩余296页未读，继续阅读

shadon178

粉丝: 98
资源: 10

Neo4j开发手册：高性能图形数据库指南

Neo4j官方开发手册

Neo4j官方开发手册3.1

Spring Data Neo4j API（Spring Data Neo4j 开发文档）.CHM

Neo4j开发手册.pdf

Neo4J用户手册

neo4j图数据库官网开发手册【英文】

neo4j-ogm2.0官方开发手册

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

Neo4j中文使用手册以及例子

Neo4j中文使用手册以及例子 word

最新资源