neo4j-core 0.0.1-java

data/lib/neo4j-core/cypher/result_wrapper.rb

@@ -0,0 +1,39 @@
+module Neo4j
+  module Core
+    module Cypher
+      # Wraps the Cypher query result
+      # Loads the wrapper if possible and use symbol as keys.
+      class ResultWrapper
+        include Enumerable
+
+        # @return the original result from the Neo4j Cypher Engine
+        attr_reader :source
+
+        def initialize(source)
+          @source = source
+        end
+
+        # @return [Array<Symbol>] the columns in the query result
+        def columns
+          @source.columns.map{|x| x.to_sym}
+        end
+
+        # for the Enumerable contract
+        def each
+          @source.each { |row| yield map(row) }
+        end
+
+        # Maps each row
+        # @private
+        def map(row)
+          out = {} # move to a real hash!
+          row.each do |key, value|
+            out[key.to_sym] = value.respond_to?(:wrapper) ? value.wrapper : value
+          end
+          out
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j-core/database.rb

@@ -0,0 +1,191 @@
+module Neo4j
+  module Core
+    # Wraps both Java Neo4j GraphDatabaseService and Lucene.
+    # You can access the raw java neo4j and lucene db's with the <tt>graph</tt> and <tt>lucene</tt>
+    # properties.
+    #
+    # This class is also responsible for checking if there is already a running neo4j database.
+    # If one tries to start an already started database then a read only instance to neo4j will be used.
+    # Many of the methods here are delegated from the Neo4j module
+    #
+    # @private
+    class Database
+
+      # The Java graph database
+      # @see http://components.neo4j.org/neo4j/1.6.1/apidocs/org/neo4j/graphdb/GraphDatabaseService.html
+      # @return [Java::OrgNeo4jGraphdb::GraphDatabaseService]
+      attr_reader :graph
+
+      # The lucene index manager
+      # @see http://components.neo4j.org/neo4j/1.6.1/apidocs/org/neo4j/graphdb/index/IndexManager.html
+      # @return [Java::OrgNeo4jGraphdbIndex::IndexManager]
+      attr_reader :lucene
+
+      # @return [Neo4j::EventHandler] the event handler listining to commit events
+      attr_reader :event_handler
+
+      # @return [String] The location of the database
+      attr_reader :storage_path
+
+      alias_method :index, :lucene # needed by cypher
+
+      def initialize()
+        @event_handler = EventHandler.new
+      end
+
+      def self.default_embedded_db
+        @default_embedded_db || Java::OrgNeo4jKernel::EmbeddedGraphDatabase
+      end
+
+      def self.default_embedded_db=(db)
+        @default_embedded_db = db
+      end
+
+      # Private start method, use Neo4j.start instead
+      # @see Neo4j#start
+      def start
+        return if running?
+        @running = true
+        @storage_path = Config.storage_path
+
+        begin
+          if self.class.locked?
+            start_readonly_graph_db
+          elsif Neo4j::Config['ha.db']
+            start_ha_graph_db
+            Neo4j.migrate!
+          else
+            start_local_graph_db
+            Neo4j.migrate!
+          end
+        rescue
+          @running = false
+          raise
+        end
+
+        at_exit { shutdown }
+      end
+
+
+      def running? #:nodoc:
+        @running
+      end
+
+      # Returns true if the neo4j db was started in read only mode.
+      # This can occur if the database was locked (it was already one instance running).
+      # @see Neo4j#read_only?
+      def read_only?
+        @graph.java_class == Java::OrgNeo4jKernel::EmbeddedReadOnlyGraphDatabase
+      end
+
+      # check if the database is locked. A neo4j database is locked when the database is running.
+      def self.locked?
+        lock_file = File.join(Neo4j.config.storage_path, 'neostore')
+        return false unless File.exist?(lock_file)
+        rfile = java.io.RandomAccessFile.new(lock_file, 'rw')
+        begin
+          lock = rfile.getChannel.tryLock
+          lock.release if lock
+          return lock == nil # we got the lock, so that means it is not locked.
+        rescue Exception => e
+          return false
+        end
+      end
+
+      # Internal method, see Neo4j#shutdown
+      def shutdown
+        if @running
+          @graph.unregister_transaction_event_handler(@event_handler) unless read_only?
+          @event_handler.neo4j_shutdown(self)
+          @graph.shutdown
+          @graph = nil
+          @lucene = nil
+          @running = false
+          @neo4j_manager = nil
+        end
+      end
+
+
+      # @see Neo4j.management
+      def management(jmx_clazz)
+        @neo4j_manager ||= Java::OrgNeo4jManagement::Neo4jManager.new(@graph.get_management_bean(org.neo4j.jmx.Kernel.java_class))
+        @neo4j_manager.getBean(jmx_clazz.java_class)
+      end
+
+      # private method, used from Neo4j::Transaction.new
+      def begin_tx
+        @graph.begin_tx
+      end
+
+      # @see Neo4j.all_nodes
+      def each_node
+        iter = @graph.all_nodes.iterator
+        while (iter.hasNext)
+          yield iter.next.wrapper
+        end
+      end
+
+      # @see Neo4j._all_nodes
+      def _each_node
+        iter = @graph.all_nodes.iterator
+        while (iter.hasNext)
+          yield iter.next
+        end
+      end
+
+      private
+
+      def start_readonly_graph_db
+        Neo4j.logger.info "Starting Neo4j in readonly mode since the #{@storage_path} is locked"
+        @graph = Java::OrgNeo4jKernel::EmbeddedReadOnlyGraphDatabase.new(@storage_path, Config.to_java_map)
+        @lucene = @graph.index
+      end
+
+      def start_local_graph_db
+        Neo4j.logger.info "Starting local Neo4j using db #{@storage_path} using #{self.class.default_embedded_db}"
+        @graph = self.class.default_embedded_db.new(@storage_path, Config.to_java_map)
+        @graph.register_transaction_event_handler(@event_handler)
+        @lucene = @graph.index
+        @event_handler.neo4j_started(self)
+      end
+
+      # needed by cypher
+      def getNodeById(id) #:nodoc:
+        Neo4j::Node.load(id)
+      end
+
+      # needed by cypher
+      def getRelationshipById(id) #:nodoc:
+        Neo4j::Relationship.load(id)
+      end
+
+      def start_ha_graph_db
+        Neo4j.logger.info "starting Neo4j in HA mode, machine id: #{Neo4j.config['ha.server_id']} at #{Neo4j.config['ha.server']} db #{@storage_path}"
+        # Modify the public base classes for the HA Node and Relationships
+        # (instead of private Java::OrgNeo4jKernel::HighlyAvailableGraphDatabase::LookupNode)
+        Neo4j::Node.extend_java_class(Java::OrgNeo4jToolingWrap::WrappedNode)
+        Neo4j::Relationship.extend_java_class(Java::OrgNeo4jToolingWrap::WrappedRelationship)
+        @graph = Java::OrgNeo4jKernel::HighlyAvailableGraphDatabase.new(@storage_path, Neo4j.config.to_java_map)
+        @graph.register_transaction_event_handler(@event_handler)
+        @lucene = @graph.index
+        @event_handler.neo4j_started(self)
+      end
+
+      def start_external_db(external_graph_db)
+        begin
+          @running = true
+          @graph = external_graph_db
+          Neo4j.migrate!
+          @graph.register_transaction_event_handler(@event_handler)
+          @lucene = @graph.index #org.neo4j.index.impl.lucene.LuceneIndexProvider.new
+          @event_handler.neo4j_started(self)
+          Neo4j.logger.info("Started with external db")
+        rescue
+          @running = false
+          raise
+        end
+      end
+
+    end
+  end
+end

