Module: Neo4j

Defined in:
lib/neo4j/neo4j.rb,
lib/neo4j-core.rb,
lib/neo4j/algo.rb,
lib/neo4j/node.rb,
lib/neo4j/config.rb,
lib/neo4j/cypher.rb,
lib/neo4j/transaction.rb,
lib/neo4j-core/to_java.rb,
lib/neo4j-core/version.rb,
lib/neo4j/relationship.rb,
lib/neo4j-core/database.rb,
lib/neo4j-core/lazy_map.rb,
lib/neo4j-core/node/node.rb,
lib/neo4j-core/rels/rels.rb,
lib/neo4j-core/equal/equal.rb,
lib/neo4j-core/index/index.rb,
lib/neo4j-core/cypher/cypher.rb,
lib/neo4j-core/event_handler.rb,
lib/neo4j-core/index/indexer.rb,
lib/neo4j-core/property/java.rb,
lib/neo4j-core/rels/traverser.rb,
lib/neo4j-core/wrapper/wrapper.rb,
lib/neo4j-core/relationship_set.rb,
lib/neo4j-core/property/property.rb,
lib/neo4j-core/index/index_config.rb,
lib/neo4j-core/index/lucene_query.rb,
lib/neo4j-core/node/class_methods.rb,
lib/neo4j-core/index/class_methods.rb,
lib/neo4j-core/traversal/evaluator.rb,
lib/neo4j-core/traversal/traversal.rb,
lib/neo4j-core/traversal/traverser.rb,
lib/neo4j-core/index/unique_factory.rb,
lib/neo4j-core/cypher/result_wrapper.rb,
lib/neo4j-core/wrapper/class_methods.rb,
lib/neo4j-core/index/indexer_registry.rb,
lib/neo4j-core/traversal/rel_expander.rb,
lib/neo4j-core/relationship/relationship.rb,
lib/neo4j-core/traversal/prune_evaluator.rb,
lib/neo4j-core/relationship/class_methods.rb,
lib/neo4j-core/traversal/filter_predicate.rb,
lib/neo4j-core/hash_with_indifferent_access.rb

Overview

Neo4j

The Neo4j modules is used to interact with an Neo4j Database instance. You can for example start and stop an instance and list all the nodes that exist in the database.

Notice - Starting and Stopping Neo4j

You don’t normally need to start the Neo4j database since it will be automatically started when needed. Before the database is started you should configure where the database is stored, see Config].

Examples:

require 'neo4j'
Neo4j::Transaction.run { Neo4j.ref_node.outgoing(:friends) << Neo4j::Node.new(:name => 'andreas')}
Neo4j.ref_node.node(:outgoing, :friends)[:name] #=> 'andreas'
Neo4j.query(Neo4j.ref_node){|ref| ref > ':friends' > :x; :x}

Defined Under Namespace

Modules: Core Classes: Algo, Config, Cypher, Node, Relationship, Transaction

Constant Summary collapse

Enumerator =

Enumerator has been moved to top level in Ruby 1.9.2, make it compatible with Ruby 1.8.7

Enumerable::Enumerator
NEO_VERSION =

Returns The version of the Neo4j jar files.

Returns:

  • (String) —

    The version of the Neo4j jar files

Neo4j::Community::VERSION

Class Method Summary collapse

Class Method Details

._all_nodes(this_db = self.started_db) ⇒ Enumerable

Returns all nodes in the database but not wrapped in ruby classes.

Returns:

  • (Enumerable) —

    all nodes in the database but not wrapped in ruby classes.



242
243
244
 
# File 'lib/neo4j/neo4j.rb', line 242

def _all_nodes(this_db = self.started_db)
  Enumerator.new(this_db, :_each_node)
end

._query(q) ⇒ Object

Performs a cypher query with given string

Parameters:

  • q (String) —

    the cypher query as a String



123
124
125
126
127
 
# File 'lib/neo4j/neo4j.rb', line 123

def _query(q)
  engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(db)
  result = engine.execute(q)
  Neo4j::Core::Cypher::ResultWrapper.new(result)
end

.all_nodes(this_db = self.started_db) ⇒ Enumerable

Returns all nodes in the database.

Returns:

  • (Enumerable) —

    all nodes in the database



237
238
239
 
# File 'lib/neo4j/neo4j.rb', line 237

def all_nodes(this_db = self.started_db)
  Enumerator.new(this_db, :each_node)
end

.config ⇒ Neo4j::Config

Same as typing; Neo4j::Config

Returns:



83
84
85
 
# File 'lib/neo4j/neo4j.rb', line 83

def config
  Neo4j::Config
end

