neo4j-core 0.0.15-java → 2.0.0.alpha.1-java

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

@@ -5,25 +5,14 @@ module Neo4j
       # Responsible for holding the configuration for one index
       # Is used in a DSL to configure the index.
       class IndexConfig
-        attr_reader :_trigger_on, :_index_names, :entity_type, :_index_type, :_field_types
+        attr_reader :_trigger_on, :_index_names, :entity_type
 
-        # @param [:rel, :node] entity_type the type of index
         def initialize(entity_type)
           @entity_type = entity_type
-          @_index_type = {}
-          @_field_types = {}
+          @index_type = {}
+          @numeric_types = []
           @_trigger_on = {}
-        end
-
-        def to_s
-          "IndexConfig [#@entity_type, _index_type: #{@_index_type.inspect}, _field_types: #{@_field_types.inspect}, _trigger_on: #{@_trigger_on.inspect}]"
-        end
-
-        def inherit_from(clazz)
-          c = clazz._indexer.config
-          raise "Can't inherit from different index type #{@entity_type} != #{c.entity_type}" if @entity_type != c.entity_type
-          @_index_type.merge!(c._index_type)
-          @_field_types.merge!(c._field_types)
+          @decl_type = {}
         end
 
         # Specifies which property and values the index should be triggered on.
@@ -33,8 +22,11 @@ module Neo4j
           merge_and_to_string(@_trigger_on, hash)
         end
 
-        def field_type(key)
-          @_field_types[key.to_s]
+        # Specifies the types of the properties being indexed so that the proper sort order can be applied.
+        # Used in the Index DSL.
+        # @see Neo4j::Core::Index::ClassMethods#node_indexer
+        def decl_type(prop_and_type_hash)
+          merge_and_to_string(@decl_type, prop_and_type_hash)
         end
 
         # Specifies an index with configuration
@@ -45,15 +37,15 @@ module Neo4j
           conf = args.last.kind_of?(Hash) ? args.pop : {}
 
           args.uniq.each do |field|
-            @_index_type[field.to_s] = conf[:type] || :exact
-            @_field_types[field.to_s] = conf[:field_type] || String
+            @index_type[field.to_s] = conf[:type] || :exact
+            @numeric_types << field.to_s if conf[:numeric] == true
           end
         end
 
-        # @return [Class,nil] the specified type of the property or nil
+        # @return [Class] the specified type of the property or String
         # @see #decl_type
         def decl_type_on(prop)
-          @_field_types[prop]
+          @decl_type[prop] || String
         end
 
         # @return [true, false] if the props can/should trigger an index operation
@@ -79,30 +71,31 @@ module Neo4j
           @_index_names = hash
         end
 
+
         def rm_index_config
-          @_index_type = {}
-          @_field_types = {}
+          @index_type = {}
+          @numeric_types = []
         end
 
         def index_type(field)
-          @_index_type[field.to_s]
+          @index_type[field.to_s]
         end
 
         def has_index_type?(type)
-          @_index_type.values.include?(type)
+          @index_type.values.include?(type)
         end
 
         def fields
-          @_index_type.keys
+          @index_type.keys
         end
 
         def index?(field)
-          @_index_type.include?(field.to_s)
+          @index_type.include?(field.to_s)
         end
 
         def numeric?(field)
-          raise "No index on #{field.inspect}, has fields: #{@field_types.inspect}" unless @_field_types[field]
-          @_field_types[field] != String
+          return true if @numeric_types.include?(field)
+          # TODO callback to numeric dsl for Neo4j::NodeMixin decl_props check
         end
 
         private
@@ -110,7 +103,7 @@ module Neo4j
         def merge_and_to_string(existing_hash, new_hash)
           new_hash.each_pair do |k, v|
             existing_hash[k.to_s] ||= Set.new
-            existing_hash[k.to_s].merge(v.is_a?(Array) ? v : [v])
+            existing_hash[k.to_s].merge(v.is_a?(Array)? v : [v])
           end
         end
       end

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

@@ -17,21 +17,55 @@ module Neo4j
 
 
         def to_s
-          "Indexer @#{object_id} index on: [#{@config.fields.map { |f| @config.numeric?(f) ? "#{f} (numeric)" : f }.join(', ')}]"
+          "Indexer @#{object_id} index on: [#{@config.fields.map{|f| @config.numeric?(f)? "#{f} (numeric)" : f}.join(', ')}]"
         end
 
         # Add an index on a field so that it will be automatically updated by neo4j transactional events.
