neoid 0.0.51 → 0.1

data/lib/neoid/batch.rb

@@ -0,0 +1,168 @@
+module Neoid
+  class Batch
+    def default_options=(value)
+      @default_options = value
+    end
+
+    def self.default_options
+      @default_options ||= { batch_size: 200, individual_promises: true }
+    end
+
+    def self.current_batch
+      Thread.current[:neoid_current_batch]
+    end
+
+    def self.current_batch=(batch)
+      Thread.current[:neoid_current_batch] = batch
+    end
+
+    def self.reset_current_batch
+      Thread.current[:neoid_current_batch] = nil
+    end
+
+    def initialize(options={}, &block)
+      if options.respond_to?(:call) && !block
+        block = options
+        options = {}
+      end
+
+      options.reverse_merge!(self.class.default_options)
+
+      @options = options
+      @block = block
+    end
+
+    def <<(command)
+      commands << command
+
+      if commands.length >= @options[:batch_size]
+        flush_batch
+      end
+
+      if @options[:individual_promises]
+        promise = SingleResultPromiseProxy.new(command)
+        thens << promise
+        promise
+      end
+    end
+
+    def commands
+      @commands ||= []
+    end
+
+    def thens
+      @thens ||= []
+    end
+
+    def count
+      @commands ? @commands.count : 0
+    end
+
+    def results
+      @results ||= []
+    end
+
+    def run
+      self.class.current_batch = self
+
+      begin
+        @block.call(self)
+      ensure      
+        self.class.reset_current_batch
+      end
+
+      Neoid.logger.info "Neoid batch (#{commands.length} commands)"
+
+      flush_batch
+
+      BatchPromiseProxy.new(results)
+    end
+
+    private
+      def flush_batch
+        return [] if commands.empty?
+        current_results = nil
+
+        # results = Neoid.db.batch(*commands).collect { |result| result['body'] }
+
+        benchmark = Benchmark.measure {
+          current_results = Neoid.db.batch(*commands).collect { |result| result['body'] }
+        }
+        Neoid.logger.info "Neoid batch (#{commands.length} commands) - #{benchmark}"
+        commands.clear
+
+        process_results(current_results)
+
+        thens.zip(current_results).each { |t, result| t.perform(result) }
+
+        thens.clear
+
+        results.concat current_results
+      end
+
+      def process_results(results)
+        results.map! do |result|
+          return result unless result.is_a?(Hash) && result['self'] && result['self'][%r[^https?://.*/(node|relationship)/\d+]]
+
+          type = case $1
+          when 'node' then Neoid::Node
+          when 'relationship' then Neoid::Relationship
+          else return result
+          end
+
+          type.from_hash(result)
+        end
+      end
+  end
+
+  # returned from a full batch, after it has been executed,
+  # so a `.then` can be chained after the batch do ... end
+  # it proxies all methods to the result
+  class BatchPromiseProxy
+    def initialize(*results)
+      @results = results
+    end
+
+    def method_missing(method, *args)
+      @results.send(method, *args)
+    end
+
+    def then
+      yield(*@results)
+    end
+  end
+
+  # returned from adding (<<) an item to a batch in a batch block:
+  # Neoid.batch { |batch| (batch << [:neography_command, param]).is_a?(SingleResultPromiseProxy) }
+  # so a `.then` can be chained:
+  # Neoid.batch { |batch| (batch << [:neography_command, param]).then { |result| puts result } }
+  # the `then` is called once the batch is flushed with the result of the single job in the batch
+  # it proxies all methods to the result, so in case it is returned (like in Neoid.execute_script_or_add_to_batch)
+  # the result of the method will be proxied to the result from the batch. See Node#neo_save
+  class SingleResultPromiseProxy
+    def initialize(*args)
+    end
+
+    attr_accessor :result
+
+    def result
+      raise "Accessed result too soon" unless @result
+      @result
+    end
+
+    def method_missing(method, *args)
+      result.send(method, *args)
+    end
+
+    def then(&block)
+      @then = block
+      self
+    end
+
+    def perform(result)
+      @result = result
+      return unless @then
+      @then.call(result)
+    end
+  end
+end

data/lib/neoid/config.rb

@@ -0,0 +1,6 @@
+module Neoid
+  class Config
+    attr_accessor :enable_subrefs
+    attr_accessor :enable_per_model_indexes
+  end
+end

data/lib/neoid/middleware.rb

@@ -5,10 +5,12 @@ module Ndoid
     end
 
     def call(env)
-      old, Thread.current[:neoid_enabled] = Thread.current[:neoid_enabled], true
+      old_enabled, Thread.current[:neoid_enabled] = Thread.current[:neoid_enabled], true
+      old_batch, Thread.current[:neoid_current_batch] = Thread.current[:neoid_current_batch], nil
       @app.call(env)
     ensure
-      Thread.current[:neoid_enabled] = old
+      Thread.current[:neoid_enabled] = old_enabled
+      Thread.current[:neoid_current_batch] = old_batch
     end
   end
 end

data/lib/neoid/model_additions.rb

@@ -2,18 +2,26 @@ module Neoid
   module ModelAdditions
     module ClassMethods
       attr_reader :neoid_config
-      attr_reader :neoid_options
       
       def neoid_config
         @neoid_config ||= Neoid::ModelConfig.new(self)
       end
       
       def neoidable(options = {})
+        # defaults
+        neoid_config.auto_index = true
+        neoid_config.enable_model_index = true # but the Neoid.enable_per_model_indexes is false by default. all models will be true only if the primary option is turned on.
+
         yield(neoid_config) if block_given?
-        @neoid_options = options
+
+        options.each do |key, value|
+          raise "Neoid #{self.name} model options: No such option #{key}" unless neoid_config.respond_to?("#{key}=")
+          neoid_config.send("#{key}=", value)
+        end
       end
-    
-      def neo_index_name
+
+      def neo_model_index_name
+        raise "Per Model index is not enabled. Nodes/Relationships are auto indexed with node_auto_index/relationship_auto_index" unless Neoid.config.enable_per_model_indexes || neoid_config.enable_model_index
         @index_name ||= "#{self.name.tableize}_index"
       end
     end
@@ -37,9 +45,51 @@ module Neoid
         end
       end
 
-      def neo_resave
+      def neo_save_after_model_save
+        return unless self.class.neoid_config.auto_index
+        neo_save
+        true
+      end
+
+      def neo_save
+        @_neo_destroyed = false
+        @_neo_representation = _neo_save
+      end
+
+      alias neo_create neo_save
+      alias neo_update neo_save
+
+      def neo_destroy
+        return if @_neo_destroyed
+        @_neo_destroyed = true
+
+        neo_representation = neo_find_by_id
+        return unless neo_representation
+
+        begin
+          neo_representation.del
+        rescue Neography::NodeNotFoundException => e
+          Neoid::logger.info "Neoid#neo_destroy entity not found #{self.class.name} #{self.id}"
+        end
+
+        # Not working yet because Neography can't delete a node and all of its realtionships in a batch, and deleting a node with relationships results an error
+        # if Neoid::Batch.current_batch
+        #   Neoid::Batch.current_batch << [self.class.delete_command, neo_representation.neo_id]
+        # else
+        #   begin
+        #     neo_representation.del
+        #   rescue Neography::NodeNotFoundException => e
+        #     Neoid::logger.info "Neoid#neo_destroy entity not found #{self.class.name} #{self.id}"
+        #   end
+        # end
+
         _reset_neo_representation
-        neo_update
+
+        true
+      end
+
+      def neo_unique_id
+        "#{self.class.name}:#{self.id}"
       end
 
       protected
@@ -52,14 +102,7 @@ module Neoid
 
       private
       def _neo_representation
-        @_neo_representation ||= begin
-          results = neo_find_by_id
-          if results
-            neo_load(results.first['self'])
-          else
-            neo_create
-          end
-        end
+        @_neo_representation ||= neo_find_by_id || neo_save
       end
 
       def _reset_neo_representation
@@ -70,7 +113,9 @@ module Neoid
     def self.included(receiver)
       receiver.extend         ClassMethods
       receiver.send :include, InstanceMethods
-      Neoid.models << receiver
+
+      receiver.after_save :neo_save_after_model_save
+      receiver.after_destroy :neo_destroy
     end
   end
 end

data/lib/neoid/model_config.rb

@@ -3,6 +3,8 @@ module Neoid
     attr_reader :properties
     attr_reader :search_options
     attr_reader :relationship_options
+    attr_accessor :enable_model_index
+    attr_accessor :auto_index
     
     def initialize(klass)
       @klass = klass

data/lib/neoid/node.rb

@@ -1,15 +1,46 @@
 module Neoid
   module Node
+    def self.from_hash(hash)
+      node = Neography::Node.new(hash)
+      node.neo_server = Neoid.db
+      node
+    end
+
     module ClassMethods
+      attr_accessor :neo_subref_node
+
       def neo_subref_rel_type
         @_neo_subref_rel_type ||= "#{self.name.tableize}_subref"
       end
+
       def neo_subref_node_rel_type
         @_neo_subref_node_rel_type ||= self.name.tableize
       end
-      
+
+      def delete_command
+        :delete_node
+      end
+
+      def neo_model_index
+        return nil unless Neoid.config.enable_per_model_indexes
+
+        Neoid::logger.info "Node#neo_model_index #{neo_subref_rel_type}"
+
+        gremlin_query = <<-GREMLIN
+          g.createManualIndex(neo_model_index_name, Vertex.class);
+        GREMLIN
+
+        # Neoid.logger.info "subref query:\n#{gremlin_query}"
+
+        script_vars = { neo_model_index_name: neo_model_index_name }
+
+        Neoid.execute_script_or_add_to_batch gremlin_query, script_vars
+      end
+
       def neo_subref_node
-        @_neo_subref_node ||= begin
+        return nil unless Neoid.config.enable_subrefs
+
+        @neo_subref_node ||= begin
           Neoid::logger.info "Node#neo_subref_node #{neo_subref_rel_type}"
 
           gremlin_query = <<-GREMLIN
@@ -22,19 +53,26 @@ module Neoid
               g.addEdge(g.v(0), subref, neo_subref_rel_type);
             }
 
-            g.createManualIndex(neo_index_name, Vertex.class);
-
             subref
           GREMLIN
 
-          Neoid.logger.info "subref query:\n#{gremlin_query}"
+          # Neoid.logger.info "subref query:\n#{gremlin_query}"
 
-          node = Neography::Node.load(Neoid.db.execute_script(gremlin_query, neo_subref_rel_type: neo_subref_rel_type, name: self.name, neo_index_name: self.neo_index_name))
+          script_vars = {
+            neo_subref_rel_type: neo_subref_rel_type,
+            name: self.name
+          }
 
-          node
+          Neoid.execute_script_or_add_to_batch gremlin_query, script_vars do |value|
+            Neoid::Node.from_hash(value)
+          end
         end
       end
 
+      def reset_neo_subref_node
+        @neo_subref_node = nil
+      end
+
       def neo_search(term, options = {})
         Neoid.search(self, term, options)
       end
@@ -42,48 +80,72 @@ module Neoid
     
     module InstanceMethods
       def neo_find_by_id
-        Neoid::logger.info "Node#neo_find_by_id #{self.class.neo_index_name} #{self.id}"
-        Neoid.db.get_node_index(self.class.neo_index_name, :ar_id, self.id)
-      rescue Neography::NotFoundException
-        nil
+        # Neoid::logger.info "Node#neo_find_by_id #{self.class.neo_index_name} #{self.id}"
+        node = Neoid.db.get_node_auto_index(Neoid::UNIQUE_ID_KEY, self.neo_unique_id)
+        node.present? ? Neoid::Node.from_hash(node[0]) : nil
       end
       
-      def neo_create
+      def _neo_save
         return unless Neoid.enabled?
-        
-        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id)
+
+        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id, Neoid::UNIQUE_ID_KEY => self.neo_unique_id)
         data.reject! { |k, v| v.nil? }
