neo4j 1.2.4-java → 1.2.5-java

data/CHANGELOG

@@ -1,3 +1,16 @@
+ == 1.2.5 / 2011-10-21
+* Faster traversals by avoiding loading Ruby wrappers (new method 'raw' on traversals) [#189]
+* Support for IdentityMap [#188]
+* Improved performance in event handler (Vivek Prahlad)
+* Fixing issue with validates_presence_of validation (Vivek Prahlad)
+* Implemented compositions support on Neo4j::Rails::Relationship (Kalyan Akella)
+* Added after_initialize callback (Deepak N)
+* Fixed performance issues on node deleted (Vivek Prahlad)
+* Fixed a performance issue in the index_registry (Vivek Prahlad)
+* Fixed uniqueness validation for :case_sensitive => false (Vivek Prahlad)
+* Fixed update_attributes deleting relations when model is invalid (Deepak N)
+* Fixed timestamp rails generator (Marcio Toshio)
+
  == 1.2.4 / 2011-10-07
 * Support for traversing with Neo4j::Node#eval_paths and setting uniqueness on traversals [#187]
 * Removed unnecessary node creation on database start up (class nodes attached to reference node) (Vivek Prahlad)

data/CONTRIBUTORS

@@ -2,7 +2,8 @@ Maintainer:
   Andreas Ronge <andreas dot ronge at gmail dot com>
 
 Contributors:
-
+* Marcio Toshio
+* Kalyan Akella
 * Vivek Prahlad
 * Deepak N
 * Frédéric Vanclef

data/config/neo4j/config.yml

@@ -7,6 +7,11 @@ storage_path: db
 # If disabled all custom rules will also be unavailable.
 enable_rules: true
 
+# if identity map should be on or not
+# It may impact the performance. Using the identity map will keep all loaded wrapper node/relationship
+# object in memory for each thread and transaction - which may speed up or slow down operations.
+identity_map: false
+
 # When using the Neo4j::Model you can let neo4j automatically set timestamps when updating/creating nodes.
 # If set to true neo4j.rb automatically timestamps create and update operations if the model has properties named created_at/created_on or updated_at/updated_on
 # (similar to ActiveRecord).

data/lib/generators/neo4j/model/model_generator.rb

@@ -27,11 +27,11 @@ class Neo4j::Generators::ModelGenerator < Neo4j::Generators::Base #:nodoc:
 	
 	def timestamp_statements
 		%q{
-  property :created_at, DateTime
-  # property :created_on, Date
+  property :created_at, :type => DateTime
+  # property :created_on, :type => Date
 
-  property :updated_at, DateTime
-  # property :updated_on, Date
+  property :updated_at, :type => DateTime
+  # property :updated_on, :type => Date
 }            
 	end
 	

data/lib/neo4j.rb

@@ -63,7 +63,7 @@ end
 
 module Neo4j
   include Java
-  
+
   # Enumerator has been moved to top level in Ruby 1.9.2, make it compatible with Ruby 1.8.7
   Enumerator = Enumerable::Enumerator unless defined? Enumerator
 end
@@ -72,6 +72,7 @@ require 'neo4j/version'
 require 'neo4j/neo4j'
 require 'neo4j/node'
 require 'neo4j/relationship'
+require 'neo4j/relationship_set'
 
 require 'neo4j/type_converters/type_converters'
 
@@ -103,4 +104,7 @@ require 'neo4j/batch/batch'
 
 require 'orm_adapter/adapters/neo4j'
 
+require 'neo4j/identity_map'
+
+
 

data/lib/neo4j/config.rb

@@ -14,6 +14,7 @@ module Neo4j
   # <tt>:timestamps</tt>::     default <tt>true</tt> for Rails Neo4j::Model - if timestamps should be used when saving the model
   # <tt>:lucene</tt>::         default hash keys: <tt>:fulltext</tt>, <tt>:exact</tt> configuration how the lucene index is stored
   # <tt>:enable_rules</tt>::   default true, if false the _all relationship to all instances will not be created and custom rules will not be available.
+  # <tt>:identity_map</tt>::   default false, See Neo4j::IdentityMap
   #
   class Config
     # This code is copied from merb-core/config.rb.

data/lib/neo4j/event_handler.rb

@@ -12,6 +12,7 @@ module Neo4j
   # * <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)
   #
@@ -28,26 +29,33 @@ module Neo4j
   #
   # * <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, tx_data)
+  # ==== 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>tx_data</tt> :: the Java Transaction Data object,  http://api.neo4j.org/current/org/neo4j/graphdb/event/TransactionData.html
+  # * <tt>deleted_relationship_set</tt> :: the set of deleted relationships. See Neo4j::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, tx_data)
+  # ==== on_relationship_created(rel, created_node_identity_map)
   #
   # * <tt>rel</tt> :: the relationship that was created
-  # * <tt>tx_data</tt> :: the Java Transaction Data object,  http://api.neo4j.org/current/org/neo4j/graphdb/event/TransactionData.html
+  # * <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, tx_data)
+  # ==== 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>tx_data</tt> :: the Java Transaction Data object,  http://api.neo4j.org/current/org/neo4j/graphdb/event/TransactionData.html
+  # * <tt>deleted_relationship_set</tt> :: the set of deleted relationships. See Neo4j::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)
   #
@@ -66,7 +74,7 @@ module Neo4j
   # == Usage
   #
   #   class MyListener
-  #     def on_node_deleted(node, old_props, tx_data)
+  #     def on_node_deleted(node, old_props, deleted_relationship_set, deleted_node_identity_map)
   #     end
   #   end
   #
@@ -84,34 +92,56 @@ module Neo4j
 
 
     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)
+      created_node_identity_map = node_identity_map(data.created_nodes)
+      deleted_node_identity_map = 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)
+      empty_map = java.util.HashMap.new
       data.created_nodes.each{|node| node_created(node)}
       data.assigned_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, tx_data.value) }