-        # Notice that if you want to numerical range queries then you should specify a field_type of either Fixnum or Float.
-        # The index type will by default be <tt>:exact</tt>.
-        # Index on property arrays are supported.
         #
-        # @example
-        #    MyIndex.index(:age, :field_type => Fixnum) # default :exact
-        #    MyIndex.index(:wheels, :field_type => Fixnum)
-        #    MyIndex.index(:description, :type => :fulltext)
+        # The index method takes an optional configuration hash which allows you to:
+        #
+        # @example Add an index on an a property
+        #
+        #   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')
+        #
+        # @example Add index on other nodes.
+        #
+        #   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.
+        #
+        # @example Set the type value to index
+        #
+        #   class Person
+        #     include Neo4j::NodeMixin
+        #     property :height, :weight, :type => Float
+        #     index :height, :weight
+        #   end
+        #
+        # 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.
+        #
+        # 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::Core::Index::LuceneQuery
         # @see #find
+        #
         def index(*args)
           @config.index(args)
         end
@@ -62,18 +96,11 @@ module Neo4j
         # @see #index
         def add_index(entity, field, value)
           return false unless index?(field)
-          if (java_array?(value))
-            conv_value = value.map{|x| indexed_value_for(field, x)}.to_java(Java::OrgNeo4jIndexLucene::ValueContext)
-          else
-            conv_value = indexed_value_for(field, value)
-          end
+          conv_value = indexed_value_for(field, value)
           index = index_for_field(field.to_s)
           index.add(entity, field, conv_value)
         end
 
-        def java_array?(value)
-          value.respond_to?(:java_class) && value.java_class.to_s[0..0] == '['
-        end
 
         # Removes an index on the given entity
         # This is normally not needed since you can instead declare an index which will automatically keep
@@ -81,7 +108,6 @@ module Neo4j
         # @see #index
         def rm_index(entity, field, value)
           return false unless index?(field)
-          #return value.each {|x| rm_index(entity, field, x)} if value.respond_to?(:each)
           index_for_field(field).remove(entity, field, value)
         end
 
@@ -94,44 +120,23 @@ module Neo4j
         # (by Rack).
         #
         # @example with a block
-        #   Person.find('name: kalle') {|query| puts "First item #{query.first}"}
         #
-        # @example using an exact lucene index
-        #   query = Person.find('name: kalle')
-        #   puts "First item #{query.first}"
-        #   query.close
+        #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
         #
-        # @example using an fulltext lucene index
-        #   query = Person.find('name: kalle', :type => :fulltext)
+        # @example
+        #
+        #   query = Person.find('name: kalle')
         #   puts "First item #{query.first}"
         #   query.close
         #
-        # @example Sorting, descending by one property
-        #    Person.find({:name => 'kalle'}, :sort => {:name => :desc})
-        #
-        # @example Sorting using the builder pattern
-        #    Person.find(:name => 'kalle').asc(:name)
-        #
-        # @example Searching by a set of values, OR search
-        #    Person.find(:name => ['kalle', 'sune', 'jimmy'])
-        #
-        # @example Compound queries and Range queries
-        #    Person.find('name: pelle').and(:age).between(2, 5)
-        #    Person.find(:name => 'kalle', :age => (2..5))
-        #    Person.find("name: 'asd'").and(:wheels => 8)
-        #
-        # @example Using the lucene java object
-        #   # using the Neo4j query method directly
-        #   # see, http://api.neo4j.org/1.6.1/org/neo4j/graphdb/index/ReadableIndex.html#query(java.lang.Object)
-        #   MyIndex.find('description: "hej"', :type => :fulltext, :wrapped => false).get_single
-        #
-        # @param [String, Hash] query the lucene query
-        # @param [Hash] params lucene configuration parameters
-        # @return [Neo4j::Core::Index::LuceneQuery] a query object which uses the builder pattern for creating compound and sort queries.
-        # @note You must specify the index type <tt>:fulltext<tt>) if the property is index using that index (default is <tt>:exact</tt>)
+        # @return [Neo4j::Core::Index::LuceneQuery] a query object
         def find(query, params = {})
           index = index_for_type(params[:type] || :exact)