.db ⇒ Neo4j::Database

Returns the database holding references to both the Neo4j Graph Database and the Lucene Database. Creates a new one if it does not exist, but does not start it.

Returns:

  • (Neo4j::Database) —

    the created or existing database



56
57
58
 
# File 'lib/neo4j/neo4j.rb', line 56

def db
  @db ||= Neo4j::Core::Database.new
end

.db=(my_db) ⇒ Object

Sets which Neo4j::Database instance to use. It wraps both the Neo4j Database and Lucene Database.

Parameters:

  • my_db (Neo4j::Database) —

    • the database instance to use



48
49
50
 
# File 'lib/neo4j/neo4j.rb', line 48

def db=(my_db)
  @db = my_db
end

.default_logger ⇒ Object

Returns the default Ruby logger.

Returns:

  • the default Ruby logger



155
156
157
158
159
160
 
# File 'lib/neo4j/neo4j.rb', line 155

def default_logger #:nodoc:
  require 'logger'
  logger = Logger.new(STDOUT)
  logger.sev_threshold = Neo4j::Config[:logger_level] || Logger::INFO
  logger
end

.default_ref_node(this_db = self.started_db) ⇒ Object

Returns the default reference node, which is a “starting point” in the node space.

Returns:

  • the default reference node, which is a “starting point” in the node space.



189
190
191
 
# File 'lib/neo4j/neo4j.rb', line 189

def default_ref_node(this_db = self.started_db)
  this_db.graph.reference_node
end

.event_handler(this_db = db) ⇒ Neo4j::Core::EventHandler

Returns the event handler.

Returns:



247
248
249
 
# File 'lib/neo4j/neo4j.rb', line 247

def event_handler(this_db = db)
  this_db.event_handler
end

.logger ⇒ Object

Returns the logger used by neo4j. If not specified (with Neo4j.logger=) it will use the standard Ruby logger. You can change standard logger threshold by configuration :logger_level.

You can also specify which logger class should take care of logging with the :logger configuration.

Examples:


Neo4j::Config[:logger] = Logger.new(STDOUT)
Neo4j::Config[:logger_level] = Logger::ERROR

See Also:

  • #logger=


143
144
145
 
# File 'lib/neo4j/neo4j.rb', line 143

def logger
  @logger ||= Neo4j::Config[:logger] || default_logger
end

.logger=(logger) ⇒ Object

Sets which logger should be used. If this this is not called then the standard Ruby logger will be used.

See Also:

  • #logger


150
151
152
 
# File 'lib/neo4j/neo4j.rb', line 150

def logger=(logger)
  @logger = logger
end

.management(jmx_clazz = Java::OrgNeo4jJmx::Primitives, this_db = self.started_db) ⇒ Object

Returns a Management JMX Bean.

Notice that this information is also provided by the jconsole Java tool, check wiki.neo4j.org/content/Monitoring_and_Deployment and docs.neo4j.org/chunked/milestone/operations-monitoring.html

By default it returns the Primitivies JMX Bean that can be used to find number of nodes in use.

Neo4j.management(org.neo4j.management.HighAvailability).isMaster

Examples:

Example Neo4j Primititives


Neo4j.management.get_number_of_node_ids_in_use
Neo4j.management.getNumberOfPropertyIdsInUse
Neo4j.management.getNumberOfRelationshipIdsInUse
Neo4j.management.get_number_of_relationship_type_ids_in_use

Example Neo4j HA Cluster Info

Parameters:

See Also:

  • the jmx_clazz p


232
233
234
 
# File 'lib/neo4j/neo4j.rb', line 232

def management(jmx_clazz = Java::OrgNeo4jJmx::Primitives, this_db = self.started_db)
  this_db.management(jmx_clazz)
end

.query(*params, &query_dsl) ⇒ Neo4j::Core::Cypher::ResultWrapper

Note:

Returns a read-once only forward iterable.

Executes a Cypher Query Check the neo4j Returns an enumerable of hash values.

Examples:

Using the Cypher DSL

q = Neo4j.query{ match node(3) <=> node(:x); ret :x}
q.first[:n] #=> the @node
q.columns.first => :n

Using the Cypher DSL and one parameter (n=Neo4j.ref_node)

q = Neo4j.query(Neo4j.ref_node){|n| n <=> node(:x); :x}
q.first[:n] #=> the @node
q.columns.first => :n

Using an array of nodes

# same as - two_nodes=node(Neo4j.ref_node.neo_id, node_b.neo_id), b = node(b.neo_id)
q = Neo4j.query([Neo4j.ref_node, node_b], node_c){|two_nodes, b| two_nodes <=> b; b}

