neo4j-core 0.0.13-java → 0.0.14-java

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

@@ -93,6 +93,8 @@ module Neo4j
         delegate :rm_index
         delegate :index_type
         delegate :index_name_for_type
+        delegate :index_for_type
+        delegate :put_if_absent
       end
 
 

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

@@ -2,7 +2,7 @@ module Neo4j
   module Core
 
     # A mixin which adds indexing behaviour to your own Ruby class
-    # You are expected to implement the method `java_entity` returning the underlying Neo4j Node or Relationship.
+    # You are expected to implement the method `_java_entity` returning the underlying Neo4j Node or Relationship.
     module Index
 
       # Adds an index on the given property
@@ -16,7 +16,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#add_index
       #
       def add_index(field, value=self[field])
-        self.class.add_index(java_entity, field.to_s, value)
+        self.class.add_index(_java_entity, field.to_s, value)
       end
 
       # Removes an index on the given property.
@@ -26,7 +26,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#rm_index
       #
       def rm_index(field, value=self[field])
-        self.class.rm_index(java_entity, field.to_s, value)
+        self.class.rm_index(_java_entity, field.to_s, value)
       end
 
     end

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

@@ -112,6 +112,9 @@ module Neo4j
         # @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))
@@ -143,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/lucene_query.rb

@@ -224,13 +224,25 @@ module Neo4j
             if 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
               else
                 and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
               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)
+              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/relationship/relationship.rb

@@ -60,7 +60,7 @@ module Neo4j
 
       # same as #_java_rel
       # Used so that we have same method for both relationship and nodes
-      def java_entity
+      def _java_entity
         self
       end
 

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

@@ -2,6 +2,8 @@ module Neo4j
   module Core
     # Contains methods for traversing relationship object of depth one from one node.
     module Rels
+
+
       # Returns the only node of a given type and direction that is attached to this node, or nil.
       # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or one relationships of a given type and direction to another node.
       # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships exist, it is a fatal error that should generate an exception.
@@ -124,6 +126,7 @@ module Neo4j
         end
       end
 
+
       # Check if the given relationship exists
       # Returns true if there are one or more relationships from this node to other nodes
       # with the given relationship.

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "0.0.13"
+    VERSION = "0.0.14"
   end
 end

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

@@ -12,7 +12,7 @@ module Neo4j
       # This can be implemented by a wrapper to returned the underlying java node or relationship.
       # You can override this method in your own wrapper class.
       # @return self
-      def java_entity
+      def _java_entity
         self
       end
     end

data/lib/neo4j-core.rb

@@ -37,6 +37,7 @@ require 'neo4j-core/index/indexer_registry'
 require 'neo4j-core/index/index_config'
 require 'neo4j-core/index/indexer'
 require 'neo4j-core/index/lucene_query'
+require 'neo4j-core/index/unique_factory'
 
 require 'neo4j-core/equal/equal'
 

metadata

@@ -2,7 +2,7 @@
 name: neo4j-core
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.13
+  version: 0.0.14
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-23 00:00:00 Z
+date: 2012-04-24 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community
@@ -72,6 +72,7 @@ files:
   - lib/neo4j-core/index/indexer.rb
   - lib/neo4j-core/index/lucene_query.rb
   - lib/neo4j-core/index/indexer_registry.rb
+  - lib/neo4j-core/index/unique_factory.rb
   - lib/neo4j-core/index/class_methods.rb
   - lib/neo4j-core/index/index.rb
   - lib/neo4j-core/relationship/class_methods.rb