第 19 章 在 Python 中使用 Neo4j 嵌入模式

1

sudoapt-get installpython-jpype

1

sudopip installneo4j-embedded

1

sudoeasy_install neo4j-embedded

注意

注意JPype只工作在Python 2.6 和 2.7。也要注意你下载的地址由你使用的版本决定。

1

2

3

4

5

6

7

fromneo4j importGraphDatabase

# Create db

db =GraphDatabase(folder_to_put_db_in)

# Always shut down your database

db.shutdown()

1

2

3

4

5

6

fromneo4j importGraphDatabase

# Example configuration parameters

db =GraphDatabase(folder_to_put_db_in, string_block_size=200, array_block_size=240)

db.shutdown()

1

2

3

importos

os.environ['NEO4J_PYTHON_JVMARGS'] ='-Xms128M -Xmx512M'

importneo4j

1

from__future__ importwith_statement

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# Start a transaction

with db.transaction:

# This is inside the transactional

# context. All work done here

# will either entirely succeed,

# or no changes will be applied at all.

# Create a node

node =db.node()

# Give it a name

node['name'] ='Cat Stevens'

# The transaction is automatically

# commited when you exit the with

# block.

1

2

3

with db.transaction:

# Create a node

thomas =db.node(name='Thomas Anderson', age=42)

1

2

3

4

5

6

7

# You don't have to be in a transaction

# to do read operations.

a_node =db.node[some_node_id]

# Ids on nodes and relationships are available via the "id"

# property, eg.:

node_id =a_node.id

1

reference =db.reference_node

1

2

3

with db.transaction:

node =db.node()

node.delete()

提示

也可以参考：第 12.5 节 “Delete semantics”。

1

2

with db.transaction:

deldb.node[some_node_id]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

# All relationships on a node

forrel ina_node.relationships:

pass

# Incoming relationships

forrel ina_node.relationships.incoming:

pass

# Outgoing relationships

forrel ina_node.relationships.outgoing:

pass

# Relationships of a specific type

forrel ina_node.mayor_of:

pass

# Incoming relationships of a specific type

forrel ina_node.mayor_of.incoming:

pass

# Outgoing relationships of a specific type

forrel ina_node.mayor_of.outgoing:

pass

1

2

3

4

5

6

fornode indb.nodes:

pass

# Shorthand for iterating through

# and counting all nodes

number_of_nodes =len(db.nodes)

1

2

3

4

5

6

7

8

9

10

11

12

with db.transaction:

# Nodes to create a relationship between

steven =self.graphdb.node(name='Steve Brook')

poplar_bluff =self.graphdb.node(name='Poplar Bluff')

# Create a relationship of type "mayor_of"

relationship =steven.mayor_of(poplar_bluff, since="12th of July 2012")

# Or, to create relationship types with names

# that would not be possible with the above

# method.

steven.relationships.create('mayor_of', poplar_bluff, since="12th of July 2012")

1

the_relationship =db.relationship[a_relationship_id]

1

2

3

4

5

6

7

8

with db.transaction:

# Create a relationship

source =db.node()

target =db.node()

rel =source.Knows(target)

# Delete it

rel.delete()

提示

也可以参考：第 12.5 节 “Delete semantics”。

1

2

with db.transaction:

deldb.relationship[some_relationship_id]

1

2

3

4

relationship_type =relationship.type

start_node =relationship.start

end_node =relationship.end

1

2

3

4

5

6

forrel indb.relationships:

pass

# Shorthand for iterating through

# and counting all relationships

number_of_rels =len(db.relationships)

1

2

3

4

5

with db.transaction:

node_or_rel['name'] ='Thomas Anderson'

node_or_rel['age'] =42

node_or_rel['favourite_numbers'] =[1,2,3]

node_or_rel['favourite_words'] =['banana','blue']

1

numbers =node_or_rel['favourite_numbers']

1

2

with db.transaction:

delnode_or_rel['favourite_numbers']

1

2

3

4

5

6

7

8

9

10

11

# Loop key and value at the same time

forkey, value innode_or_rel.items():

pass

# Loop property keys

forkey innode_or_rel.keys():

pass

# Loop property values

forvalue innode_or_rel.values():

pass

1

2

start_node =path.start

end_node =path.end

1

last_relationship =path.last_relationship

1

2

3

4

5

6

7

8

9

10

11

12

foritem inpath:

# Item is either a Relationship,

# or a Node

pass

fornodes inpath.nodes:

# All nodes in a path

pass

fornodes inpath.relationships:

# All relationships in a path

pass

1

2

3

4

5

6

7

8

with db.transaction:

# Create a relationship index

rel_idx =db.relationship.indexes.create('my_rels')

# Create a node index, passing optional

# arguments to the index provider.

# In this case, enable full-text indexing.

node_idx =db.node.indexes.create('my_nodes', type='fulltext')

1

2

3

4

with db.transaction:

node_idx =db.node.indexes.get('my_nodes')

rel_idx =db.relationship.indexes.get('my_rels')

1

2

3

4

5

6

with db.transaction:

node_idx =db.node.indexes.get('my_nodes')

node_idx.delete()

rel_idx =db.relationship.indexes.get('my_rels')

rel_idx.delete()

1

exists =db.node.indexes.exists('my_nodes')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

with db.transaction:

# Indexing nodes

a_node =db.node()

node_idx =db.node.indexes.create('my_nodes')

# Add the node to the index

node_idx['akey']['avalue'] =a_node

# Indexing relationships

a_relationship =a_node.knows(db.node())

rel_idx =db.relationship.indexes.create('my_rels')

# Add the relationship to the index

rel_idx['akey']['avalue'] =a_relationship