-          query.delete(:sort) if query.is_a?(Hash) && query.include?(:sort)
+          if query.is_a?(Hash) && (query.include?(:conditions) || query.include?(:sort))
+            params.merge! query.reject { |k, _| k == :conditions }
+            query.delete(:sort)
+            query = query.delete(:conditions) if query.include?(:conditions)
+          end
           query = (params[:wrapped].nil? || params[:wrapped]) ? LuceneQuery.new(index, @config, query, params) : index.query(query)
 
           if block_given?
@@ -146,23 +151,6 @@ module Neo4j
           end
         end
 
-        # Add the entity to this index for the given key/value pair if this particular key/value pair doesn't already exist.
-        # This ensures that only one entity will be associated with the key/value pair even if multiple transactions are trying to add it at the same time.
-        # One of those transactions will win and add it while the others will block, waiting for the winning transaction to finish.
-        # If the winning transaction was successful these other transactions will return the associated entity instead of adding it.
-        # If it wasn't successful the waiting transactions will begin a new race to add it.
-        #
-        # @param [Neo4j::Node, Neo4j::Relationship] entity the entity (i.e Node or Relationship) to associate the key/value pair with.
-        # @param [String, Symbol] key the key in the key/value pair to associate with the entity.
-        # @param [String, Fixnum, Float] value the value in the key/value pair to associate with the entity.
-        # @param [Symbol] index_type the type of lucene index
-        # @return [nil, Neo4j:Node, Neo4j::Relationship] the previously indexed entity, or nil if no entity was indexed before (and the specified entity was added to the index).
-        # @see Neo4j::Core::Index::UniqueFactory as an alternative which probably simplify creating unique entities
-        def put_if_absent(entity, key, value, index_type = :exact)
-          index = index_for_type(index_type)
-          index.put_if_absent(entity, key.to_s, value)
-        end
-
         # Delete all index configuration. No more automatic indexing will be performed
         def rm_index_config
           @config.rm_index_config

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

@@ -7,7 +7,7 @@ module Neo4j
         end
 
         def delete_all_indexes
-          @indexers.each { |i| i.rm_index_type }
+          @indexers.values.each { |i| i.rm_index_type }
         end
 
         def register(indexer)
@@ -16,7 +16,7 @@ module Neo4j
         end
 
         def indexers_for(props)
-          Enumerator.new(self, :each_indexer, props)
+          Enumerable::Enumerator.new(self, :each_indexer, props)
         end
 
         def each_indexer(props)

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

@@ -39,7 +39,11 @@ module Neo4j
           @query = query
           @index_config = index_config
           @params = params
-          @order = params[:sort] if params.include?(:sort)
+
+          if params.include?(:sort)
+            @order = {}
+            params[:sort].each_pair { |k, v| @order[k] = (v == :desc) }
+          end
         end
 
         # Implements the Ruby +Enumerable+ interface
@@ -81,26 +85,30 @@ module Neo4j
         # 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_inclusive=false, upper_inclusive=false)
+        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
-          @query = range_query(@query, lower, upper, lower_inclusive, upper_inclusive)
+#          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 = @index_config.decl_type_on(@query)
+          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
+          @query = range_query(@query, lower, upper, lower_incusive, upper_inclusive)
           self
         end
 
-        def range_query(field, lower, upper, lower_inclusive, upper_inclusive)
-          type = @index_config.field_type(field)
-          raise "no index on field #{field}" unless type
-          # check that we perform a range query on the same values as we have declared with the property :key, :type => ...
-          raise "find(#{field}).between(#{lower}, #{upper}): #{lower} not a #{type}" unless type == lower.class
-          raise "find(#{field}).between(#{lower}, #{upper}): #{upper} not a #{type}" unless type == upper.class
+        def range_query(field, lower, upper, lower_incusive, upper_inclusive)
+          lower = TypeConverters.convert(lower)
+          upper = TypeConverters.convert(upper)
 
           case lower
             when Fixnum
-              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
             when Float
-              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
             else
-              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_incusive, upper_inclusive)
           end
         end
 
@@ -148,28 +156,19 @@ module Neo4j
         # Sort descending the given fields.
         # @param [Symbol] fields it should sort
         def desc(*fields)
-          @order ||= []
-          @order += fields.map { |f| [f, :desc] }
+          @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
           self
         end
 
         # Sort ascending the given fields.
         # @param [Symbol] fields it should sort
         def asc(*fields)
