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

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

@@ -17,55 +17,21 @@ 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.
         #
-        # 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
+        # @example
+        #    MyIndex.index(:age, :field_type => Fixnum) # default :exact
+        #    MyIndex.index(:wheels, :field_type => Fixnum)
+        #    MyIndex.index(:description, :type => :fulltext)
         #
         # @see Neo4j::Core::Index::LuceneQuery
         # @see #find
-        #
         def index(*args)
           @config.index(args)
         end
@@ -96,11 +62,18 @@ module Neo4j
         # @see #index
         def add_index(entity, field, value)
           return false unless index?(field)
-          conv_value = indexed_value_for(field, value)
+          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
           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
@@ -108,6 +81,7 @@ 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
 
@@ -120,23 +94,44 @@ module Neo4j
         # (by Rack).
         #
         # @example with a block
+        #   Person.find('name: kalle') {|query| puts "First item #{query.first}"}
         #
-        #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
-        #
-        # @example
-        #
+        # @example using an exact lucene index
         #   query = Person.find('name: kalle')
         #   puts "First item #{query.first}"
         #   query.close
         #
-        # @return [Neo4j::Core::Index::LuceneQuery] a query object
+        # @example using an fulltext lucene index
+        #   query = Person.find('name: kalle', :type => :fulltext)
+        #   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>)
         def find(query, params = {})
           index = index_for_type(params[:type] || :exact)
-          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.delete(:sort) if query.is_a?(Hash) && query.include?(:sort)
           query = (params[:wrapped].nil? || params[:wrapped]) ? LuceneQuery.new(index, @config, query, params) : index.query(query)
 
           if block_given?
@@ -151,6 +146,23 @@ 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.values.each { |i| i.rm_index_type }
+          @indexers.each { |i| i.rm_index_type }
         end
 
         def register(indexer)
@@ -16,7 +16,7 @@ module Neo4j
         end
 
         def indexers_for(props)
-          Enumerable::Enumerator.new(self, :each_indexer, props)
+          Enumerator.new(self, :each_indexer, props)
         end
 
         def each_indexer(props)

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

@@ -39,11 +39,7 @@ module Neo4j
           @query = query
           @index_config = index_config
           @params = params
-
-          if params.include?(:sort)
-            @order = {}
-            params[:sort].each_pair { |k, v| @order[k] = (v == :desc) }
-          end
+          @order = params[:sort] if params.include?(:sort)
         end
 
         # Implements the Ruby +Enumerable+ interface
@@ -85,30 +81,26 @@ 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_incusive=false, upper_inclusive=false)
+        def between(lower, upper, lower_inclusive=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 = @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)
+          @query = range_query(@query, lower, upper, lower_inclusive, upper_inclusive)
           self
         end
 
-        def range_query(field, lower, upper, lower_incusive, upper_inclusive)
-          lower = TypeConverters.convert(lower)
-          upper = TypeConverters.convert(upper)
+        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
 
           case lower
             when Fixnum
-              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
             when Float
-              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
             else
-              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
           end
         end
 
@@ -156,19 +148,28 @@ module Neo4j
         # Sort descending the given fields.
         # @param [Symbol] fields it should sort
         def desc(*fields)
-          @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
+          @order ||= []
+          @order += fields.map { |f| [f, :desc] }
           self
         end
 
         # Sort ascending the given fields.
         # @param [Symbol] fields it should sort
         def asc(*fields)
-          @order = fields.inject(@order || {}) { |memo, field| memo[field] = false; memo }
+          @order ||= []
+          @order += fields.map { |f| [f, :asc] }
           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
@@ -179,6 +180,9 @@ 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)
@@ -186,31 +190,27 @@ 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.keys.inject([]) do |memo, field|
-            decl_type = @index_config.decl_type_on(field)
+          java_sort_fields = @order.inject([]) do |memo, val|
+            field = val[0]
+            field_type = @index_config.field_type(field)
             type = case
-                     when Float == decl_type
+                     when Float == field_type
                        Java::OrgApacheLuceneSearch::SortField::DOUBLE
-                     when Fixnum == decl_type || DateTime == decl_type || Date == decl_type || Time == decl_type
+                     when Fixnum == field_type
                        Java::OrgApacheLuceneSearch::SortField::LONG
                      else
                        Java::OrgApacheLuceneSearch::SortField::STRING
                    end
-            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, @order[field])
+            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, val[1] == :desc)
           end
           sort = Java::OrgApacheLuceneSearch::Sort.new(*java_sort_fields)
           Java::OrgNeo4jIndexLucene::QueryContext.new(query).sort(sort)
@@ -220,18 +220,29 @@ module Neo4j
           and_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
 
           query.each_pair do |key, value|
-            type = @index_config && @index_config[key.to_sym] && @index_config[key.to_sym][:type]
-            if !type.nil? && type != String
+            type = @index_config.field_type(key)
+            if type != String
               if Range === value
-                and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
+                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
               else
-                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
+                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
               end
             else
-              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)
+              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
             end
           end
           and_query

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

