Skip to content
This repository

A simple unified API that can access both the server and embedded Neo4j database. Used by the neo4j gem

Fetching latest commit…

Octocat-spinner-32-eaf2f5

Cannot retrieve the latest commit at this time

Octocat-spinner-32 config
Octocat-spinner-32 lib
Octocat-spinner-32 spec
Octocat-spinner-32 .gitignore
Octocat-spinner-32 .travis.yml
Octocat-spinner-32 Gemfile
Octocat-spinner-32 README.rdoc
Octocat-spinner-32 Rakefile
Octocat-spinner-32 neo4j-core.gemspec
README.rdoc

Neo4j-core

This gem only contains the JRuby mapping of the Neo4j graph database. The neo4j.rb gem will be split up into three gems, neo4j-core, neo4j-wrapper and neo4j. This gem will be included by neo4j 2.0.0 gem.

This gem contains two modules: Neo4j and Neo4j::Core The Neo4j module is public and the Neo4j::Core(::*) are internal modules.

Documentation

The public API

{Neo4j::Node} The Java Neo4j Node

{Neo4j::Relationship} The Java Relationship

{Neo4j} The Database

{Neo4j::Cypher} Cypher Query Generator, see RSpec spec/neo4j/cypher_spec

Custom Index

You can create your own indexer.

class MyIndex
  extend Neo4j::Core::Index::ClassMethods
  include Neo4j::Core::Index

  node_indexer do
    index_names :exact => 'myindex_exact', :fulltext => 'myindex_fulltext'
    trigger_on :myindex => true, :things => ['a', 'b']
  end

  index :name
end

All nodes with the property myindex == true or property things 'a' or 'b' will be indexed using this index.

Exampel:

n = Neo4j::Node.new(:myindex = true, :name => 'foo')
MyIndex.find('name: foo').first #=> n

Cypher

Example:

Neo4j.query { node(3) }

Example with parameters:

Neo4j.query(Neo4j.ref_node} do |ref|
   ref <=> :x
   :x
end

Notice

  • The last statement in the expression will be the return value.

  • You can skip the start, match, where and ret (they are just empty methods).

Cypher Examples

“START n0=node(3) RETURN n0”

Neo4j.query do
  start n = node(3)
  ret n
end
# the above is same as:
Neo4j.query { node(3) }

“START n0=node(42) RETURN n0”

node(Neo4j::Node.new)

“START r0=relationship(3,4) RETURN r0”

rel(3,4)

“START n0=node(3) MATCH (n0)–(x) RETURN x”

start n = node(3)
match n <=> :x
ret :x

“START n0=node(3) MATCH (n0)–(v0) RETURN v0”

x = node
n = node(3)
match n <=> x
ret x

“START n0=node(3) MATCH (n0)–(v0) RETURN v0.name”

x = node
n = node(3)
match n <=> x
ret x[:name]

“START n0=node(1) RETURN n0.name AS SomethingTotallyDifferent”

x = node(1)
x[:name].as('SomethingTotallyDifferent')

“START n0=node:fooindex_exact(name:A) RETURN n0”

query(FooIndex, "name:A")

“START n0=node:fooindex_fulltext(desc=”A“) RETURN n0”

lookup(FooIndex, "desc", "A")

“START n0=node(1),n1=node(2) RETURN n0,n1”

[node(1), node(2)]

“START n0=node(3) MATCH (n0)–>©–>(d) RETURN c”

node(3) >> node(:c) >> :d
:c

“START n0=node(3) MATCH (n0)-[r]->(x) RETURN r”

node(3) > :r > :x
:r

“START n0=node(3) MATCH (n0)-[r:friends]->(x) RETURN r”

r = rel('r:friends').as(:r)
node(3) > r > :x
r

“START n0=node(3,1) WHERE n0.age < 30 RETURN n0”

n=node(3, 1)
where n[:age] < 30
ret n

“START n0=node(3,4) WHERE n0.desc = ”hej“ RETURN n0”

n=node(3, 4)
n[:desc] == "hej"
n

“START n0=node(3) MATCH (n0)<-[:knows]-© RETURN c”

a=node(3)
a < ':knows' < :c
:c

“START n0=node(3) MATCH (n0)-[r]->(v1) WHERE type® =~ /K.*/ RETURN r”

n=node(3)
n > (r=rel('r')) > node
r.rel_type =~ /K.*/
r

“START n0=node(3) MATCH m2 = (n0)–>(b) RETURN b,length(m2)”

p = node(3) >> :b; [:b, p.length]

“START n0=node(1) MATCH (n0)–>(b) RETURN distinct n0”

n=node(1); n>>:b; n.distinct

“START n0=node(2) MATCH (n0)–>(x) RETURN n0,count(*)”

n = node(2))>>:x
[n, count]

“START n0=node(2,3,4) RETURN sum(n0.property)”

n=node(2, 3, 4)
n[:property].sum

“START n0=node(2) MATCH (n0)–>(b) RETURN count(distinct n0.eyes)”

n=node(2); n>>:b
n[:eyes].distinct.count

“START n0=node(3,4,5) RETURN ID(n0)”

node(3, 4, 5).neo_id

“START n0=node(2) WHERE any(x in n0.array WHERE x = ”one“) RETURN n0”

a = node(2)
a[:array].any? { |x| x == 'one' }
a

“START n0=node(3),n1=node(4),n2=node(1) MATCH m4 = (n0)–>(n1)–>(n2) RETURN extract(x in nodes(m4) : x.age)”

a=node(3)
b=node(4)
c=node(1)
p=a>>b>>c
p.nodes.extract { |x| x[:age] }

“START n0=node(3) WHERE abs(n0.x) = 3 RETURN n0”

a=node(3); a[:x].abs==3
a

“START n0=node(3,4,5,1,2) RETURN n0 ORDER BY n0.name SKIP 1 LIMIT 2”

a=node(3,4,5,1,2); ret(a).asc(a[:name]).skip(1).limit(2)
# o same as
a=node(3,4,5,1,2); ret a, :asc => a[:name], :skip => 1, :limit => 2

For more examples, see the RSpecs

Creates Your Own Wrapper

Todo, see {Neo4j::Core::Wrapper}

Changes

Changes from the neo4j.rb

  • Use of YARD instead of RDoc

  • Some tidy up of the API and code (e.g. Neo4j::Node#rels methods)

  • Change of Ruby module structure.

  • More RSpecs and more use of mocking combined with real testing of the Java layer

  • Make sure that we retrieve relationships and nodes lazy if possible.

  • Cypher Query DSL

Something went wrong with that request. Please try again.