-          @order ||= []
-          @order += fields.map { |f| [f, :asc] }
+          @order = fields.inject(@order || {}) { |memo, field| memo[field] = false; memo }
           self
         end
 
         protected
 
-        def parse_query(query)
-          version = Java::OrgApacheLuceneUtil::Version::LUCENE_30
-          analyzer = Java::OrgApacheLuceneAnalysisStandard::StandardAnalyzer.new(version)
-          parser = Java::org.apache.lucene.queryParser.QueryParser.new(version, 'name', analyzer)
-          parser.parse(query)
-        end
-
         def build_and_query(query)
           build_composite_query(@left_and_query.build_query, query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
         end
@@ -180,9 +179,6 @@ module Neo4j
 
         def build_not_query(query)
           right_query = @right_not_query.build_query
-          query = parse_query(query) if query.is_a?(String)
-          right_query = parse_query(right_query) if right_query.is_a?(String)
-
           composite_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
           composite_query.add(query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST_NOT)
           composite_query.add(right_query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
@@ -190,27 +186,31 @@ module Neo4j
         end
 
         def build_composite_query(left_query, right_query, operator) #:nodoc:
-          left_query = parse_query(left_query) if left_query.is_a?(String)
-          right_query = parse_query(right_query) if right_query.is_a?(String)
           composite_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
+          version = Java::OrgApacheLuceneUtil::Version::LUCENE_35
+          analyzer = org.apache.lucene.analysis.standard::StandardAnalyzer.new(version)
+          parser = Java::org.apache.lucene.queryParser.QueryParser.new(version,'name', analyzer )
+
+          left_query = parser.parse(left_query) if left_query.is_a?(String)
+          right_query = parser.parse(right_query) if right_query.is_a?(String)
+
           composite_query.add(left_query, operator)
           composite_query.add(right_query, operator)
           composite_query
         end
 
         def build_sort_query(query) #:nodoc:
-          java_sort_fields = @order.inject([]) do |memo, val|
-            field = val[0]
-            field_type = @index_config.field_type(field)
+          java_sort_fields = @order.keys.inject([]) do |memo, field|
+            decl_type = @index_config.decl_type_on(field)
             type = case
-                     when Float == field_type
+                     when Float == decl_type
                        Java::OrgApacheLuceneSearch::SortField::DOUBLE
-                     when Fixnum == field_type
+                     when Fixnum == decl_type || DateTime == decl_type || Date == decl_type || Time == decl_type
                        Java::OrgApacheLuceneSearch::SortField::LONG
                      else
                        Java::OrgApacheLuceneSearch::SortField::STRING
                    end
-            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, val[1] == :desc)
+            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, @order[field])
           end
           sort = Java::OrgApacheLuceneSearch::Sort.new(*java_sort_fields)
           Java::OrgNeo4jIndexLucene::QueryContext.new(query).sort(sort)
@@ -220,29 +220,18 @@ module Neo4j
           and_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
 
           query.each_pair do |key, value|
-            type = @index_config.field_type(key)
-            if type != String
+            type = @index_config && @index_config[key.to_sym] && @index_config[key.to_sym][:type]
+            if !type.nil? && type != String
               if Range === value
-                and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
-              elsif Array === value
-                value.each do |v|
-                  and_query.add(range_query(key, v, v, true, true), Java::OrgApacheLuceneSearch::BooleanClause::Occur::SHOULD)
-                end
+                and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
               else
-                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
+                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
               end
             else
-              if Array === value
-                value.each do |v|
-                  term = Java::OrgApacheLuceneIndex::Term.new(key.to_s, v.to_s)
-                  term_query = Java::OrgApacheLuceneSearch::TermQuery.new(term)
-                  and_query.add(term_query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::SHOULD)
-                end
-              else
-                term = Java::OrgApacheLuceneIndex::Term.new(key.to_s, value.to_s)
-                term_query = Java::OrgApacheLuceneSearch::TermQuery.new(term)
-                and_query.add(term_query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
-              end
+              conv_value = type ? TypeConverters.convert(value) : value.to_s
+              term = Java::OrgApacheLuceneIndex::Term.new(key.to_s, conv_value)
+              term_query = Java::OrgApacheLuceneIndex::TermQuery.new(term)
+              and_query.add(term_query, Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
             end
           end
           and_query