@@ -0,0 +1,54 @@
+module Neo4j
+  module Core
+
+    module Index
+
+      # A Utility class that can be used to make it easier to create unique entities. It uses {Neo4j::Core::Index::Indexer#put_if_absent}.
+      #
+      # @see Indexer#put_if_absent
+      #
+      # @example
+      #   index = index_for_type(:exact)
+      #   Neo4j::Core::Index::UniqueFactory.new(:email, index) { |k,v| Neo4j::Node.new(k => v) }.get_or_create(:email, 'foo@gmail.com')
+      #
+      class UniqueFactory
+        # @param [Symbol] key only one key is possible
+        # @param [Java::Neo4j] index the lucene index (see #index_for_type)
+        # @yield a proc for initialize each created entity
+        def initialize(key, index, &entity_creator_block)
+          @key = key
+          @index = index
+          @entity_creator_block = entity_creator_block || Proc.new{|k,v| Neo4j::Node.new(key.to_s => v)}
+        end
+
+        # Get the indexed entity, creating it (exactly once) if no indexed entity exists.
+        # There must be an index on the key
+        # @param [Symbol] key the key to find the entity under in the index.
+        # @param [String, Fixnum, Float] value  the value the key is mapped to for the entity in the index.
+        # @param [Hash] props optional properties that the entity will have if created
+        # @yield optional, make it possible to initialize the created node in a block
+        def get_or_create(key, value, props=nil, &init_block)
+          tx = Neo4j::Transaction.new
+          result = @index.get(key.to_s, value).get_single
+          return result if result
+
+          created = @entity_creator_block.call(key,value)
+          result = @index.put_if_absent(created._java_entity, key.to_s, value)
+          if result.nil?
+            props.each_pair{|k,v| created[k.to_s] = v} if props
+            init_block.call(result) if init_block
+            result = created
+          else
+            created.del
+          end
+          tx.success
+          result
+        ensure
+          tx.finish
+        end
+
+      end
+    end
+
+  end
+end

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

@@ -61,11 +61,11 @@ module Neo4j
         end
 
         # Loads a node or wrapped node given a native java node or an id.
-        # If there is a Ruby wrapper for the node then it will create a Ruby object that will
-        # wrap the java node (see Neo4j::NodeMixin).
-        # To implement a wrapper you must implement a wrapper class method in the Neo4j::Node or Neo4j::Relationship.
+        # If there is a Ruby wrapper for the node then it will create and return a Ruby object that will
+        # wrap the java node.
         #
-        # @return [Object, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.
+        # @param [nil, #to_i] node_id the neo4j node id
+        # @return [Object, Neo4j::Node, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.
         def load(node_id, db = Neo4j.started_db)
           node = _load(node_id, db)
           node && node.wrapper

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

@@ -31,14 +31,7 @@ module Neo4j
         Neo4j::Node.exist?(self)
       end
 
-      # Tries to load the wrapper object for this node by calling the class #wrapper method.
-      # This allows you to create a custom Ruby wrapper class around the Neo4j::Node.
-      # This is for example done in the <tt>neo4j<//t> ruby gem <tt>Neo4j::NodeMixin</tt>
-      # @return a wrapper object or self
-      def wrapper
-        self.class.respond_to?(:wrapper) ? self.class.wrapper(node) : self
-      end
-
+      # Overrides the class so that the java object feels like a Ruby object.
       def class
         Neo4j::Node
       end

data/lib/neo4j-core/property/java.rb

@@ -0,0 +1,59 @@
+module Neo4j
+  module Core
+    module Property
+      # This module is only used for documentation purpose
+      # It simplify declares the java methods which are available Java org.neo4j.graphdb.PropertyContainer
+      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/PropertyContainer.html
+      module Java
+
+
+        # Get the GraphDatabaseService that this Node or Relationship belongs to.
+        # @return [Java::Neo4jGraphdbGraphDatabaseService]
+        def graph_database
+        end
+
+        # Returns the property value associated with the given key, or a default value.
+        # The value is of one of the valid property types, i.e. a Java primitive, a String or an array of any of the valid types.
+        # If there's no property associated with key an unchecked exception is raised.
+        # The idiomatic way to avoid an exception for an unknown key and instead get null back is to use a default value: Object valueOrNull = nodeOrRel.getProperty( key, null )
+        # @param [String] key the property key
+        # @param [String] default_value the default value that will be returned if no property value was associated with the given key
+        # @return [String,Fixnum,Boolean,Float,Array] ]the property value associated with the given key.
+        # @raise an exception if not given a default value and there is no property for the given key
+        # @see Neo4j::Core:Property#[]
+        def get_property(key, default_value = nil)
+        end
+
+        # @return all existing property keys, or an empty iterable if this property container has no properties.
+        def property_keys
+        end
+
+
+        # Removes the property associated with the given key and returns the old value.
+        # @param [String] key the name of the property
+        # @return [String,Fixnum,Boolean,Float,Array, nil] The old value or <tt>nil</tt> if there's no property associated with the key.
+        def remove_property(key)
+        end
+
+        # Sets the property value for the given key to value.
+        # The property value must be one of the valid property types, i.e:
+        # * boolean or boolean[]
+        # * byte or byte[]
+        # * short or short[]
+        # * int or int[]
+        # * long or long[]
+        # * float or float[]
+        # * double or double[]
+        # * char or char[]
+        # * java.lang.String or String[]
+        # Notice that JRuby does map Ruby primitive object (e.g. Fixnum) to java primitives automatically.
+        # Also, nil is not an accepted property value.
+        # @param [String] key the property key
+        # @param [String,Fixnum,Boolean,Float,Array] value
+        # @see Neo4j::Core::Property#[]=
+        def set_property(key, value)
+        end
+      end
+    end
+  end
+end