neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/batch/batch.rb

@@ -1,4 +0,0 @@
-require 'neo4j/batch/inserter'
-require 'neo4j/batch/indexer'
-require 'neo4j/batch/rule_inserter'
-require 'neo4j/batch/rule_node'

data/lib/neo4j/batch/indexer.rb

@@ -1,109 +0,0 @@
-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.index_names[type], index_config)
-        else
-          self.class.index_provider.relationship_index(indexer_for.index_names[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

@@ -1,179 +0,0 @@
-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
-      include Neo4j::Load
-
-      # 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)
-        @rule_inserter = RuleInserter.new(self)
-      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
-        @rule_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
-
-        props = ensure_valid_props(props)
-
-        node = @batch_inserter.create_node(props)
-        props && _index(node, props, clazz)
-        @rule_inserter.node_added(node, props)
-        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
-
-        props = ensure_valid_props(props)
-
-        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']
-          from_class = to_class(from_props['_classname'])
-          indexer = Indexer.instance_for(from_class)
-          indexer.index_node_via_rel(rel_type, to_node, from_props)
-        end
-
-        to_props   = node_props(to_node)
-        if to_props['_classname']
-          to_class = to_class(to_props['_classname'])
-          indexer = Indexer.instance_for(to_class)
-          indexer.index_node_via_rel(rel_type, from_node, to_props)
-        end
-        rel
-      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

data/lib/neo4j/batch/rule_inserter.rb

@@ -1,24 +0,0 @@
-module Neo4j
-  module Batch
-    class RuleInserter #:nodoc:
-      def initialize(inserter)
-        @inserter = inserter
-      end
-
-      def node_added(node, props)
-        classname = props && props['_classname']
-        classname && create_rules(node, props, classname)
-      end
-
-
-      def create_rules(node, props, classname)
-        rule_node = RuleNode.rule_node_for(classname, @inserter)
-        rule_node && rule_node.execute_rules(@inserter, node, props)
-
-        if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
-          create_rules(node, props, clazz.to_s)
-        end
-      end
-    end
-  end
-end

data/lib/neo4j/batch/rule_node.rb

@@ -1,72 +0,0 @@
-module Neo4j
-  module Batch
-    class RuleNode #:nodoc:
-      attr_reader :node
-      delegate :rules, :to => :@wrapped_rule_node
-
-      def initialize(wrapped_rule_node, node)
-        @wrapped_rule_node = wrapped_rule_node
-        @node              = node
-      end
-
-      def execute_rules(inserter, node, props)
-        rules.each do |rule|
-          if execute_filter(rule, props)
-            inserter.create_rel(rule.rule_name, @node, node)
-            execute_add_functions(inserter, rule, props)
-          end
-        end
-      end
-
-      def execute_add_functions(inserter, rule, props)
-        rule_props = nil
-        executed_functions = []
-        props.keys.each do |key|
-          functions = rule.functions_for(key)
-          next unless functions
-          functions -= executed_functions
-          rule_props ||= clone_node_props(inserter) #inserter.node_props(@node)
-          functions.each { |f| executed_functions << f; f.add(rule.rule_name, rule_props, props[key]) }
-        end
-        rule_props && inserter.set_node_props(@node, rule_props)
-      end
-
-      def clone_node_props(inserter)
-        hash = {}
-        props = inserter.node_props(@node)  # need to clone this since we can't modify it
-        props.each_pair{|k,v| hash[k]=v}
-        hash
-      end
-      
-      def execute_filter(rule, props)
-        if rule.filter.nil?
-          true
-        elsif rule.filter.arity != 1
-          classname = props['_classname'] || 'Neo4j::Node'
-          clazz     = Neo4j::Node.to_class(classname)
-          wrapper   = clazz.load_wrapper(ActiveSupport::HashWithIndifferentAccess.new(props))
-          wrapper.instance_eval(&rule.filter)
-        else
-          rule.filter.call(ActiveSupport::HashWithIndifferentAccess.new(props))
-        end
-      end
-
-      class << self
-        def rule_node_for(classname, inserter)
-          return nil unless Neo4j::Rule::Rule.has_rules?(classname)
-          wrapped_rule_node      = Neo4j::Rule::Rule.rule_node_for(classname)
-          @rule_nodes            ||= {}
-          @rule_nodes[classname] ||= RuleNode.new(wrapped_rule_node, create_node(classname, inserter))
-        end
-
-        def create_node(classname, inserter)
-          rule_node = inserter.create_node
-          inserter.create_rel(classname, inserter.ref_node, rule_node)
-          rule_node
-        end
-      end
-
-
-    end
-  end
-end

data/lib/neo4j/config.rb

@@ -1,177 +0,0 @@
-
-module Neo4j
-
-
-  # == Keeps configuration for neo4j
-  #
-  # The most important configuration is <tt>Neo4j::Config[:storage_path]</tt> which is used to
-  # locate where the neo4j database is stored on the filesystem.
-  # If this directory is empty then a new database will be created, otherwise it will use the
-  # database from that directory.
-  #
-  # ==== Default Configurations
-  # <tt>:storage_path</tt>::   default <tt>tmp/neo4j</tt> where the database is stored
-  # <tt>:timestamps</tt>::     default <tt>true</tt> for Rails Neo4j::Model - if timestamps should be used when saving the model
-  # <tt>:lucene</tt>::         default hash keys: <tt>:fulltext</tt>, <tt>:exact</tt> configuration how the lucene index is stored
-  # <tt>:enable_rules</tt>::   default true, if false the _all relationship to all instances will not be created and custom rules will not be available.
-  # <tt>:identity_map</tt>::   default false, See Neo4j::IdentityMap
-  #
-  class Config
-    # This code is copied from merb-core/config.rb.
-    class << self
-
-      # The location of the default configuration file
-      def default_file
-        @default_file ||= File.expand_path(File.join(File.dirname(__FILE__), "..", "..",  "config", "neo4j", "config.yml"))
-      end
-
-      # You can keep all the configuration in your own yaml file
-      # Also deletes all old configurations.
-      def default_file=(file_path)
-        @configuration = nil
-        @defaults = nil
-        @default_file = File.expand_path(file_path)
-      end
-
-      # Returns the hash of default config values for neo4j.
-      #
-      # ==== Returns
-      # Hash:: The defaults for the config.
-      def defaults
-        @defaults ||= YAML.load_file(default_file)
-      end
-
-      # Returns a Java HashMap used by the Java Neo4j API as configuration for the GraphDatabase
-      def to_java_map
-        map = java.util.HashMap.new
-        to_hash.each_pair do |k, v|
-          case v
-            when TrueClass
-              map[k.to_s] = "YES"
-            when FalseClass
-              map[k.to_s] = "NO"
-            when String, Fixnum, Float
-              map[k.to_s] = v.to_s
-            # skip list and hash values - not accepted by the Java Neo4j API
-          end
-        end
-        map
-      end
-
-
-      # Returns the expanded path of the Config[:storage_path] property
-      def storage_path
-        File.expand_path(self[:storage_path])
-      end
-
-      # Yields the configuration.
-      #
-      # ==== Block parameters
-      # c :: The configuration parameters, a hash.
-      #
-      # ==== Examples
-      # Neo4j::Config.use do |config|
-      #   config[:storage_path] = '/var/neo4j'
-      # end
-      #
-      # ==== Returns
-      # nil
-      def use
-        @configuration ||= {}
-        yield @configuration
-        nil
-      end
-      
-      
-      # Set the value of a config entry.
-      #
-      # ==== Parameters
-      # key :: The key to set the parameter for.
-      # val :: The value of the parameter.
-      #
-      def []=(key, val)
-        (@configuration ||= setup)[key] = val
-      end
-
-
-      # Gets the the value of a config entry
-      #
-      # ==== Parameters
-      # key:: The key of the config entry value we want
-      #
-      def [](key)
-        (@configuration ||= setup)[key]
-      end
-
-
-      # Remove the value of a config entry.
-      #
-      # ==== Parameters
-      # key<Object>:: The key of the parameter to delete.
-      #
-      # ==== Returns
-      # The value of the removed entry.
-      #
-      def delete(key)
-        @configuration.delete(key)
-      end
-
-
-      # Remove all configuration. This can be useful for testing purpose.
-      #
-      #
-      # ==== Returns
-      # nil
-      #
-      def delete_all
-        @configuration = nil
-      end
-
-
-      # Retrieve the value of a config entry, returning the provided default if the key is not present
-      #
-      # ==== Parameters
-      # key:: The key to retrieve the parameter for.
-      # default::The default value to return if the parameter is not set.
-      #
-      # ==== Returns
-      # The value of the configuration parameter or the default.
-      #
-      def fetch(key, default)
-        @configuration.fetch(key, default)
-      end
-
-      # Sets up the configuration to use the default.
-      #
-      # ==== Returns
-      # The a new configuration using default values as a hash.
-      #
-      def setup()
-        @configuration = defaults.with_indifferent_access #nested_under_indifferent_access
-        @configuration.merge!(defaults)
-        @configuration
-      end
-
-
-      # Returns the configuration as a hash.
-      #
-      # ==== Returns
-      # The config as a hash.
-      #
-      def to_hash
-        @configuration ||= setup
-      end
-
-      # Returns the config as YAML.
-      #
-      # ==== Returns
-      # The config as YAML.
-      #
-      def to_yaml
-        require "yaml"
-        @configuration.to_yaml
-      end
-    end
-  end
-
-end