-      data.removed_node_properties.each { |tx_data| property_changed(tx_data.entity, tx_data.key, tx_data.previously_commited_value, nil) unless data.deleted_nodes.include?(tx_data.entity) }
-      data.deleted_nodes.each { |node| node_deleted(node, deleted_properties_for(node,data), data)}
-      data.created_relationships.each {|rel| relationship_created(rel, data)}
-      data.deleted_relationships.each {|rel| relationship_deleted(rel, deleted_rel_properties_for(rel, data), data)}
+      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 data.deleted_relationships.include?(tx_data.entity) }
+      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) }
     end
 
-    def deleted_properties_for(node, data)
-      data.removed_node_properties.find_all{|tx_data| tx_data.entity == node}.inject({}) do |memo, tx_data|
-        memo[tx_data.key] = tx_data.previously_commited_value
-        memo
-      end
+    def node_identity_map(nodes)
+      identity_map = java.util.HashMap.new(nodes.size)
+      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::RelationshipSet.new(relationships.size)
+      relationships.each{|rel| relationship_set.add(rel)}
+      relationship_set
     end
 
-    def deleted_rel_properties_for(rel, data)
-      data.removed_relationship_properties.find_all{|tx_data| tx_data.entity == rel}.inject({}) do |memo, tx_data|
-        memo[tx_data.key] = tx_data.previously_commited_value
-        memo
+    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)
@@ -143,16 +173,16 @@ module Neo4j
       @listeners.each {|li| li.on_node_created(node) if li.respond_to?(:on_node_created)}
     end
 
-    def node_deleted(node,old_properties, data)
-      @listeners.each {|li| li.on_node_deleted(node,old_properties, data) if li.respond_to?(:on_node_deleted)}
+    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, tx_data)
-      @listeners.each {|li| li.on_relationship_created(relationship, tx_data) if li.respond_to?(:on_relationship_created)}
+    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, data)
-      @listeners.each {|li| li.on_relationship_deleted(relationship, old_props, data) if li.respond_to?(:on_relationship_deleted)}
+    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)

data/lib/neo4j/identity_map.rb

@@ -0,0 +1,143 @@
+# https://github.com/rails/rails/blob/master/activerecord/lib/active_record/identity_map.rb
+# https://github.com/rails/rails/pull/76
+
+module Neo4j
+
+  # = Neo4j Identity Map
+  #
+  # Ensures that each object gets loaded only once by keeping every loaded
+  # object in a map. Looks up objects using the map when referring to them.
+  #
+  # More information on Identity Map pattern:
+  #   http://www.martinfowler.com/eaaCatalog/identityMap.html
+  #
+  # == Configuration
+  #
+  # In order to enable IdentityMap, set <tt>config.neo4j.identity_map = true</tt>
+  # in your <tt>config/application.rb</tt> file. If used outside rails, set Neo4j::Config[:identity_map] = true.
+  #
+  # IdentityMap is disabled by default and still in development (i.e. use it with care).
+  #
+  module IdentityMap
+
+    class << self
+      def enabled=(flag)
+        Thread.current[:neo4j_identity_map] = flag
+      end
+
+      def enabled
+         Thread.current[:neo4j_identity_map]
+      end
+
+      alias enabled? enabled
+
+      def node_repository
+        Thread.current[:node_identity_map] ||= java.util.HashMap.new
+      end
+
+      def rel_repository
+        Thread.current[:rel_identity_map] ||= java.util.HashMap.new
+      end
+
+      def repository_for(neo_entity)
+        return nil unless enabled?
+        if neo_entity.class == Neo4j::Node
+          node_repository
+        elsif neo_entity.class == Neo4j::Relationship
+          rel_repository
+        else
+          nil
+        end
+      end
+
+      def use
+        old, self.enabled = enabled, true
+        yield if block_given?
+      ensure
+        self.enabled = old
+        clear
+      end
+
+      def without
+        old, self.enabled = enabled, false
+        yield if block_given?
+      ensure
+        self.enabled = old
+      end
+
+      def get(neo_entity)
+        r = repository_for(neo_entity)
+        r && r.get(neo_entity.neo_id)
+      end
+
+      def add(neo_entity, wrapped_entity)
+        r = repository_for(neo_entity)
+        r && r.put(neo_entity.neo_id, wrapped_entity)
+      end
+
+      def remove(neo_entity)
+        r = repository_for(neo_entity)
+        r && r.remove(neo_entity.neo_id)
+      end
+
+      def remove_node_by_id(node_id)
+        node_repository.remove(node_id)
+      end
+
+      def remove_rel_by_id(rel_id)
+        rel_repository.remove(rel_id)
+      end
+
+      def clear
+        node_repository.clear
+        rel_repository.clear
+      end
+
+      def on_after_commit(*)
+        clear
+      end
+
+      def on_neo4j_started(db)
+        if not Neo4j::Config[:identity_map]
+          db.event_handler.remove(self)
+        end
+      end
+
+    end
+
+
+    class Middleware
+      class Body #:nodoc:
+        def initialize(target, original)
+          @target = target
+          @original = original
+        end
+
+        def each(&block)
+          @target.each(&block)
+        end
+
+        def close
+          @target.close if @target.respond_to?(:close)
+        ensure
+          IdentityMap.enabled = @original
+          IdentityMap.clear
+        end
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        enabled = IdentityMap.enabled
+        IdentityMap.enabled = Neo4j::Config[:identity_map]
+        status, headers, body = @app.call(env)
+        [status, headers, Body.new(body, enabled)]
+      end
+    end
+  end
+end
+
+Neo4j.unstarted_db.event_handler.add(Neo4j::IdentityMap)
+