data/lib/neo4j-core/equal/equal.rb

@@ -0,0 +1,23 @@
+module Neo4j
+  module Core
+
+    # == This mixin is used for both nodes and relationships to decide if two entities are equal or not.
+    #
+    module Equal
+      def equal?(o)
+        eql?(o)
+      end
+
+      def eql?(o)
+        return false unless o.respond_to?(:getId)
+        o.getId == getId
+      end
+
+      def ==(o)
+        eql?(o)
+      end
+
+    end
+  end
+
+end

data/lib/neo4j-core/event_handler.rb

@@ -0,0 +1,265 @@
+module Neo4j
+  module Core
+
+    # == Handles Transactional Events
+    #
+    # You can use this to receive event before the transaction commits.
+    # The following events are supported:
+    # * <tt>on_neo4j_started</tt>
+    # * <tt>on_neo4j_shutdown</tt>
+    # * <tt>on_node_created</tt>
+    # * <tt>on_node_deleted</tt>
+    # * <tt>on_relationship_created</tt>
+    # * <tt>on_relationship_deleted</tt>
+    # * <tt>on_property_changed</tt>
+    # * <tt>on_rel_property_changed</tt>
+    # * <tt>on_after_commit</tt>
+    #
+    # ==== on_neo4j_started(db)
+    #
+    # Called when the neo4j engine starts.
+    # Notice that the neo4j will be started automatically when the first neo4j operation is performed.
+    # You can also start Neo4j: <tt>Neo4j.start</tt>
+    #
+    # * <tt>db</tt> :: the Neo4j::Database instance
+    #
+    # ==== on_neo4j_shutdown(db)
+    #
+    # Called when the neo4j engine shutdown. You don't need to call <tt>Neo4j.shutdown</tt> since
+    # the it will automatically be shutdown when the application exits (using the at_exit ruby hook).
+    #
+    # * <tt>db</tt> :: the Neo4j::Database instance
+    #
+    # ==== on_after_commit(data, state)
+    #
+    # Called after the transaction has successfully committed.
+    # See http://api.neo4j.org/1.4/org/neo4j/graphdb/event/TransactionEventHandler.html for the data and state parameter.
+    #
+    # ==== on_node_created(node)
+    #
+    # * <tt>node</tt> :: the node that was created
+    #
+    # ==== on_node_deleted(node, old_props, deleted_relationship_set, deleted_node_identity_map)
+    #
+    # * <tt>node</tt> :: the node that was deleted
+    # * <tt>old_props</tt> :: a hash of the old properties this node had
+    # * <tt>deleted_relationship_set</tt> :: the set of deleted relationships. See Neo4j::Core::RelationshipSet
+    # * <tt>deleted_node_identity_map</tt> :: the identity map of deleted nodes. The key is the node id, and the value is the node
+    #
+    # ==== on_relationship_created(rel, created_node_identity_map)
+    #
+    # * <tt>rel</tt> :: the relationship that was created
+    # * <tt>created_node_identity_map</tt> :: the identity map of created nodes. The key is the node id, and the value is the node
+    #
+    # ==== on_relationship_deleted(rel, old_props, deleted_relationship_set, deleted_node_identity_map)
+    #
+    # * <tt>rel</tt> :: the relationship that was created
+    # * <tt>old_props</tt> :: a hash of the old properties this relationship had
+    # * <tt>deleted_relationship_set</tt> :: the set of deleted relationships. See Neo4j::Core::RelationshipSet
+    # * <tt>deleted_node_identity_map</tt> :: the identity map of deleted nodes. The key is the node id, and the value is the node
+    #
+    # ==== on_property_changed(node, key, old_value, new_value)
+    #
+    # * <tt>node</tt> :: the node
+    # * <tt>key</tt> :: the name of the property that was changed (String)
+    # * <tt>old_value</tt> :: old value of the property
+    # * <tt>new_value</tt> :: new value of the property
+    #
+    # ==== on_rel_property_changed(rel, key, old_value, new_value)
+    #
+    # * <tt>rel</tt> :: the node that was created
+    # * <tt>key</tt> :: the name of the property that was changed (String)
+    # * <tt>old_value</tt> :: old value of the property
+    # * <tt>new_value</tt> :: new value of the property
+    #
+    # ==== classes_changed(class_change_map)
+    # * <tt>class_change_map</tt> :: a hash with class names as keys, and class changes as values. See Neo4j::ClassChanges
+    #
+    # == Usage
+    #
+    #   class MyListener
+    #     def on_node_deleted(node, old_props, deleted_relationship_set, deleted_node_identity_map)
+    #     end
+    #   end
+    #
+    #   # to add an listener without starting neo4j:
+    #   Neo4j.unstarted_db.event_handler.add(MyListener.new)
+    #
+    # You only need to implement the methods that you need.
+    #
+    class EventHandler
+      include org.neo4j.graphdb.event.TransactionEventHandler
+
+      def initialize
+        @listeners = []
+      end
+
+
+      def after_commit(data, state)
+        @listeners.each { |li| li.on_after_commit(data, state) if li.respond_to?(:on_after_commit) }
+      end
+
+      def after_rollback(data, state)
+      end
+
+      def before_commit(data)
+        class_change_map = java.util.HashMap.new
+        created_node_identity_map = iterate_created_nodes(data.created_nodes, class_change_map)
+        deleted_node_identity_map = deleted_node_identity_map(data.deleted_nodes)
+        deleted_relationship_set = relationship_set(data.deleted_relationships)
+        removed_node_properties_map = property_map(data.removed_node_properties)
+        removed_relationship_properties_map = property_map(data.removed_relationship_properties)
+        add_deleted_nodes(data, class_change_map, removed_node_properties_map)
+        empty_map = java.util.HashMap.new
+        data.assigned_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) unless tx_data.key == '_classname' }
+        data.removed_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless deleted_node_identity_map.containsKey(tx_data.entity.getId) }
+        data.deleted_nodes.each { |node| node_deleted(node, removed_node_properties_map.get(node.getId)||empty_map, deleted_relationship_set, deleted_node_identity_map) }
+        data.created_relationships.each { |rel| relationship_created(rel, created_node_identity_map) }
+        data.deleted_relationships.each { |rel| relationship_deleted(rel, removed_relationship_properties_map.get(rel.getId)||empty_map, deleted_relationship_set, deleted_node_identity_map) }
+        data.assigned_relationship_properties.each { |tx_data| rel_property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) }
+        data.removed_relationship_properties.each { |tx_data| rel_property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless deleted_relationship_set.contains_rel?(tx_data.entity) }
+        classes_changed(class_change_map)
+      rescue Exception => e
+        # since these exceptions gets swallowed
+        puts "ERROR in before commit hook #{e}"
+        puts e.backtrace.join("\n")
+      end
+
+
+      def iterate_created_nodes(nodes, class_change_map)
+        identity_map = java.util.HashMap.new
+        nodes.each do |node|
+          identity_map.put(node.neo_id, node) #using put due to a performance regression in JRuby 1.6.4
+          instance_created(node, class_change_map)
+          node_created(node)
+        end
+        identity_map
+      end
+
+      def deleted_node_identity_map(nodes)
+        identity_map = java.util.HashMap.new
+        nodes.each { |node| identity_map.put(node.neo_id, node) } #using put due to a performance regression in JRuby 1.6.4
+        identity_map
+      end
+
+      def relationship_set(relationships)
+        relationship_set = Neo4j::Core::RelationshipSet.new #(relationships.size)
+        relationships.each { |rel| relationship_set.add(rel) }
+        relationship_set
+      end
+
+      def property_map(properties)
+        map = java.util.HashMap.new
+        properties.each do |property|
+          map(property.entity.getId, map).put(property.key, property.previously_commited_value)
+        end
+        map
+      end
+
+      def map(key, map)
+        map.get(key) || add_map(key, map)
+      end
+
+      def add_map(key, map)
+        map.put(key, java.util.HashMap.new)
+        map.get(key)
+      end
+
+      def add(listener)
+        @listeners << listener unless @listeners.include?(listener)
+      end
+
+      def remove(listener)
+        @listeners.delete(listener)
+      end
+
+      def remove_all
+        @listeners = []
+      end
+
+      def print
+        puts "Listeners #{@listeners.size}"
+        @listeners.each { |li| puts "  Listener '#{li}'" }
+      end
+
+      def neo4j_started(db)
+        @listeners.each { |li| li.on_neo4j_started(db) if li.respond_to?(:on_neo4j_started) }
+      end
+
+      def neo4j_shutdown(db)
+        @listeners.each { |li| li.on_neo4j_shutdown(db) if li.respond_to?(:on_neo4j_shutdown) }
+      end
+
+      def node_created(node)
+        @listeners.each { |li| li.on_node_created(node) if li.respond_to?(:on_node_created) }
+      end
+
+      def node_deleted(node, old_properties, deleted_relationship_set, deleted_node_identity_map)
+        @listeners.each { |li| li.on_node_deleted(node, old_properties, deleted_relationship_set, deleted_node_identity_map) if li.respond_to?(:on_node_deleted) }
+      end
+
+      def relationship_created(relationship, created_node_identity_map)
+        @listeners.each { |li| li.on_relationship_created(relationship, created_node_identity_map) if li.respond_to?(:on_relationship_created) }
+      end
+
+      def relationship_deleted(relationship, old_props, deleted_relationship_set, deleted_node_identity_map)
+        @listeners.each { |li| li.on_relationship_deleted(relationship, old_props, deleted_relationship_set, deleted_node_identity_map) if li.respond_to?(:on_relationship_deleted) }
+      end
+
+      def property_changed(node, key, old_value, new_value)
+        @listeners.each { |li| li.on_property_changed(node, key, old_value, new_value) if li.respond_to?(:on_property_changed) }
+      end
+
+      def rel_property_changed(rel, key, old_value, new_value)
+        @listeners.each { |li| li.on_rel_property_changed(rel, key, old_value, new_value) if li.respond_to?(:on_rel_property_changed) }
+      end
+
+      def add_deleted_nodes(data, class_change_map, removed_node_properties_map)
+        data.deleted_nodes.each { |node| instance_deleted(node, removed_node_properties_map, class_change_map) }
+      end
+
+      def instance_created(node, class_change_map)
+        classname = node[:_classname]
+        class_change(classname, class_change_map).add(node) if classname
+      end
+
+      def instance_deleted(node, removed_node_properties_map, class_change_map)
+        properties = removed_node_properties_map.get(node.getId)
+        if properties
+          classname = properties.get("_classname")
+          class_change(classname, class_change_map).delete(node) if classname
+        end
+      end
+
+      def class_change(classname, class_change_map)
+        class_change_map.put(classname, ClassChanges.new) if class_change_map.get(classname).nil?
+        class_change_map.get(classname)
+      end
+
+      def classes_changed(changed_class_map)
+        @listeners.each { |li| li.classes_changed(changed_class_map) if li.respond_to?(:classes_changed) }
+      end
+    end
+
+    class ClassChanges
+      attr_accessor :added, :deleted
+
+      def initialize
+        self.added = []
+        self.deleted = []
+      end
+
+      def add(node)
+        self.added << node
+      end
+
+      def delete(node)
+        self.deleted << node
+      end
+
+      def net_change
+        self.added.size - self.deleted.size
+      end
+    end
+  end
+end

