neo4j 1.0.0.beta.27-java → 1.0.0.beta.28-java

data/CONTRIBUTORS

@@ -2,6 +2,7 @@ Maintainer:
   Andreas Ronge <andreas dot ronge at gmail dot com>
 
 Contributors:
+* Bobby Calderwood
 * Ben Jackson
 * Dwight van Tuyl
 * Martin Kleppmann

data/lib/neo4j.rb

@@ -1,5 +1,3 @@
-include Java
-
 require 'enumerator'
 require 'forwardable'
 require 'time'
@@ -15,23 +13,22 @@ require 'will_paginate/finders/base'
 
 require 'neo4j/jars/core/geronimo-jta_1.1_spec-1.1.1.jar'
 require 'neo4j/jars/core/lucene-core-3.0.3.jar'
-require 'neo4j/jars/core/neo4j-lucene-index-0.5-SNAPSHOT.jar'  
-require 'neo4j/jars/core/neo4j-graph-algo-0.8-SNAPSHOT.jar'
-require 'neo4j/jars/core/neo4j-kernel-1.3-SNAPSHOT.jar'
+require 'neo4j/jars/core/neo4j-lucene-index-0.5-1.3.M01.jar'
+require 'neo4j/jars/core/neo4j-kernel-1.3-1.3.M01.jar'
 
 module Neo4j
 
   def self.load_local_jars
     # This is a temporary fix since the HA does not yet work with this JAR
     # It will be solved in a future version of the Java Neo4j library.
-    require 'neo4j/jars/core/neo4j-index-1.3-SNAPSHOT.jar'
+    require 'neo4j/jars/core/neo4j-index-1.3-1.3.M01.jar'
   end
 
   def self.load_ha_jars
     require 'neo4j/jars/ha/log4j-1.2.16.jar'
-    require 'neo4j/jars/ha/neo4j-ha-0.6-SNAPSHOT.jar'
-    require 'neo4j/jars/ha/neo4j-management-1.3-SNAPSHOT.jar'
-    require 'neo4j/jars/ha/neo4j-shell-1.3-SNAPSHOT.jar'
+    require 'neo4j/jars/ha/neo4j-ha-0.6-1.3.M01.jar'
+    require 'neo4j/jars/ha/neo4j-management-1.3-1.3.M01.jar'
+    require 'neo4j/jars/ha/neo4j-shell-1.3-1.3.M01.jar'
     require 'neo4j/jars/ha/netty-3.2.1.Final.jar'
     require 'neo4j/jars/ha/org.apache.servicemix.bundles.jline-0.9.94_1.jar'
     require 'neo4j/jars/ha/org.apache.servicemix.bundles.lucene-3.0.1_2.jar'
@@ -39,77 +36,46 @@ module Neo4j
   end
 end
 
-require 'neo4j/to_java'
-require 'neo4j/version'
-require 'neo4j/equal'
+module Neo4j
+  include Java
+  
+  # Enumerator has been moved to top level in Ruby 1.9.2, make it compatible with Ruby 1.8.7
+  Enumerator = Enumerable::Enumerator unless defined? Enumerator
+end
 
-require 'neo4j/event_handler'
-require 'neo4j/type_converters'
-require 'neo4j/config'
-require 'neo4j/database'
+require 'neo4j/version'
 require 'neo4j/neo4j'
+require 'neo4j/node'
+require 'neo4j/relationship'
 
-require "neo4j/functions/function"
-require "neo4j/functions/count"
-require "neo4j/functions/sum"
+require 'neo4j/type_converters/type_converters'
 
+require 'neo4j/index/index'
 
+require 'neo4j/traversal/traversal'
 