1

2

3

4

5

6

7

8

9

# Remove specific key/value/item triplet

delidx['akey']['avalue'][item]

# Remove all instances under a certain

# key

delidx['akey'][item]

# Remove all instances all together

delidx[item]

重要

除非遍历整个索引结果，否则当你用完它后你必须关闭结果。如果你没有关闭，数据库不知道他什么时候能释放结果资源。

1

2

3

4

5

6

7

hits =idx['akey']['avalue']

foritem inhits:

pass

# Always close index results when you are

# done, to free up resources.

hits.close()

1

2

3

4

5

6

7

hits =idx.query('akey:avalue')

foritem inhits:

pass

# Always close index results when you are

# done, to free up resources.

hits.close()

1

result =db.query("START n=node(0) RETURN n")

1

2

3

4

5

6

7

8

9

root_node ="START n=node(0) RETURN n"

# Iterate through all result rows

forrow indb.query(root_node):

node =row['n']

# We know it's a single result,

# so we could have done this as well

node =db.query(root_node).single['n']

1

2

3

4

5

6

7

8

9

10

11

root_node ="START n=node(0) RETURN n"

# Fetch an iterator for the "n" column

column =db.query(root_node)['n']

forcell incolumn:

node =cell

# Coumns support "single":

column =db.query(root_node)['n']

node =column.single

1

2

3

4

result =db.query("START n=node(0) RETURN n,count(n)")

# Get a list of the column names

columns =result.keys()

1

2

3

result =db.query("START n=node({id}) RETURN n",id=0)

node =result.single['n']

警告

在neo4j-embedded for python中支持的遍历查询在Neo4j 1.7 GA已经废弃了。请参考 第 19.4 节 “Cypher 查询”或者用核心API代替。因为遍历查询框架要求在JVM和python直接有一个紧密的耦合，所以为了提升性能，我们需要打破这个耦合。

1

2

3

4

5

6

7

8

traverser =db.traversal()\

.relationships('related_to')\

.traverse(start_node)

# The graph is traversed as

# you loop through the result.

fornode intraverser.nodes:

pass

1

2

3

4

5

fromneo4j importOUTGOING, INCOMING, ANY

traverser =db.traversal()\

.relationships('related_to', OUTGOING)\

.traverse(start_node)

1

2

3

4

5

6

fromneo4j importOUTGOING, INCOMING, ANY

traverser =db.traversal()\

.relationships('related_to', INCOMING)\

.relationships('likes')\

.traverse(start_node)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

traverser =db.traversal()\

.relationships('related_to')\

.traverse(start_node)

# Get each possible path

forpath intraverser:

pass

# Get each node

fornode intraverser.nodes:

pass

# Get each relationship

forrelationship intraverser.relationships:

pass

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

fromneo4j importUniqueness

# Available options are:

Uniqueness.NONE

# Any position in the graph may be revisited.

Uniqueness.NODE_GLOBAL

# Default option

# No node in the entire graph may be visited

# more than once. This could potentially

# consume a lot of memory since it requires

# keeping an in-memory data structure

# remembering all the visited nodes.

Uniqueness.RELATIONSHIP_GLOBAL

# No relationship in the entire graph may be

# visited more than once. For the same

# reasons as NODE_GLOBAL uniqueness, this

# could use up a lot of memory. But since

# graphs typically have a larger number of

# relationships than nodes, the memory

# overhead of this uniqueness level could

# grow even quicker.

Uniqueness.NODE_PATH

# A node may not occur previously in the

# path reaching up to it.

Uniqueness.RELATIONSHIP_PATH

# A relationship may not occur previously in

# the path reaching up to it.

Uniqueness.NODE_RECENT

# Similar to NODE_GLOBAL uniqueness in that

# there is a global collection of visited

# nodes each position is checked against.

# This uniqueness level does however have a

# cap on how much memory it may consume in

# the form of a collection that only

# contains the most recently visited nodes.

# The size of this collection can be

# specified by providing a number as the

# second argument to the

# uniqueness()-method along with the

# uniqueness level.

Uniqueness.RELATIONSHIP_RECENT

# works like NODE_RECENT uniqueness, but

# with relationships instead of nodes.

traverser =db.traversal()\

.uniqueness(Uniqueness.NODE_PATH)\

.traverse(start_node)

1

2

3

4

5

6

7

8

9

10

# Depth first traversal, this

# is the default.

traverser =db.traversal()\

.depthFirst()\

.traverse(self.source)

# Breadth first traversal

traverser =db.traversal()\

.breadthFirst()\

.traverse(start_node)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

fromneo4j importEvaluation

# Evaluation contains the four

# options that an evaluator can

# return. They are:

Evaluation.INCLUDE_AND_CONTINUE

# Include this node in the result and

# continue the traversal

Evaluation.INCLUDE_AND_PRUNE

# Include this node in the result, but don't

# continue the traversal

Evaluation.EXCLUDE_AND_CONTINUE

# Exclude this node from the result, but

# continue the traversal

Evaluation.EXCLUDE_AND_PRUNE

# Exclude this node from the result and

# don't continue the traversal

# An evaluator

defmy_evaluator(path):

# Filter on end node property

ifpath.end['message'] =='world':

returnEvaluation.INCLUDE_AND_CONTINUE

# Filter on last relationship type

ifpath.last_relationship.type.name() =='related_to':

returnEvaluation.INCLUDE_AND_PRUNE

# You can do even more complex things here, like subtraversals.

returnEvaluation.EXCLUDE_AND_CONTINUE

# Use the evaluator

traverser =db.traversal()\

.evaluator(my_evaluator)\

.traverse(start_node)