data/lib/neo4j/index/indexer.rb

@@ -98,15 +98,13 @@ module Neo4j
         end
       end
 
-      def remove_index_on_fields(node, props, tx_data) #:nodoc:
+      def remove_index_on_fields(node, props, deleted_relationship_set) #: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)
+          deleted_relationship_set.relationships(node.getId).each do |rel|
+            indexer.remove_index_on_fields(rel._start_node, props, deleted_relationship_set)
           end
         end
       end

data/lib/neo4j/index/indexer_registry.rb

@@ -18,9 +18,9 @@ module Neo4j
           @@indexers[classname]
         end
 
-        def on_node_deleted(node, old_props, tx_data)
+        def on_node_deleted(node, old_props, deleted_relationship_set, deleted_identity_map)
           indexer = find_by_class(old_props['_classname'] || node.class.to_s)
-          indexer && indexer.remove_index_on_fields(node, old_props, tx_data)
+          indexer && indexer.remove_index_on_fields(node, old_props, deleted_relationship_set)
         end
 
         def on_property_changed(node, field, old_val, new_val)
@@ -35,23 +35,23 @@ module Neo4j
           on_property_changed(rel, field, old_val, new_val)
         end
 
-        def on_relationship_created(rel, tx_data)
+        def on_relationship_created(rel,created_identity_map)
           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}
+          created = created_identity_map.get(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)
+        def on_relationship_deleted(rel, old_props, deleted_relationship_set, deleted_identity_map)
+          on_node_deleted(rel, old_props, deleted_relationship_set, deleted_identity_map)
           # 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}
+          deleted = deleted_identity_map.get(end_node.neo_id)
           unless deleted
             indexer = find_by_class(end_node['_classname'])
             indexer && indexer.update_on_deleted_relationship(rel)

data/lib/neo4j/index/lucene_query.rb

@@ -117,7 +117,7 @@ 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)
         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
@@ -188,7 +188,7 @@ module Neo4j
           type      = case
                         when Float == decl_type
                           org.apache.lucene.search.SortField::DOUBLE
-                        when Fixnum == decl_type
+                        when Fixnum == decl_type || DateTime == decl_type || Date == decl_type || Time == decl_type
                           org.apache.lucene.search.SortField::LONG
                         else
                           org.apache.lucene.search.SortField::STRING

data/lib/neo4j/load.rb

@@ -3,9 +3,13 @@ module Neo4j
   # === Mixin responsible for loading Ruby wrappers for Neo4j Nodes and Relationship.
   #
   module Load
-    def wrapper(node) # :nodoc:
-      return node unless node.property?(:_classname)
-      to_class(node[:_classname]).load_wrapper(node)
+    def wrapper(entity) # :nodoc:
+      return entity unless entity.property?(:_classname)
+      existing_instance = Neo4j::IdentityMap.get(entity)
+      return existing_instance if existing_instance
+      new_instance = to_class(entity[:_classname]).load_wrapper(entity)
+      Neo4j::IdentityMap.add(entity, new_instance)
+      new_instance
     end
 
     def to_class(class_name) # :nodoc:
@@ -13,8 +17,8 @@ module Neo4j
     end
 
     # Checks if the given entity (node/relationship) or entity id (#neo_id) exists in the database.
-    def exist?(node_or_node_id, db = Neo4j.started_db)
-      id = node_or_node_id.kind_of?(Fixnum) ?  node_or_node_id : node_or_node_id.id
+    def exist?(entity_or_entity_id, db = Neo4j.started_db)
+      id = entity_or_entity_id.kind_of?(Fixnum) ?  entity_or_entity_id : entity_or_entity_id.id
       _load(id, db) != nil
     end
   end

data/lib/neo4j/node.rb

@@ -28,7 +28,7 @@ module Neo4j
     def wrapped_entity  #:nodoc:
       self
     end