-require 'neo4j/index/index'
-require 'neo4j/index/class_methods'
-require 'neo4j/index/indexer_registry'
-require 'neo4j/index/indexer'
-require 'neo4j/index/lucene_query'
-require 'neo4j/relationship_traverser'
-require 'neo4j/node_traverser'
-require 'neo4j/property'
-require 'neo4j/transaction'
-require 'neo4j/node_relationship'
-require 'neo4j/load'
-require 'neo4j/relationship'
-require 'neo4j/node'
-require 'neo4j/mapping/class_methods/init_node'
-require 'neo4j/mapping/class_methods/init_rel'
-require 'neo4j/mapping/class_methods/property'
-require 'neo4j/mapping/class_methods/relationship'
-require 'neo4j/mapping/class_methods/list'
-require 'neo4j/mapping/decl_relationship_dsl'
-require 'neo4j/mapping/has_n'
-require 'neo4j/mapping/has_list'
-require 'neo4j/mapping/node_mixin'
-require 'neo4j/mapping/relationship_mixin'
-require 'neo4j/mapping/rule'
-require 'neo4j/mapping/rule_node'
-
-require 'neo4j/node_mixin'
-require 'neo4j/relationship_mixin'
-require 'neo4j/mapping/class_methods/rule'
-require 'neo4j/algo'
-require 'neo4j/migrations'
-
-# rails
-require 'neo4j/rails/tx_methods'
-require 'neo4j/rails/transaction'
-require 'neo4j/rails/railtie'
-require 'neo4j/rails/validations/uniqueness'
-require 'neo4j/rails/validations/non_nil'
-require 'neo4j/rails/finders'
-require 'neo4j/rails/mapping/property'
-require 'neo4j/rails/validations'
-require 'neo4j/rails/callbacks'
-require 'neo4j/rails/timestamps'
-require 'neo4j/rails/serialization'
-require 'neo4j/rails/attributes'
-require 'neo4j/rails/persistence'
-require 'neo4j/rails/relationships/mapper'
-require 'neo4j/rails/relationships/relationship'
-require 'neo4j/rails/relationships/relationships'
-require 'neo4j/rails/model'
-require 'neo4j/rails/lucene_connection_closer'
+require 'neo4j/property/property'
+
+require 'neo4j/has_n/has_n'
+
+require 'neo4j/node_mixin/node_mixin'
+
+require 'neo4j/relationship_mixin/relationship_mixin'
+
+require 'neo4j/rule/rule'
+
+require 'neo4j/rels/rels'
+
+require 'neo4j/rails/rails'
 
 require 'neo4j/model'
+
+require 'neo4j/migrations/migrations'
+
+require 'neo4j/algo/algo'
+
+require 'neo4j/batch/batch'
+
 require 'orm_adapter/adapters/neo4j'
 
-# hmm, looks like Enumerator have been moved in some ruby versions
-Enumerator = Enumerable::Enumerator unless defined? Enumerator
 

data/lib/neo4j/{algo.rb → algo/algo.rb}

@@ -1,3 +1,7 @@
+# external neo4j dependencies
+require 'neo4j/to_java'
+require 'neo4j/jars/core/neo4j-graph-algo-0.8-1.3.M01.jar'
+
 module Neo4j
 
 
@@ -104,7 +108,7 @@ module Neo4j
     # ==== Parameters
     # * expander_proc :: a proc relationship type (symbol)
     def expand(&expander_proc)
-      @expander = (RelExpander.create_pair(&expander_proc))
+      @expander = (Neo4j::Traversal::RelExpander.create_pair(&expander_proc))
       self
     end
 

data/lib/neo4j/batch/batch.rb

@@ -0,0 +1,2 @@
+require 'neo4j/batch/inserter'
+require 'neo4j/batch/indexer'

data/lib/neo4j/batch/indexer.rb