With an string

q = Neo4j._query("START n=node(42) RETURN n")
q.first(:n) #=> the @node
q.columns.first => :n

Parameters:

  • params —

    parameter for the query_dsl block

Returns:

See Also:



115
116
117
118
 
# File 'lib/neo4j/neo4j.rb', line 115

def query(*params, &query_dsl)
  q = Cypher.new(*params, &query_dsl).to_s
  _query(q)
end

.read_only? ⇒ true, false

Checks read only mode of the database. Only one process can have write access to the database.

Returns:

  • (true, false) —

    if the database has started up in read only mode



62
63
64
 
# File 'lib/neo4j/neo4j.rb', line 62

def read_only?
  (@db && @db.graph && @db.read_only?)
end

.ref_node(this_db = self.started_db) ⇒ Object

Note:

In case the ref_node has been assigned via the threadlocal_ref_node method, then that node will be returned instead.

Usually, a client attaches relationships to this node that leads into various parts of the node space. ®return the reference node, which is a “starting point” in the node space.

See Also:

  • design guide at http://wiki.neo4j.org/content/Design_Guide


198
199
200
201
 
# File 'lib/neo4j/neo4j.rb', line 198

def ref_node(this_db = self.started_db)
  return Thread.current[:local_ref_node] if Thread.current[:local_ref_node]
  default_ref_node(this_db)
end

.running? ⇒ true, false

Returns if the database is running.

Returns:

  • (true, false) —

    if the database is running



176
177
178
 
# File 'lib/neo4j/neo4j.rb', line 176

def running?
  !!(@db && @db.running?)
end

.shutdown(this_db = @db) ⇒ Object

Stops this database There are Ruby hooks that will do this automatically for you.



183
184
185
 
# File 'lib/neo4j/neo4j.rb', line 183

def shutdown(this_db = @db)
  this_db.shutdown if this_db
end

.start(config_file = nil, external_db = $NEO4J_SERVER) ⇒ Object

Start Neo4j using the default database. This is usually not required since the database will be started automatically when it is used. If the global variable $NEO4J_SERVER is defined then it will use that as the Java Graph DB. This can be used if you want to embed neo4j.rb and already got an instance of the Java Neo4j Database service.

Parameters:

  • config_file (String) (defaults to: nil) —

    (optionally) if this is nil or not given use the Neo4j::Config, otherwise setup the Neo4j::Config file using the provided YAML configuration file.

  • external_db (Java::OrgNeo4jKernel::EmbeddedGraphDatabase) (defaults to: $NEO4J_SERVER) —

    (optionally) use this Java Neo4j instead of creating a new neo4j database service.



33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/neo4j/neo4j.rb', line 33

def start(config_file=nil, external_db = $NEO4J_SERVER)
  return if @db && @db.running?

  Neo4j.config.default_file = config_file if config_file
  if external_db
    @db ||= Neo4j::Core::Database.new
    self.db.start_external_db(external_db)
  else
    db.start
  end
end

.started_db ⇒ Neo4j::Database

Returns a started db instance. Starts it’s not running. if $NEO4J_SERVER is defined then use that Java Neo4j Database service instead of creating a new one.

Returns:

  • (Neo4j::Database) —

    a started database



69
70
71
72
 
# File 'lib/neo4j/neo4j.rb', line 69

def started_db
  start unless db.running?
  db
end

.storage_path ⇒ String

If the database is not running it returns Neo4j::Config.storage_path otherwise it asks the database

Returns:

  • (String) —

    the current storage path of the database



76
77
78
79
 
# File 'lib/neo4j/neo4j.rb', line 76

def storage_path
  return Neo4j::Config.storage_path unless db.running?
  db.storage_path
end

.threadlocal_ref_node=(reference_node) ⇒ Object

Changes the reference node on a threadlocal basis. This can be used to achieve multitenancy. All new entities will be attached to the new ref_node, which effectively partitions the graph, and hence scopes traversals.



206
207
208
 
# File 'lib/neo4j/neo4j.rb', line 206

def threadlocal_ref_node=(reference_node)
  Thread.current[:local_ref_node] = reference_node.nil? ? nil : reference_node._java_node
end

.unstarted_db ⇒ Neo4j::Database

Returns an unstarted db instance

This is typically used for configuring the database, which must sometimes be done before the database is started if the database was already started an exception will be raised

Returns:

  • (Neo4j::Database) —

    an not started database



169
170
171
172
173
 
# File 'lib/neo4j/neo4j.rb', line 169

def unstarted_db
  @db ||= Neo4j::Core::Database.new
  raise "database was already started" if @db.running?
  @db
end