-    
+
     def wrapper  #:nodoc:
       self.class.wrapper(self)
     end

data/lib/neo4j/node_mixin/class_methods.rb

@@ -39,6 +39,7 @@ module Neo4j
       def new(*args)
         node = Neo4j::Node.create
         wrapped_node = super()
+        Neo4j::IdentityMap.add(node, wrapped_node)
         wrapped_node.init_on_load(node)
         wrapped_node.init_on_create(*args)
         wrapped_node

data/lib/neo4j/rails/attributes.rb

@@ -216,6 +216,10 @@ module Neo4j
       def attribute?(name)
         name[0] != ?_ && property?(name)
       end
+      
+      def _classname
+        self[:_classname]
+      end
 
       # To get ActiveModel::Dirty to work, we need to be able to call undeclared
       # properties as though they have get methods

data/lib/neo4j/rails/callbacks.rb

@@ -4,7 +4,7 @@ module Neo4j
 			extend ActiveSupport::Concern
 
       CALLBACKS = [
-        :before_validation, :after_validation,
+        :after_initialize, :before_validation, :after_validation,
         :before_create, :around_create, :after_create,
         :before_destroy, :around_destroy, :after_destroy,
         :before_save, :around_save, :after_save,
@@ -12,35 +12,40 @@ module Neo4j
         ].freeze
 
 			included do
-				[:valid?, :create_or_update, :create, :update, :destroy].each do |method|
+				[:initialize, :valid?, :create_or_update, :create, :update, :destroy].each do |method|
 					alias_method_chain method, :callbacks
 				end
-				
+
 				extend ActiveModel::Callbacks
-				
+
+				define_model_callbacks :initialize, :only => :after
 				define_model_callbacks :validation, :create, :save, :update, :destroy
 			end
-			
+
 			def valid_with_callbacks?(*) #:nodoc:
 			  _run_validation_callbacks { valid_without_callbacks? }
 			end
-			
+
 			def destroy_with_callbacks #:nodoc:
 				_run_destroy_callbacks { destroy_without_callbacks }
 			end
-			
+
 			private
 			def create_or_update_with_callbacks #:nodoc:
 				_run_save_callbacks { create_or_update_without_callbacks }
 			end
-	
+
 			def create_with_callbacks #:nodoc:
 				_run_create_callbacks { create_without_callbacks }
 			end
-	
+
 			def update_with_callbacks(*) #:nodoc:
 				_run_update_callbacks { update_without_callbacks }
 			end
+
+			def initialize_with_callbacks(*args, &block) #:nodoc:
+				_run_initialize_callbacks { initialize_without_callbacks(*args, &block) }
+			end
 		end
 	end
 end

data/lib/neo4j/rails/persistence.rb

@@ -5,7 +5,7 @@ module Neo4j
 
 			included do
 				extend TxMethods
-				tx_methods :destroy, :create, :update, :update_nested_attributes, :delete
+				tx_methods :destroy, :create, :update, :update_nested_attributes, :delete, :update_attributes, :update_attributes!
 			end
 
 			# Persist the object to the database.  Validations and Callbacks are included
@@ -154,6 +154,7 @@ module Neo4j
       def create
         node = Neo4j::Node.new
         @_java_node = node
+        Neo4j::IdentityMap.add(node, self)
         init_on_create
         clear_changes
         clear_relationships
@@ -172,7 +173,9 @@ module Neo4j
       end
 
       def reload_from_database
+        Neo4j::IdentityMap.remove_node_by_id(id)
         if reloaded = self.class.load(id)
+          clear_relationships
           send(:attributes=, reloaded.attributes, false)
         end
         reloaded

data/lib/neo4j/rails/railtie.rb

@@ -4,6 +4,7 @@ module Neo4j
 
     initializer "neo4j.tx" do |app|
       app.config.middleware.use Neo4j::Rails::RackMiddleware
+      app.config.middleware.use Neo4j::IdentityMap::Middleware
     end
 
     # Add ActiveModel translations to the I18n load_path

data/lib/neo4j/rails/rel_persistence.rb

@@ -158,6 +158,7 @@ module Neo4j
           _persist_end_node
 
           @_java_rel = Neo4j::Relationship.new(type, start_node, end_node)
+          Neo4j::IdentityMap.add(@_java_rel, self)
           init_on_create
           clear_changes
         end unless @end_node.nil?
@@ -193,6 +194,10 @@ module Neo4j
       end
 
       def reload_from_database
+        Neo4j::IdentityMap.remove_rel_by_id(id) if persisted?
+        Neo4j::IdentityMap.remove_node_by_id(@end_node.id) if @end_node && @end_node.persisted?
+        Neo4j::IdentityMap.remove_node_by_id(@start_node.id) if @start_node && @start_node.persisted?
+
         if reloaded = self.class.load(id)
           send(:attributes=, reloaded.attributes, false)
         end

data/lib/neo4j/rails/relationship.rb

@@ -132,7 +132,8 @@ module Neo4j
       include Validations # enable validations
       include Callbacks # enable callbacks
       include Finders # ActiveRecord style find
+      include Compositions
     end
 
   end
