neo4j 1.0.0.beta.21-java

data/lib/neo4j/index/indexer.rb

@@ -0,0 +1,312 @@
+module Neo4j
+  module Index
+    class Indexer 
+      attr_reader :indexer_for, :field_types, :via_relationships
+
+      def initialize(clazz, type) #:nodoc:
+        # part of the unique name of the index
+        @indexer_for       = clazz
+
+        # do we want to index nodes or relationships ?
+        @type              = type
+
+        @indexes           = {} # key = type, value = java neo4j index
+        @field_types       = {} # key = field, value = type (e.g. :exact or :fulltext)
+        @via_relationships = {} # key = field, value = relationship
+
+        # to enable subclass indexing to work properly, store a list of parent indexers and
+        # whenever an operation is performed on this one, perform it on all
+        @parent_indexers   = []
+      end
+
+      def inherit_fields_from(parent_index) #:nodoc:
+        return unless parent_index
+        @field_types.reverse_merge!(parent_index.field_types) if parent_index.respond_to?(:field_types)
+        @via_relationships.reverse_merge!(parent_index.via_relationships) if parent_index.respond_to?(:via_relationships)
+        @parent_indexers << parent_index
+      end
+
+      def to_s
+        "Indexer @#{object_id} [index_for:#{@indexer_for}, field_types=#{@field_types.keys.join(', ')}, via=#{@via_relationships.inspect}]"
+      end
+
+      # Add an index on a field so that it will be automatically updated by neo4j transactional events.
+      #
+      # The index method takes an optional configuration hash which allows you to:
+      #
+      # === Add an index on an a property
+      #
+      # Example:
+      #   class Person
+      #     include Neo4j::NodeMixin
+      #     index :name
+      #   end
+      #
+      # When the property name is changed/deleted or the node created it will keep the lucene index in sync.
+      # You can then perform a lucene query like this: Person.find('name: andreas')
+      #'
+      # === Add index on other nodes.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Neo4j::NodeMixin
+      #     has_n(:friends).to(Contact)
+      #     has_n(:known_by).from(:friends)
+      #     index :user_id, :via => :known_by
+      #   end
+      #
+      # Notice that you *must* specify an incoming relationship with the via key, as shown above.
+      # In the example above an index <tt>user_id</tt> will be added to all Person nodes which has a <tt>friends</tt> relationship
+      # that person with that user_id. This allows you to do lucene queries on your friends properties.
+      #
+      # === Set the type value to index
+      # By default all values will be indexed as Strings.
+      # If you want for example to do a numerical range query you must tell Neo4j.rb to index it as a numeric value.
+      # You do that with the key <tt>type</tt> on the property.
+      #
+      # Example:
+      #   class Person
+      #     include Neo4j::NodeMixin
+      #     property :weight, :type => Float
+      #     index :weight
+      #   end
+      #
+      # Supported values for <tt>:type</tt> is <tt>String</tt>, <tt>Float</tt>, <tt>Date</tt>, <tt>DateTime</tt> and <tt>Fixnum</tt>
+      #
+      # === For more information
+      # * See Neo4j::Index::LuceneQuery
+      # * See #find
+      #
+      def index(field, conf = {})
+        if conf[:via]
+          rel_dsl = @indexer_for._decl_rels[conf[:via]]
+          raise "No relationship defined for '#{conf[:via]}'. Check class '#{@indexer_for}': index :#{field}, via=>:#{conf[:via]} <-- error. Define it with a has_one or has_n" unless rel_dsl
+          raise "Only incoming relationship are possible to define index on. Check class '#{@indexer_for}': index :#{field}, via=>:#{conf[:via]}" unless rel_dsl.incoming?
+          via_indexer = rel_dsl.target_class._indexer
+
+          field = field.to_s
+          @via_relationships[field] = rel_dsl
+          conf.delete :via # avoid endless recursion
+          via_indexer.index(field, conf)
+        else
+#          raise "Already defined an (via?) index on #{field}, Using the same index for from two classes ? Check index :#{field}, :via => :#{@indexer_for}" if @field_types[field.to_s]
+          @field_types[field.to_s] = conf[:type] || :exact
+        end
+      end
+
+      def remove_index_on_fields(node, props, tx_data) #:nodoc:
+        @field_types.keys.each { |field| rm_index(node, field, props[field]) if props[field] }
+        # remove all via indexed fields
+        @via_relationships.each_value do |dsl|
+          indexer = dsl.target_class._indexer
+          tx_data.deleted_relationships.each do |rel|
+            start_node = rel._start_node
+            next if node != rel._end_node
+            indexer.remove_index_on_fields(start_node, props, tx_data)
+          end
+        end
+      end
+
+      def update_on_deleted_relationship(relationship) #:nodoc:
+        update_on_relationship(relationship, false)
+      end
+
+      def update_on_new_relationship(relationship) #:nodoc:
+        update_on_relationship(relationship, true)
+      end
+
+      def update_on_relationship(relationship, is_created) #:nodoc:
+        rel_type = relationship.rel_type
+        end_node = relationship._end_node
+        # find which via relationship match rel_type
+        @via_relationships.each_pair do |field, dsl|
+          # have we declared an index on this changed relationship ?
+          next unless dsl.rel_type == rel_type
+
+          # yes, so find the node and value we should update the index on
+          val        = end_node[field]
+          start_node = relationship._start_node
+
+          # find the indexer to use
+          indexer   = dsl.target_class._indexer
+
+          # is the relationship created or deleted ?
+          if is_created
+            indexer.update_index_on(start_node, field, nil, val)
+          else
+            indexer.update_index_on(start_node, field, val, nil)
+          end
+        end
+      end
+
+      def update_index_on(node, field, old_val, new_val) #:nodoc:
+        if @via_relationships.include?(field)
+          dsl = @via_relationships[field]
+          target_class = dsl.target_class
+
+          dsl._all_relationships(node).each do |rel|
+            other = rel._start_node
+            target_class._indexer.update_single_index_on(other, field, old_val, new_val)
+          end
+        end
+        update_single_index_on(node, field, old_val, new_val)
+      end
+
+      def update_single_index_on(node, field, old_val, new_val) #:nodoc:
+        if @field_types.include?(field)
+          rm_index(node, field, old_val) if old_val
+          add_index(node, field, new_val) if new_val
+        end
+      end
+
+      # Returns true if there is an index on the given field.
+      #
+      def index?(field)
+        @field_types.include?(field.to_s)
+      end
+
+      # Returns the type of index for the given field (e.g. :exact or :fulltext)
+      #
+      def index_type_for(field) #:nodoc:
+        return nil unless index?(field)
+        @field_types[field.to_s]
+      end
+
+      # Returns true if there is an index of the given type defined.
+      def index_type?(type)
+        @field_types.values.include?(type)
+      end
+
+      # Adds an index on the given entity
+      # This is normally not needed since you can instead declare an index which will automatically keep
+      # the lucene index in sync. See #index
+      #
+      def add_index(entity, field, value)
+       	return false unless @field_types.has_key?(field)
+
+        # we might need to know what type the properties are when indexing and querying
+        @decl_props ||= @indexer_for.respond_to?(:_decl_props) && @indexer_for._decl_props
+
+        type = @decl_props && @decl_props[field.to_sym] && @decl_props[field.to_sym][:type]
+        if type
+          value = if String != type
+                    org.neo4j.index.impl.lucene.ValueContext.new(value).indexNumeric
+                  else
+                    org.neo4j.index.impl.lucene.ValueContext.new(value)
+                  end
+        end
+
+        index_for_field(field.to_s).add(entity, field, value)
+      	@parent_indexers.each { |i| i.add_index(entity, field, value) }
+      end
+
+      # Removes an index on the given entity
+      # This is normally not needed since you can instead declare an index which will automatically keep
+      # the lucene index in sync. See #index
+      #
+      def rm_index(entity, field, value)
+        return false unless @field_types.has_key?(field)
+        index_for_field(field).remove(entity, field, value)
+        @parent_indexers.each { |i| i.rm_index(entity, field, value) }
+      end
+
+      # Performs a Lucene Query.
+      #
+      # In order to use this you have to declare an index on the fields first, see #index.
+      # Notice that you should close the lucene query after the query has been executed.
+      # You can do that either by provide an block or calling the Neo4j::Index::LuceneQuery#close
+      # method. When performing queries from Ruby on Rails you do not need this since it will be automatically closed
+      # (by Rack).
+      #
+      # === Example, with a block
+      #   
+      #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
+      #
+      # ==== Example
+      #
+      #   query = Person.find('name: kalle')
+      #   puts "First item #{query.first}"
+      #   query.close
+      #
+      # === Return Value
+      # It will return a Neo4j::Index::LuceneQuery object
+      #
+      #
+      def find(query, params = {})
+        # we might need to know what type the properties are when indexing and querying
+        @decl_props ||= @indexer_for.respond_to?(:_decl_props) && @indexer_for._decl_props
+
+        index = index_for_type(params[:type] || :exact)
+        query = (params[:wrapped].nil? || params[:wrapped]) ? LuceneQuery.new(index, @decl_props, query) : index.query(query)
+
+        if block_given?
+          begin
+            ret = yield query
+          ensure
+            query.close
+          end
+          ret
+        else
+          query
+        end
+      end
+
+      # delete the index, if no type is provided clear all types of indexes
+      def delete_index_type(type=nil)
+        if type
+          #raise "can't clear index of type '#{type}' since it does not exist ([#{@field_types.values.join(',')}] exists)" unless index_type?(type)
+          @indexes[type] && @indexes[type].delete
+          @indexes[type] = nil
+        else
+          @indexes.each_value { |index| index.delete }
+          @indexes.clear
+        end
+      end
+
+      def on_neo4j_shutdown #:nodoc:
+        # Since we might start the database again we must make sure that we don't keep any references to
+        # an old lucene index in memory.
+        @indexes.clear
+      end
+
+      # Removes the cached lucene index, can be useful for some RSpecs which needs to restart the Neo4j.
+      #
+      def rm_field_type(type=nil)
+        if type
+          @field_types.delete_if { |k, v| v == type }
+        else
+          @field_types.clear
+        end
+      end
+
+      def index_for_field(field) #:nodoc:
+        type = @field_types[field]
+        @indexes[type] ||= create_index_with(type)
+      end
+
+      def index_for_type(type) #:nodoc:
+        @indexes[type] ||= create_index_with(type)
+      end
+
+      def lucene_config(type) #:nodoc:
+        conf = Neo4j::Config[:lucene][type.to_sym]
+        raise "unknown lucene type #{type}" unless conf
+        conf
+      end
+
+      def create_index_with(type) #:nodoc:
+        db=Neo4j.started_db
+        index_config = lucene_config(type)
+        if @type == :node
+          db.lucene.for_nodes("#{@indexer_for}-#{type}", index_config)
+        else
+          db.lucene.for_relationships("#{@indexer_for}-#{type}", index_config)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/neo4j/index/indexer_registry.rb