-        
-        node = Neography::Node.create(data)
-        
-        retires = 2
-        begin
-          Neography::Relationship.create(
-            self.class.neo_subref_node_rel_type,
-            self.class.neo_subref_node,
-            node
+
+        gremlin_query = <<-GREMLIN
+          idx = g.idx('node_auto_index');
+          q = null;
+          if (idx) q = idx.get(unique_id_key, unique_id);
+
+          node = null;
+          if (q && q.hasNext()) {
+            node = q.next();
+            node_data.each {
+              if (node.getProperty(it.key) != it.value) {
+                node.setProperty(it.key, it.value);
+              }
+            }
+          } else {
+            node = g.addVertex(node_data);
+            if (enable_subrefs) g.addEdge(g.v(subref_id), node, neo_subref_rel_type);
+
+            if (enable_model_index) g.idx(neo_model_index_name).put('ar_id', node.ar_id, node);
+          }
+
+          node
+        GREMLIN
+
+         script_vars = {
+          unique_id_key: Neoid::UNIQUE_ID_KEY,
+          node_data: data,
+          unique_id: self.neo_unique_id,
+          enable_subrefs: Neoid.config.enable_subrefs,
+          enable_model_index: Neoid.config.enable_per_model_indexes && self.class.neoid_config.enable_model_index
+        }
+
+        if Neoid.config.enable_subrefs
+          script_vars.update(
+            subref_id: self.class.neo_subref_node.neo_id,
+            neo_subref_rel_type: self.class.neo_subref_rel_type
           )
-        rescue
-          # something must've happened to the cached subref node, reset and retry
-          @_neo_subref_node = nil
-          retires -= 1
-          retry if retires > 0
         end
 
-        Neoid.db.add_node_to_index(self.class.neo_index_name, :ar_id, self.id, node)
+        if Neoid.config.enable_per_model_indexes && self.class.neoid_config.enable_model_index
+          script_vars.update(
+            neo_model_index_name: self.class.neo_model_index_name
+          )
+        end
 
-        Neoid::logger.info "Node#neo_create #{self.class.name} #{self.id}, index = #{self.class.neo_index_name}"
-        
-        neo_search_index
+        Neoid::logger.info "Node#neo_save #{self.class.name} #{self.id}"
+
+        node = Neoid.execute_script_or_add_to_batch(gremlin_query, script_vars) do |value|
+          @_neo_representation = Neoid::Node.from_hash(value)
+        end.then do |result|
+          neo_search_index
+        end
 
         node
       end
-      
-      def neo_update
-        Neoid.db.set_node_properties(neo_node, self.to_neo)
-        neo_search_index
-      end
-      
+
       def neo_search_index
         return if self.class.neoid_config.search_options.blank? || (
           self.class.neoid_config.search_options.index_fields.blank? &&
@@ -113,29 +175,20 @@ module Neoid
         end
       end
       
-      def neo_load(node)
-        Neography::Node.load(node)
+      def neo_load(hash)
+        Neoid::Node.from_hash(hash)
       end
       
       def neo_node
         _neo_representation
       end
-    
-      def neo_destroy
-        return unless neo_node
-        Neoid.db.remove_node_from_index(DEFAULT_FULLTEXT_SEARCH_INDEX_NAME, neo_node)
-
-        Neoid.db.remove_node_from_index(self.class.neo_index_name, neo_node)
-        neo_node.del
-        _reset_neo_representation
-      end
 
       def neo_after_relationship_remove(relationship)
         relationship.neo_destroy
       end
 
       def neo_before_relationship_through_remove(record)
-        rel_model, foreign_key_of_owner, foreign_key_of_record = Neoid.config[:relationship_meta_data][self.class.name.to_s][record.class.name.to_s]
+        rel_model, foreign_key_of_owner, foreign_key_of_record = Neoid::Relationship.meta_data[self.class.name.to_s][record.class.name.to_s]
         rel_model = rel_model.to_s.constantize
         @__neo_temp_rels ||= {}
         @__neo_temp_rels[record] = rel_model.where(foreign_key_of_owner => self.id, foreign_key_of_record => record.id).first
@@ -152,10 +205,6 @@ module Neoid
       receiver.extend         ClassMethods
       receiver.send :include, InstanceMethods
       Neoid.node_models << receiver
-      
-      receiver.after_create :neo_create
-      receiver.after_update :neo_update
-      receiver.after_destroy :neo_destroy
     end
   end
 end