-end
+end

data/lib/neo4j/rails/relationships/relationships.rb

@@ -4,23 +4,24 @@ module Neo4j
 
 
       def write_changed_relationships #:nodoc:
-        @relationships.each_value do |storage|
+        @_relationships.each_value do |storage|
           storage.persist
         end
       end
 
       def clear_relationships #:nodoc:
-        @relationships = {}
+        @_relationships && @_relationships.each_value{|storage| storage.remove_from_identity_map}
+        @_relationships = {}
       end
 
 
       def _create_or_get_storage(rel_type) #:nodoc:
         dsl = _decl_rels_for(rel_type.to_sym)
-        @relationships[rel_type.to_sym] ||= Storage.new(self, rel_type, dsl)
+        @_relationships[rel_type.to_sym] ||= Storage.new(self, rel_type, dsl)
       end
 
       def _create_or_get_storage_for_decl_rels(decl_rels) #:nodoc:
-        @relationships[decl_rels.rel_type.to_sym] ||= Storage.new(self, decl_rels.rel_type, decl_rels)
+        @_relationships[decl_rels.rel_type.to_sym] ||= Storage.new(self, decl_rels.rel_type, decl_rels)
       end
 
 

data/lib/neo4j/rails/relationships/storage.rb

@@ -14,9 +14,6 @@ module Neo4j
           @target_class = (dsl && dsl.target_class) || Neo4j::Rails::Model
           @outgoing_rels = []
           @incoming_rels = []
-          @persisted_related_nodes = {}
-          @persisted_relationships = {}
-          @persisted_node_to_relationships = {}
         end
 
         def to_s #:nodoc:
@@ -24,6 +21,11 @@ module Neo4j
         end
 
 
+        def remove_from_identity_map
+          @outgoing_rels.each {|r| Neo4j::IdentityMap.remove(r._java_rel)}
+          @incoming_rels.each {|r| Neo4j::IdentityMap.remove(r._java_rel)}
+        end
+
         def size(dir)
           counter = 0
           # count persisted relationship
@@ -60,18 +62,12 @@ module Neo4j
         def each_rel(dir, &block) #:nodoc:
           relationships(dir).each { |rel| block.call rel }          
           if @node.persisted?
-            cache_relationships(dir) if @persisted_relationships[dir].nil?
-            @persisted_relationships[dir].each {|rel| block.call rel unless !rel.exist?}
+            @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
+              block.call(rel.wrapper)
+            end
           end
         end
         
-        def cache_relationships(dir)
-          @persisted_relationships[dir] ||= []
-          node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
-            @persisted_relationships[dir] << rel.wrapper
-          end          
-        end
-
         def each_node(dir, &block)
           relationships(dir).each do |rel|
             if rel.start_node == @node
@@ -80,31 +76,21 @@ module Neo4j
               block.call rel.start_node
             end
           end
-          if @node.persisted?
-            cache_persisted_nodes_and_relationships(dir) if @persisted_related_nodes[dir].nil?
-            @persisted_related_nodes[dir].each {|node| block.call node unless relationship_deleted?(dir,node)}
-          end
-        end
 
-        def cache_persisted_nodes_and_relationships(dir)
-          @persisted_related_nodes[dir] ||= []
-          @persisted_node_to_relationships[dir] ||= {}
-          @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
-            end_node = rel.getOtherNode(@node._java_node).wrapper
-            @persisted_related_nodes[dir] << end_node
-            @persisted_node_to_relationships[dir][end_node]=rel
+          if @node.persisted?
+            @node._java_node.getRelationships(java_rel_type, dir_to_java(dir)).each do |rel|
+              end_node = rel.getOtherNode(@node._java_node).wrapper
+              block.call(end_node)
+            end
           end
         end
 
-        def relationship_deleted?(dir,node)
-          @persisted_node_to_relationships[dir][node].nil? || !@persisted_node_to_relationships[dir][node].exist?
-        end
-
-        def single_relationship(dir)
+        def single_relationship(dir, raw = false)
           rel = relationships(dir).first
+#          puts "single_relationship #{dir} for #{self}, got #{rel && rel._java_rel} @node.persisted?=#{@node.persisted?}, #{@node._java_node}"
           if rel.nil? && @node.persisted?
             java_rel = @node._java_node.getSingleRelationship(java_rel_type, dir_to_java(dir))
-            java_rel && java_rel.wrapper
+            raw ? java_rel : java_rel && java_rel.wrapper
           else
             rel
           end
@@ -115,10 +101,8 @@ module Neo4j
         end
 
         def single_node(dir)
-          rel = single_relationship(dir)
-          return nil if rel.nil?
-          other = rel.other_node(@node)
-          other && other.wrapper
+          rel = single_relationship(dir, true)
+          rel && rel.other_node(@node)
         end
 
         def destroy_rels(dir, *nodes)
@@ -161,7 +145,7 @@ module Neo4j
           out_rels = @outgoing_rels.clone
           in_rels = @incoming_rels.clone
 