@@ -0,0 +1,108 @@
+module Neo4j
+  module Batch
+    class Indexer
+
+      delegate :field_types, :entity_type, :indexer_for, :indexed_value_for, :lucene_config, :via_relationships, :to => :@wrapped_indexer
+
+      def initialize(wrapped_indexer)
+        @wrapped_indexer = wrapped_indexer
+        @parent_indexers = wrapped_indexer.parent_indexers.collect{|i| Indexer.new(i)}
+      end
+
+      def indexer_for_field(field, rel_type)
+        dsl = via_relationships[field]
+        return nil if dsl.nil?
+        return nil if dsl.rel_type != rel_type
+
+        target_class = dsl.target_class
+        self.class.instance_for(target_class)
+      end
+
+      def index_node_via_rel(rel_type, other, node_props) #:nodoc:
+        return if node_props.empty? || via_relationships.empty?
+        props_copy = node_props.clone
+
+        while !props_copy.empty?
+          indexer     = indexer_for_field(props_copy.keys.first, rel_type)
+
+          # put all other fields that are not of this index type in a new hash
+          other_index = {}
+          # delete all fields that are not of this index
+          props_copy.delete_if { |k, v| indexer != indexer_for_field(k, rel_type) && other_index[k] = v }
+          # add all those properties for this index
+          indexer && indexer.index_entity(other, props_copy)
+
+          # continue with the remaining fields
+          props_copy = other_index
+        end
+      end
+
+      def index_entity(entity_id, props)
+        filter_props = props.keys.inject({}) { |memo, field| memo[field] = indexed_value_for(field, props[field]) if field_types.has_key?(field); memo }
+
+        while !filter_props.empty?
+          # pick one index type
+          index       = batch_index_for_field(filter_props.keys[0])
+          # put all other fields that are not of this index type in a new hash
+          other_index = {}
+          # delete all fields that are not of this index
+          filter_props.delete_if { |k, v| index != batch_index_for_field(k) && other_index[k] = v }
+          # add all those properties for this index
+          index.add(entity_id, filter_props)
+          # continue with the remaining fields
+          filter_props = other_index
+        end
+
+        @parent_indexers.each { |i| i.index_entity(entity_id, props) }
+      end
+
+      def index_flush
+        return nil if @batch_indexes.nil?
+        @batch_indexes.values.each {|index| index.flush}
+      end
+
+      def index_get(key, value, index_type)
+        index = @batch_indexes && @batch_indexes[index_type]
+        return nil if index.nil?
+        index.get(key,value)
+      end
+
+      def index_query(query, index_type)
+        index = @batch_indexes && @batch_indexes[index_type]
+        return nil if index.nil?
+        index.query(query)
+      end
+
+
+      def batch_index_for_field(field)
+        type                 = field_types[field]
+        @batch_indexes       ||= {}
+        @batch_indexes[type] ||= create_batch_index_with(type)
+      end
+
+      def create_batch_index_with(type)
+        index_config = lucene_config(type)
+
+        if entity_type == :node
+          self.class.index_provider.node_index("#{indexer_for}-#{type}", index_config)
+        else
+          self.class.index_provider.relationship_index("#{indexer_for}-#{type}", index_config)
+        end
+      end
+
+      class << self
+        attr_accessor :index_provider
+      
+        def instance_for(clazz)
+          @instances ||= {}
+          @instances[clazz.to_s] ||= Indexer.new(clazz._indexer)
+        end
+
+        # Mostly for testing
+        def clear_all_instances
+          @instances = nil
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/batch/inserter.rb

