Neo4j开发者指南：从入门到精通

版权申诉

134 浏览量更新于2024-07-21 收藏 5.89MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"Neo4j开发手册.pdf 是一本针对Neo4j 3.1版本的英文使用手册，涵盖了图数据库概念、安装、Cypher查询语言、驱动程序、HTTP API以及如何扩展Neo4j等内容。" Neo4j是一款强大的图形数据库系统，它以节点、关系和属性的形式存储数据，特别适合处理具有复杂关联的数据。本手册是针对开发者设计的，提供了全面的指导和信息，帮助用户理解和使用Neo4j。 1. **Neo4j亮点** - 部分介绍了Neo4j的核心特性，包括高性能、高可用性以及模式发现等。Neo4j利用图形数据模型的优势，提供了一种直观的方式来处理和查询复杂的网络结构数据。 2. **图数据库概念** - 解释了图数据库的基本概念，如节点、关系、属性和图。这部分内容有助于理解如何在Neo4j中构建和操作数据模型。 3. **开始使用** - 提供了安装Neo4j的步骤，以及快速入门Cypher查询语言的指南，帮助用户快速上手。 4. **Cypher** - Cypher是Neo4j的声明式图形查询语言，类似于SQL。手册详细介绍了Cypher的语法、子句、函数和查询调优，使开发者能够编写高效且易读的查询。 5. **Cypher语法** - 包含Cypher的语法规则，包括创建、删除、查询、更新和操作节点、关系的命令。 6. **查询调优** - 提供了优化查询性能的策略，如索引使用、执行计划分析等，以确保在大数据集上的高效运行。 7. **驱动程序** - 介绍了与Neo4j交互的不同驱动程序，如Java、Python、.NET等，以及如何配置和连接到数据库，以及执行语句和处理结果的方法。 8. **HTTP API** - 描述了如何通过HTTP协议进行事务性的Cypher查询，以及关于认证和授权的信息，这对于Web应用程序集成至关重要。 9. **扩展Neo4j** - 阐述了如何通过编写自定义过程和用户定义的函数来扩展 Neo4j 的功能，以及实现自己的认证和授权插件。 10. **附录** - 提供了参考信息，如Neo4j的状态码和术语表，方便开发者查找和解决问题。《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页未读，继续阅读

新西伯利亚狼

粉丝: 137
资源: 2

Neo4j开发者指南：从入门到精通

neo4j 教程 百度网盘链接 pdf

图数据库Neo4J的实践之路.pdf

Neo4j中文操作指南及JavaDemo PDF高清

Neo4j图数据库概述.pdf

MongoDB开发使用手册.pdf

阿里巴巴面试官手册.pdf

neo4j-cypher-manual-4.0.pdf

neo4j-developer-manual-3.3-javascript.pdf

neo4j-driver-manual-4.2-java.pdf

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

neo4j 官方资料

neo4j cypher帮助文档

neo4j-operations-manual-4.0_图数据库_neo4j_

neojzwsyscyjlzi_jb51.rar

Neo4j Cypher 操作手册 v4.1 - 简明指南

Neo4j Java驱动手册 v4.2：连接与Cypher工作流

Neo4j入门指南：图数据库王者

Neo4j标签属性图与Cypher查询语言简介（2018版）

最新资源

neo4j 教程百度网盘链接 pdf