@@ -0,0 +1,68 @@
+module Neo4j
+  module Index
+    class IndexerRegistry #:nodoc:
+      class << self
+
+        def delete_all_indexes
+          @@indexers.values.each {|i| i.delete_index_type}
+        end
+
+        def create_for(this_clazz, using_other_clazz, type)
+          @@indexers                  ||= {}
+          index                       = Indexer.new(this_clazz, type)
+          index.inherit_fields_from(@@indexers[using_other_clazz.to_s])
+          @@indexers[this_clazz.to_s] = index
+        end
+
+        def find_by_class(classname)
+          @@indexers[classname]
+        end
+
+        def on_node_deleted(node, old_props, tx_data)
+          indexer = find_by_class(old_props['_classname'] || node.class.to_s)
+          indexer && indexer.remove_index_on_fields(node, old_props, tx_data)
+        end
+
+        def on_property_changed(node, field, old_val, new_val)
+          classname = node['_classname'] || node.class.to_s
+          indexer = find_by_class(classname)
+          indexer && indexer.update_index_on(node, field, old_val, new_val)
+        end
+
+        def on_rel_property_changed(rel, field, old_val, new_val)
+          # works exactly like for nodes
+          on_property_changed(rel, field, old_val, new_val)
+        end
+
+        def on_relationship_created(rel, tx_data)
+          end_node = rel._end_node
+          # if end_node was created in this transaction then it will be handled in on_property_changed
+          created = tx_data.created_nodes.find{|n| n.neo_id == end_node.neo_id}
+          unless created
+            indexer = find_by_class(end_node['_classname'])
+            indexer && indexer.update_on_new_relationship(rel)
+          end
+        end
+
+        def on_relationship_deleted(rel, old_props, tx_data)
+          on_node_deleted(rel, old_props, tx_data)
+          # if only the relationship has been deleted then we have to remove the index
+          # if both the relationship and the node has been deleted then the index will be removed in the
+          # on_node_deleted callback
+          end_node = rel._end_node
+          deleted = tx_data.deleted_nodes.find{|n| n.neo_id == end_node.neo_id}
+          unless deleted
+            indexer = find_by_class(end_node['_classname'])
+            indexer && indexer.update_on_deleted_relationship(rel)
+          end
+        end
+
+        def on_neo4j_shutdown(*)
+          @@indexers.each_value {|indexer| indexer.on_neo4j_shutdown}
+        end
+      end
+    end
+    Neo4j.unstarted_db.event_handler.add(IndexerRegistry)
+
+  end
+end