data/lib/neo4j-core/index/class_methods.rb

@@ -0,0 +1,117 @@
+module Neo4j
+  module Core
+    module Index
+      module ClassMethods
+
+        # The indexer which we are delegating to
+        attr_reader :_indexer
+
+
+        # TODO YARD
+        # Sets which indexer should be used for the given node class.
+        # You can share an indexer between several different classes.
+        #
+        # @example Using custom index
+        #
+        #   class MyIndex
+        #      extend Neo4j::Core::Index::ClassMethods
+        #      include Neo4j::Core::Index
+        #
+        #      node_indexer do
+        #        index_names :exact => 'myindex_exact', :fulltext => 'myindex_fulltext'
+        #        trigger_on :ntype => 'foo', :name => ['bar', 'foobar']
+        #
+        #        prefix_index_name do
+        #          return "" unless Neo4j.running?
+        #          return "" unless @indexer_for.respond_to?(:ref_node_for_class)
+        #          ref_node = @indexer_for.ref_node_for_class.wrapper
+        #          prefix = ref_node.send(:_index_prefix) if ref_node.respond_to?(:_index_prefix)
+        #          prefix ||= ref_node[:name] # To maintain backward compatiblity
+        #          prefix.blank? ? "" : prefix + "_"
+        #         end
+        #
+        #
+        #        numeric do
+        #           type = decl_props && decl_props[field.to_sym] && decl_props[field.to_sym][:type]
+        #           type && !type.is_a?(String)
+        #        end
+        #      end
+        #   end
+        #
+        # @example Using Neo4j::NodeMixin
+        #
+        #   class Contact
+        #      include Neo4j::NodeMixin
+        #      index :name
+        #      has_one :phone
+        #   end
+        #
+        #   class Phone
+        #      include Neo4j::NodeMixin
+        #      property :phone
+        #      node_indexer Contact  # put index on the Contact class instead
+        #      index :phone
+        #   end
+        #
+        #   # Find an contact with a phone number, this works since they share the same index
+        #   Contact.find('phone: 12345').first #=> a phone object !
+        #
+        # @return [Neo4j::Core::Index::Indexer] The indexer that should be used to index the given class
+        # @see Neo4j::Core::Index::IndexConfig for possible configuration values in the +config_dsl+ block
+        # @yield evaluated in the a Neo4j::Core::Index::IndexConfig object to configure it.
+        def node_indexer(&config_dsl)
+          # TODO reuse an existing index config
+          config = IndexConfig.new(:node)
+          config.instance_eval(&config_dsl)
+          indexer(config)
+        end
+
+        # Sets which indexer should be used for the given relationship class
+        # Same as #node_indexer except that it indexes relationships instead of nodes.
+        #
+        # @see #node_indexer
+        # @return [Neo4j::Core::Index::Indexer] The indexer that should be used to index the given class
+        def rel_indexer(clazz)
+          indexer(clazz, :rel)
+        end
+
+
+        def indexer(index_config)
+          @_indexer ||= IndexerRegistry.instance.register(Indexer.new(index_config))
+        end
+
+
+        class << self
+          private
+
+
+          # @macro [attach] index.delegate
+          #   @method $1(*args, &block)
+          #   Delegates the `$1` message to @_indexer instance with the supplied parameters.
+          #   @see Neo4j::Core::Index::Indexer#$1
+          def delegate(method_name)
+            class_eval(<<-EOM, __FILE__, __LINE__)
+              def #{method_name}(*args, &block)
+                _indexer.send(:#{method_name}, *args, &block)
+              end
+            EOM
+          end
+
+        end
+
+        delegate :index
+        delegate :find
+        delegate :index?
+        delegate :has_index_type?
+        delegate :rm_index_type
+        delegate :rm_index_config
+        delegate :add_index
+        delegate :rm_index
+        delegate :index_type
+        delegate :index_name_for_type
+      end
+
+
+    end
+  end
+end

data/lib/neo4j-core/index/index.rb

@@ -0,0 +1,36 @@
+module Neo4j
+  module Core
+
+    # A mixin which adds indexing behaviour to your own Ruby class
+    # You are expected to implement the method `wrapped_entity` returning the underlying Neo4j Node or Relationship
+    module Index
+
+      # Adds an index on the given property
+      # Notice that you normally don't have to do that since you simply can declare
+      # that the property and index should be updated automatically by using the class method #index.
+      #
+      # The index operation will take place immediately unlike when using the Neo4j::Core::Index::ClassMethods#index
+      # method which instead will guarantee that the neo4j database and the lucene database will be consistent.
+      # It uses a two phase commit when the transaction is about to be committed.
+      #
+      # @see Neo4j::Core::Index::ClassMethods#add_index
+      #
+      def add_index(field, value=self[field])
+        converted_value = Neo4j::TypeConverters.convert(value, field, self.class)
+        self.class.add_index(wrapped_entity, field.to_s, converted_value)
+      end
+
+      # Removes an index on the given property.
+      # Just like #add_index this is normally not needed since you instead can declare it with the
+      # #index class method instead.
+      #
+      # @see Neo4j::Core::Index::ClassMethods#rm_index
+      #
+      def rm_index(field, value=self[field])
+        self.class.rm_index(wrapped_entity, field.to_s, value)
+      end
+
+    end
+  end
+
+end