-          [@outgoing_rels, @incoming_rels, @persisted_related_nodes, @persisted_node_to_relationships, @persisted_relationships].each{|c| c.clear}
+          [@outgoing_rels, @incoming_rels].each{|c| c.clear}
 
           out_rels.each do |rel|
             rel.end_node.rm_incoming_rel(@rel_type.to_sym, rel) if rel.end_node

data/lib/neo4j/rails/timestamps.rb

@@ -3,19 +3,19 @@ module Neo4j
     # Handle all the created_at, updated_at, created_on, updated_on type stuff.
 		module Timestamps
 			extend ActiveSupport::Concern
-			
+
 			TIMESTAMP_PROPERTIES = [ :created_at, :created_on, :updated_at, :updated_on ]
-			
+
 			def write_changed_attributes
 				update_timestamp
 				super
 			end
-			
+
 			def init_on_create(*args)
 				create_timestamp
 				super
 			end
-			
+
 			# Set the timestamps for this model if timestamps is set to true in the config
 			# and the model is set up with the correct property name, e.g.:
 			#
@@ -23,9 +23,9 @@ module Neo4j
 			#     property :updated_at, :type => DateTime
 			#   end
 			def update_timestamp
-				write_date_or_timestamp(:updated_at) if Neo4j::Config[:timestamps] && respond_to?(:updated_at)
+				#definition provided whenever an :updated_at property is defined
 			end
-			
+
 			# Set the timestamps for this model if timestamps is set to true in the config
 			# and the model is set up with the correct property name, e.g.:
 			#
@@ -33,9 +33,9 @@ module Neo4j
 			#     property :created_at, :type => DateTime
 			#   end
 			def create_timestamp
-				write_date_or_timestamp(:created_at) if Neo4j::Config[:timestamps] && respond_to?(:created_at)
+				#definition provided whenever an :created_at property is defined
 			end
-			
+
 			# Write the timestamp as a Date, DateTime or Time depending on the property type
 			def write_date_or_timestamp(attribute)
 				value = case self.class._decl_props[attribute][:type].to_s
@@ -49,16 +49,25 @@ module Neo4j
 
 				send("#{attribute}=", value)
 			end
-			
+
 			module ClassMethods
 				def property_setup(property, options)
 					super
-					
+          define_timestamp_method(:create_timestamp,:created_at) if property == :created_at
+				  define_timestamp_method(:update_timestamp,:updated_at) if property == :updated_at
 					# ensure there's always a type on the timestamp properties
 					if Neo4j::Config[:timestamps] && TIMESTAMP_PROPERTIES.include?(property)
 						_decl_props[property][:type] ||= Time
 					end
 				end