data/lib/neo4j/index/lucene_query.rb

@@ -0,0 +1,191 @@
+module Neo4j
+  module Index
+    # == LuceneQuery
+    #
+    # This object is returned when you call the #find method on the Node, Relationship.
+    # The actual query is not executed until the first item is requested.
+    #
+    # You can perform a query in many different ways:
+    #
+    # ==== By Hash
+    #
+    # Example:
+    #  Person.find(:name => 'foo', :age => 3)
+    #
+    # ==== By Range
+    #
+    # Example:
+    #  Person.find(:age).between(15,35)
+    #
+    # ==== By Lucene Query Syntax
+    #
+    # Example
+    #  Car.find('wheels:"4" AND colour: "blue")
+    #
+    # For more information about the syntax see http://lucene.apache.org/java/3_0_2/queryparsersyntax.html
+    #
+    # ==== By Compound Queries
+    #
+    # You can combine several queries by <tt>AND</tt>ing those together.
+    #
+    # Example:
+    #   Vehicle.find(:weight).between(5.0, 100000.0).and(:name).between('a', 'd')
+    #
+    # === See Also
+    # * Neo4j::Index::Indexer#index
+    # * Neo4j::Index::Indexer#find - which returns an LuceneQuery
+    #
+    class LuceneQuery
+      include Enumerable
+      attr_accessor :left_and_query, :left_or_query
+      
+      def initialize(index, decl_props, query)
+        @index = index
+        @query = query
+        @decl_props = decl_props
+      end
+
+      # Since we include the Ruby Enumerable mixin we need this method.
+      def each
+        hits.each { |n| yield n.wrapper }
+      end
+
+      # Close hits
+      #
+      # Closes the underlying search result. This method should be called whenever you've got what you wanted from the result and won't use it anymore.
+      # It's necessary to call it so that underlying indexes can dispose of allocated resources for this search result.
+      # You can however skip to call this method if you loop through the whole result, then close() will be called automatically.
+      # Even if you loop through the entire result and then call this method it will silently ignore any consequtive call (for convenience).
+      #
+      # This must be done according to the Neo4j Java Documentation:
+      def close
+        @hits.close if @hits
+      end
+
+      # True if there is no search hits.
+      def empty?
+        hits.size == 0
+      end
+
+      # returns the n'th search item
+      # Does simply loop all search items till the n'th is found.
+      #
+      def [](index)
+        each_with_index {|node,i| break node if index == i}
+      end
+
+      # Returns the number of search hits
+      def size
+        hits.size
+      end
+
+      def hits #:nodoc:
+        @hits ||= perform_query
+      end
+
+      # Performs a range query
+      # Notice that if you don't specify a type when declaring a property a String range query will be performed.
+      # 
+      def between(lower, upper, lower_incusive=false, upper_inclusive=false)
+        raise "Expected a symbol. Syntax for range queries example: index(:weight).between(a,b)" unless Symbol === @query
+        raise "Can't only do range queries on Neo4j::NodeMixin, Neo4j::Model, Neo4j::RelationshipMixin" unless @decl_props
+        # check that we perform a range query on the same values as we have declared with the property :key, :type => ...
+        type   = @decl_props[@query] && @decl_props[@query][:type]
+        raise "find(#{@query}).between(#{lower}, #{upper}): #{lower} not a #{type}" if type && !type === lower.class
+        raise "find(#{@query}).between(#{lower}, #{upper}): #{upper} not a #{type}" if type && !type === upper.class
+
+        # Make it possible to convert those values
+        lower  = TypeConverters.convert(lower)
+        upper  = TypeConverters.convert(upper)
+
+        @query = case lower
+                   when Fixnum
+                     org.apache.lucene.search.NumericRangeQuery.new_long_range(@query.to_s, lower, upper, lower_incusive, upper_inclusive)
+                   when Float
+                     org.apache.lucene.search.NumericRangeQuery.new_double_range(@query.to_s, lower, upper, lower_incusive, upper_inclusive)
+                   else
+                     org.apache.lucene.search.TermRangeQuery.new(@query.to_s, lower, upper, lower_incusive, upper_inclusive)
+                 end
+        self
+      end
+
+      # Create a compound lucene query.
+      #
+      # ==== Parameters
+      # query2 :: the query that should be AND together
+      #
+      # ==== Example
+      #
+      #  Person.find(:name=>'kalle').and(:age => 3)
+      #
+      def and(query2)
+        new_query = LuceneQuery.new(@index, @decl_props, query2)
+        new_query.left_and_query = self
+        new_query
+      end
+
+
+      # Sort descending the given fields.
+      def desc(*fields)
+        @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
+        self
+      end
+
+      # Sort ascending the given fields.
+      def asc(*fields)
+        @order = fields.inject(@order || {}) { |memo, field| memo[field] = false; memo }
+        self
+      end
+
+      def build_and_query(query) #:nodoc:
+        left_query = @left_and_query.build_query
+        and_query  = org.apache.lucene.search.BooleanQuery.new
+        and_query.add(left_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
+        and_query.add(query, org.apache.lucene.search.BooleanClause::Occur::MUST)
+        and_query
+      end
+
+      def build_sort_query(query)  #:nodoc:
+        java_sort_fields = @order.keys.inject([]) do |memo, field|
+          decl_type = @decl_props && @decl_props[field] && @decl_props[field][:type]
+          type      = case
+                        when Float == decl_type
+                          org.apache.lucene.search.SortField::DOUBLE
+                        when Fixnum == decl_type
+                          org.apache.lucene.search.SortField::LONG
+                        else
+                          org.apache.lucene.search.SortField::STRING
+                      end
+          memo << org.apache.lucene.search.SortField.new(field.to_s, type, @order[field])
+        end
+        sort             = org.apache.lucene.search.Sort.new(*java_sort_fields)
+        org.neo4j.index.impl.lucene.QueryContext.new(query).sort(sort)
+      end
+
+      def build_hash_query(query)  #:nodoc:
+        and_query  = org.apache.lucene.search.BooleanQuery.new
+
+        query.each_pair do |key, value|
+          raise "Only String values valid in find(hash) got :#{key} => #{value} which is not a String" if !value.is_a?(String) && @decl_props[key] && @decl_props[key][:type] != String
+          term = org.apache.lucene.index.Term.new(key.to_s, value.to_s)
+          term_query = org.apache.lucene.search.TermQuery.new(term)
+          and_query.add(term_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
+        end
+        and_query
+      end
+      
+      def build_query  #:nodoc:
+        query = @query
+        query = build_hash_query(query) if Hash === query
+        query = build_and_query(query) if @left_and_query
+        query = build_sort_query(query) if @order
+        query
+      end
+
+      def perform_query  #:nodoc:
+        @index.query(build_query)
+      end
+    end
+  end
+end
+