@@ -0,0 +1,168 @@
+module Neo4j
+  module Batch
+
+    # = Batch Insert
+    # Neo4j has a batch insert mode that drops support for transactions and concurrency in favor of insertion speed.
+    # This is useful when you have a big dataset that needs to be loaded once. In our experience, the batch inserter will
+    # typically inject data around five times faster than running in normal transactional mode.
+    #
+    # Be aware that the BatchInserter is intended use is for initial import of data
+    # * non thread safe
+    # * non transactional
+    # * failure to successfully invoke shutdown (properly) results in corrupt database files
+    #
+    class Inserter
+      attr_reader :batch_inserter, :batch_indexer
+      include ToJava
+
+      # Creates a new batch inserter.
+      # Will raise an exception if Neo4j is already running at the same storage_path
+      # 
+      def initialize(storage_path=Neo4j.config.storage_path, config={})
+        # check if neo4j is running and using the same storage path
+        raise "Not allowed to start batch inserter while Neo4j is already running at storage location #{storage_path}" if Neo4j.storage_path == storage_path
+        @batch_inserter  = org.neo4j.kernel.impl.batchinsert.BatchInserterImpl.new(storage_path, config)
+        Indexer.index_provider  = org.neo4j.index.impl.lucene.LuceneBatchInserterIndexProvider.new(@batch_inserter)
+      end
+
+      def running?
+        @batch_inserter != nil
+      end
+
+      # This method MUST be called after inserting is completed.
+      def shutdown
+        @batch_inserter && @batch_inserter.shutdown
+        @batch_inserter = nil
+
+        Indexer.index_provider
+        Indexer.index_provider && Indexer.index_provider.shutdown
+        Indexer.index_provider = nil
+        Indexer.clear_all_instances
+      end
+
+      # Creates a node. Returns a Fixnum id of the created node.
+      # Adds a lucene index if there is a lucene index declared on the properties
+      def create_node(props=nil, clazz = Neo4j::Node)
+        props = {} if clazz != Neo4j::Node && props.nil?
+        props['_classname'] = clazz.to_s if clazz != Neo4j::Node
+
+        node = @batch_inserter.create_node(props)
+        props && _index(node, props, clazz)
+        node
+      end
+
+      # returns true if the node exists
+      def node_exist?(id)
+        @batch_inserter.node_exists(id)
+      end
+
+      def ref_node
+        @batch_inserter.get_reference_node
+      end
+
+      # creates a relationship between given nodes of given type.
+      # Returns a fixnum id of the created relationship.
+      def create_rel(rel_type, from_node, to_node, props=nil, clazz=Neo4j::Relationship)
+        props = {} if clazz != Neo4j::Relationship && props.nil?
+        props['_classname'] = clazz.to_s if clazz != Neo4j::Relationship
+        rel = @batch_inserter.create_relationship(from_node, to_node, type_to_java(rel_type), props)
+
+        props && _index(rel, props, clazz)
+
+        from_props = node_props(from_node)
+
+        if from_props['_classname']
+          indexer = Indexer.instance_for(from_props['_classname'])
+          indexer.index_node_via_rel(rel_type, to_node, from_props)
+        end
+
+        to_props   = node_props(to_node)
+        if to_props['_classname']
+          indexer = Indexer.instance_for(to_props['_classname'])
+          indexer.index_node_via_rel(rel_type, from_node, to_props)
+        end
+
+      end
+
+      # Return a hash of all properties of given node
+      def node_props(node)
+        @batch_inserter.get_node_properties(node)
+      end
+
+      # Sets the properties of the given node, overwrites old properties
+      def set_node_props(node, hash, clazz = Neo4j::Node)
+        @batch_inserter.set_node_properties(node, hash)
+        _index(node, hash, clazz)
+      end
+
+      # Sets the old properties of the given relationship, overwrites old properties
+      def set_rel_props(rel, hash)
+        @batch_inserter.set_relationship_properties(rel, hash)
+      end
+
+      # Returns the properties of the given relationship
+      def rel_props(rel)
+        @batch_inserter.get_relationship_properties(rel)
+      end
+      
+      # Returns all the relationships of the given node
+      def rels(node)
+        @batch_inserter.getRelationships(node)
+      end
+
+      #  Makes sure additions/updates can be seen by #index_get and #index_query
+      # so that they are guaranteed to return correct results.
+      def index_flush(clazz = Neo4j::Node)
+        indexer = Indexer.instance_for(clazz)
+        indexer.index_flush
+      end
+
+      #  Returns matches from the index specified by index_type and class.
+      #
+      # ==== Parameters
+      # * key :: the lucene key
+      # * value :: the lucene value we look for given the key
+      # * index_type :: :exact or :fulltext
+      # * clazz :: on which clazz we want to perform the query
+      #
+      def index_get(key, value, index_type = :exact, clazz = Neo4j::Node)
+        indexer = Indexer.instance_for(clazz)
+        indexer.index_get(key, value, index_type)
+      end
+
+      #  Returns matches from the index specified by index_type and class.
+      #
+      # ==== Parameters
+      # * query :: lucene query
+      # * index_type :: :exact or :fulltext
+      # * clazz :: on which clazz we want to perform the query
+      #
+      def index_query(query, index_type = :exact, clazz = Neo4j::Node)
+        indexer = Indexer.instance_for(clazz)
+        indexer.index_query(query, index_type)
+      end
+
+      # index the given entity (a node or a relationship)
+      def _index(entity, props, clazz = Neo4j::Node) #:nodoc:
+        indexer = Indexer.instance_for(clazz)
+        indexer.index_entity(entity, props)
+      end
+
+
+      # hmm, maybe faster not wrapping this ?
+      def to_java_map(hash)
+        return nil if hash.nil?
+        map = java.util.HashMap.new
+        hash.each_pair do |k, v|
+          case v
+            when Symbol
+              map[k.to_s] = v.to_s
+            else
+              map[k.to_s] = v
+          end
+        end
+        map
+      end
+    end
+  end
+end