+
+				def define_timestamp_method(method_name, property)
+					class_eval <<-RUBY, __FILE__, __LINE__
+						def #{method_name}
+							write_date_or_timestamp(:#{property}) if Neo4j::Config[:timestamps]
+						end
+          RUBY
+			  end
 			end
 		end
 	end

data/lib/neo4j/rails/validations/uniqueness.rb

@@ -1,37 +1,76 @@
 module Neo4j
-	module Rails
-		module Validations
-			extend ActiveSupport::Concern
-			
-			class UniquenessValidator < ActiveModel::EachValidator
-				def initialize(options)
-					super(options.reverse_merge(:case_sensitive => true))
-				end
-	
-				def setup(klass)
-					@attributes.each do |attribute|
-						if klass.index_type_for(attribute) != :exact
-							raise "Can't validate property #{attribute.inspect} on class #{klass} since there is no :exact lucene index on that property or the index declaration #{attribute} comes after the validation declaration in #{klass} (try to move it before the validation rules)"
-						end
-					end
-				end
-	
-				def validate_each(record, attribute, value)
-					return if options[:allow_blank] && value.blank?
-					record.class.all("#{attribute}: \"#{value}\"").each do |rec|
+  module Rails
+    module Validations
+      extend ActiveSupport::Concern
+
+      class UniquenessValidator < ActiveModel::EachValidator
+        def initialize(options)
+          super(options.reverse_merge(:case_sensitive => true))
+            @validator =  options[:case_sensitive].nil? || options[:case_sensitive] ? ExactMatchValidator : FulltextMatchValidator
+        end
+
+        def setup(klass)
+          @attributes.each do |attribute|
+            if klass.index_type_for(attribute) != @validator.index_type
+              raise index_error_message(klass,attribute,@validator.index_type)
+            end
+          end
+        end
+
+        def index_error_message(klass,attribute,index_type)
+          "Can't validate property #{attribute.inspect} on class #{klass} since there is no :#{index_type} lucene index on that property or the index declaration #{attribute} comes after the validation declaration in #{klass} (try to move it before the validation rules)"
+        end
+
+        def validate_each(record, attribute, value)
+          return if options[:allow_blank] && value.blank?
+          @validator.query(record.class,attribute,value).each do |rec|
             if rec.id != record.id # it doesn't count if we find ourself!
-              record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+              if @validator.match(rec, attribute, value)
+                record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+              end
               break
             end
-					end
-				end
-			end
-	
-			module ClassMethods
-				def validates_uniqueness_of(*attr_names)
-					validates_with UniquenessValidator, _merge_attributes(attr_names)
-				end
-			end
-		end
-	end
+          end
+        end
+      end
+
+      class ExactMatchValidator
+        def self.index_type
+          :exact
+        end
+
+        def self.query(model,attribute,value)
+          model.all("#{attribute}: \"#{value}\"")
+        end
+
+        def self.match(rec,attribute,value)
+          rec[attribute] == value
+        end
+      end
+
+      class FulltextMatchValidator
+        def self.index_type
+          :fulltext
+        end
+
+        def self.query(model,attribute,value)
+          value.blank? ? model.all("*:* -#{attribute}:[* TO *]", :type => :fulltext) : model.all("#{attribute}: \"#{value}\"", :type => :fulltext)
+        end
+
+        def self.match(rec,attribute,value)
+          downcase(rec[attribute]) == downcase(value)
+        end
+
+        def self.downcase(value)
+          value.nil? ? value : value.strip.downcase
+        end
+      end
+
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
 end

data/lib/neo4j/relationship_mixin/class_methods.rb

@@ -24,6 +24,7 @@ module Neo4j
         type, from_node, to_node = args
         rel = Neo4j::Relationship.create(type, from_node, to_node)
         wrapped_rel = super()
+        Neo4j::IdentityMap.add(rel, wrapped_rel)
         wrapped_rel.init_on_load(rel)
         wrapped_rel.init_on_create(*args)
         wrapped_rel

data/lib/neo4j/relationship_set.rb

@@ -0,0 +1,58 @@
+module Neo4j
+  # == Represents a set of relationships.
+  # See Neo4j::EventHandler
+  class RelationshipSet
+    def initialize(size=0)
+      @relationship_type_set = java.util.HashSet.new(size)
+      @relationship_set = java.util.HashSet.new(size)
+      @relationship_map = java.util.HashMap.new(size)
+    end
+
+    # Adds a relationship to the set
+    def add(rel)
+      @relationship_type_set.add(RelationshipSetEntry.new(rel.getEndNode().getId(),rel.rel_type))
+      relationships(rel.getEndNode().getId()) << rel
+      @relationship_set.add(rel.getId)
+    end
+
+    # Returns a collection of relationships where the node with the specified end node id is the end node.
+    def relationships(end_node_id)
+      @relationship_map.get(end_node_id) || add_list(end_node_id)
+    end
+
+    # Returns true if the specified relationship is in the set
+    def contains_rel?(rel)
+      @relationship_set.contains(rel.getId)
+    end
+
+    # Returns true if a relationship with the specified end_node_id and relationship_type is present in the set.
+    def contains?(end_node_id,relationship_type)
+      @relationship_type_set.contains(RelationshipSetEntry.new(end_node_id,relationship_type))
+    end
+
+    protected
+    def add_list(node_id)
+      @relationship_map.put(node_id,[])
+      @relationship_map.get(node_id)
+    end
+  end
+
+  class RelationshipSetEntry
+    attr_accessor :nodeid, :relationship_type
+    def initialize(nodeid,relationship_type)
+      @nodeid,@relationship_type = nodeid.to_s, relationship_type.to_s
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+    def eql?(other)
+      @nodeid == other.nodeid && @relationship_type == other.relationship_type
+    end
+
+    def hash
+      3 * @nodeid.hash + @relationship_type.hash
+    end
+  end
+end

data/lib/neo4j/rule/event_listener.rb

@@ -17,7 +17,7 @@ module Neo4j
           Rule.trigger_rules(node, *changes) if Rule.trigger?(node)
         end
 
-        def on_node_deleted(node, old_properties, data)
+        def on_node_deleted(node, old_properties, deleted_relationship_set, deleted_identity_map)
           # have we deleted a rule node ?
           del_rule_node = Rule.find_rule_node(node)
           del_rule_node && del_rule_node.clear_rule_node
@@ -34,13 +34,11 @@ module Neo4j
             rule_name = rule.rule_name.to_s
 
             # is the rule node deleted ?
-            deleted_rule_node = data.deletedNodes.find { |n| n == rule_node.rule_node }
+            deleted_rule_node = deleted_identity_map.get(rule_node.rule_node.neo_id)
             next if deleted_rule_node
 
             rule.functions.each do |function|
-              next unless data.deletedRelationships.find do |r|
-                r.getEndNode().getId() == id && r.rel_type == rule_name
-              end
+              next unless deleted_relationship_set.contains?(id,rule_name)
               previous_value = old_properties[function.function_id]
               function.delete(rule_name, rule_node.rule_node, previous_value) if previous_value
             end if rule.functions

data/lib/neo4j/rule/rule.rb

@@ -115,16 +115,16 @@ module Neo4j
           rule_node.execute_rules(node, *changes)
 
           # recursively add relationships for all the parent classes with rules that also pass for this node
-          recursive(node,classname,*changes)
+          recursive(node,rule_node.model_class,*changes)
         end
 
         private 
 
-          def recursive(node,classname,*changes)
-            if (clazz = eval("#{classname}.superclass")) && clazz.include?(Neo4j::NodeMixin)
+          def recursive(node,model_class,*changes)
+            if (clazz = model_class.superclass) && clazz.include?(Neo4j::NodeMixin)
               rule_node = rule_node_for(clazz)
               rule_node && rule_node.execute_rules(node, *changes)
-              recursive(node,clazz.name,*changes)
+              recursive(node,clazz,*changes)
             end
           end
       end

data/lib/neo4j/rule/rule_node.rb

@@ -9,27 +9,28 @@ module Neo4j
     class RuleNode
       include ToJava
       attr_reader :rules
+      attr_reader :model_class
 
       def initialize(clazz)
-        @type = eval("#{clazz}")
-        @clazz = clazz
+        @model_class = eval("#{clazz}")
+        @classname = clazz
         @rules = []
         @rule_node_key = ("rule_" + clazz.to_s).to_sym
         @ref_node_key = ("rule_ref_for_" + clazz.to_s).to_sym
       end
 
       def to_s
-        "RuleNode #{@clazz}, node #{rule_node} #rules: #{@rules.size}"
+        "RuleNode #{@classname}, node #{rule_node} #rules: #{@rules.size}"
       end
 
       # returns true if the rule node exist yet in the database
       def node_exist?
-        !ref_node.rel?(@clazz)
+        !ref_node.rel?(@classname)
       end
       
       def ref_node
-        if @type.respond_to? :ref_node_for_class
-          @type.ref_node_for_class
+        if @model_class.respond_to? :ref_node_for_class
+          @model_class.ref_node_for_class
         else
           Neo4j.ref_node
         end
@@ -38,7 +39,7 @@ module Neo4j
       def create_node
         Neo4j::Transaction.run do
           node = Neo4j::Node.new
-          ref_node.create_relationship_to(node, type_to_java(@clazz))
+          ref_node.create_relationship_to(node, type_to_java(@classname))
           node
         end
       end
@@ -50,14 +51,14 @@ module Neo4j
       end
 
       def delete_node
-        if ref_node.rel?(@clazz)
-          ref_node.outgoing(@clazz).each { |n| n.del }
+        if ref_node.rel?(@classname)
+          ref_node.outgoing(@classname).each { |n| n.del }
         end
         clear_rule_node
       end
 
       def find_node
-        ref_node.rel?(@clazz.to_s) && ref_node._rel(:outgoing, @clazz.to_s)._end_node
+        ref_node.rel?(@classname.to_s) && ref_node._rel(:outgoing, @classname.to_s)._end_node
       end
 
       def rule_node

data/lib/neo4j/traversal/traversal.rb

@@ -36,7 +36,10 @@ module Neo4j
     #
     # ==== Examples
     #   # Find all my friends (nodes of depth 1 of type <tt>friends</tt>)
-    #   me.outgoing(:friends).each {|friend| puts friend[:name]}
+    #   me.outgoing(:friends).each {|friend| puts friend.name}
+    #
+    #   # A possible faster way, avoid loading wrapper Ruby classes, instead use raw java neo4j node objects
+    #   me.outgoing(:friends).raw.each {|friend| puts friend[:name]}
     #
     #   # Find all my friends and their friends (nodes of depth 1 of type <tt>friends</tt>)
     #   # me.outgoing(:friends).depth(2).each {|friend| puts friend[:name]}

data/lib/neo4j/traversal/traverser.rb

@@ -194,7 +194,9 @@ module Neo4j
       end
 
       def size
-        to_a.size
+        s = 0
+        iterator.each { |_| s += 1 }
+        s
       end
 
       alias_method :length, :size
@@ -208,7 +210,7 @@ module Neo4j
       end
 
       def each
-        @traversal_result == :paths ? iterator.each { |i| yield i } : iterator.each { |i| yield i.wrapper }
+        @raw ? iterator.each { |i| yield i } : iterator.each { |i| yield i.wrapper }
       end
 
       # Same as #each but does not wrap each node in a Ruby class, yields the Java Neo4j Node instance instead.
@@ -223,10 +225,18 @@ module Neo4j
         self
       end
 
-      # Returns an enumerable of relationships instead of nodes
+      # If this is called then it will not wrap the nodes but instead return the raw Java Neo4j::Node objects when traversing
+      #
+      def raw
+        @raw = true
+        self
+      end
+
+      # Returns an enumerable of paths instead of nodes
       #
       def paths
         @traversal_result = :paths
+        @raw = true
         self
       end
 

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.2.4"
+  VERSION = "1.2.5"
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.4
+  version: 1.2.5
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-07 00:00:00 +02:00
+date: 2011-10-21 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -84,6 +84,7 @@ files:
   - lib/generators/neo4j/model/model_generator.rb
   - lib/generators/neo4j/model/templates/model.erb
   - lib/orm_adapter/adapters/neo4j.rb
+  - lib/neo4j/identity_map.rb
   - lib/neo4j/event_handler.rb
   - lib/neo4j/model.rb
   - lib/neo4j/config.rb
@@ -92,6 +93,7 @@ files:
   - lib/neo4j/node.rb
   - lib/neo4j/load.rb
   - lib/neo4j/database.rb
+  - lib/neo4j/relationship_set.rb
   - lib/neo4j/version.rb
   - lib/neo4j/equal.rb
   - lib/neo4j/relationship.rb