activerecord-futures 0.2.0 → 0.3.0

data/README.md

@@ -68,15 +68,41 @@ both count and page queries at once.
 
 ### Methods
 
-ActiveRecord::Relation instances get a `future` method for all queries where multiple results are returned. The future gets
-executed whenever `#to_a` gets executed. Note that, as ActiveRecord does, enumerable methods get delegated to `#to_a` also,
+#### #future method
+ActiveRecord::Relation instances get a `future` method  that futurizes a normal
+relation. The future gets executed whenever `#to_a` gets executed. Note that, as ActiveRecord does, enumerable methods get delegated to `#to_a` also,
 so things like `#each`, `#map`, `#collect` all trigger the future.
 
-Also, ActiveRecord::Relation instances get all the calculation methods provided by the ActiveRecord::Calculations module
-"futurized", that means, for `#count` you get `#future_count`, for `#sum` you get `#future_sum` and so on. If the calculation
-returns a list of values, for example with a `#future_pluck` or a grouped `#future_count`, the future will be triggered with
-the `#to_a` method (or any of the methods that delegate to `#to_a`). If it returns a single value, the future will be 
-triggered when you execute the `#value` method.
+#### Calculation methods
+You also get all the calculation methods provided by the ActiveRecord::Calculations module
+"futurized". More specifically you get:
+* future_count
+* future_average
+* future_minimum
+* future_maximum
+* future_sum
+* future_calculate
+* future_pluck
+
+All future
+calculations are triggered with the `#value` method, except for the `#future_pluck` method, that returns an array, and is
+triggered with a `#to_a` method (or any other method that delegates to it).
+
+#### Finder methods
+
+Lastly, you also get finder methods futurized, which are:
+
+* future_find
+* future_first
+* future_last
+* future_exists?
+* future_all
+
+As with the other future methods, those which return an array get triggered with
+the `to_a` method, or the delegated ones, and those that return a value or a hash
+are triggered with the `value` method. Note that the `find` method returns an
+array or a value depending on the parameters provided, and so will the futurized
+version of the method.
 
 ## Database support
 
@@ -89,7 +115,7 @@ it will execute the future's query whenever the future is triggered, but it will
 
 Multi statement queries are supported by the mysql2 gem since version 0.3.12b1, so you'll need to use that one or a newer
 one.
-Currently the adapter provided inherits the built-in one in Rails, and it also sets the MULTI_STATEMENTS flag to allow 
+Currently the adapter provided inherits the built-in one in Rails, and it also sets the MULTI_STATEMENTS flag to allow
 multiple queries in a single command.
 If you have an older version of the gem, ActiveRecord::Futures will fall back to normal query execution.
 

data/lib/active_record/connection_adapters/future_enabled.rb

@@ -6,21 +6,22 @@ module ActiveRecord
       end
 
       def exec_query(sql, name = 'SQL', binds = [])
-        my_future = Futures::Future.current
+        my_future = Futures::FutureRegistry.current
 
         # default behavior if not a current future or not executing
         # the current future's sql (some adapters like PostgreSQL
         # may execute some attribute queries during a relation evaluation)
-        return super unless my_future && my_future.to_sql == sql
+        return super if !my_future || to_sql(my_future.query, my_future.binds.try(:dup)) != sql
 
         # return fulfilled result, if exists, to load the relation
         return my_future.result if my_future.fulfilled?
 
-        futures = Futures::Future.all
-        futures_sql = futures.map(&:to_sql).join(';')
+        futures = Futures::FutureRegistry.all
+        future_arels = futures.map(&:query)
+        future_binds = futures.map(&:binds)
         name = "#{name} (fetching Futures)"
 
-        result = future_execute(futures_sql, name)
+        result = future_execute(future_arels, future_binds, name)
 
         futures.each do |future|
           future.fulfill(build_active_record_result(result))

data/lib/active_record/connection_adapters/future_enabled_mysql2_adapter.rb

@@ -36,7 +36,8 @@ module ActiveRecord
         @connection.respond_to?(:store_result)
       end
 
-      def future_execute(sql, name)
+      def future_execute(arels, binds, name)
+        sql = arels.zip(binds).map { |arel, bind| to_sql(arel, bind.try(:dup)) }.join(';')
         execute(sql, name)
       end
 

data/lib/active_record/connection_adapters/future_enabled_postgresql_adapter.rb

@@ -27,13 +27,27 @@ module ActiveRecord
     class FutureEnabledPostgreSQLAdapter < PostgreSQLAdapter
       include FutureEnabled
 
-      def future_execute(sql, name)
-        log(sql, name) do
-          # Clear the queue
-          @connection.get_last_result
-          @connection.send_query(sql)
-          @connection.block
-          @connection.get_result
+      def future_execute(arels, binds, name)
+        sql = arels.zip(binds).map { |arel, bind| to_sql(arel, bind.try(:dup)) }.join(';')
+        binds = binds.flatten(1).compact
+
+        log(sql, name, binds) do
+
+          if binds.empty?
+            # Clear the queue
+            @connection.get_last_result
+            @connection.send_query(sql)
+            @connection.block
+            @connection.get_result
+          else
+            # Clear the queue
+            @connection.get_last_result
+            @connection.send_query(sql, binds.map { |col, val|
+              type_cast(val, col)
+            })
+            @connection.block
+            @connection.get_result
+          end
         end
       end
 

data/lib/active_record/futures.rb

@@ -1,35 +1,23 @@
 module ActiveRecord
   module Futures
-    include QueryRecording
 
-    def self.original_calculation_methods
-      [:count, :average, :minimum, :maximum, :sum, :calculate]
+    def self.futurize(method)
+      "future_#{method}"
     end
 
-    def self.future_calculation_methods
-      original_calculation_methods.map { |name| "future_#{name}" }
-    end
+    include QueryRecording
+    include FinderMethods
+    include CalculationMethods
 
     def future
-      FutureRelation.new(self)
+      FutureArray.new(record_future(:to_a))
     end
 
-    def future_pluck(*args, &block)
-      exec = lambda { pluck(*args, &block) }
-      query = record_query(&exec)
-      FutureCalculationArray.new(self, query, exec)
-    end
-
-    method_table = Hash[future_calculation_methods.zip(original_calculation_methods)]
-
-    # define a "future_" method for each calculation method
-    #
-    method_table.each do |future_method, method|
-      define_method(future_method) do |*args, &block|
-        exec = lambda { send(method, *args, &block) }
-        query = record_query(&exec)
-        FutureCalculationValue.new(self, query, exec)
-      end
+  private
+    def record_future(method, *args, &block)
+      exec = -> { send(method, *args, &block) }
+      query, binds = record_query(&exec)
+      Future.new(self, query, binds, exec)
     end
   end
 end

data/lib/active_record/futures/calculation_methods.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Futures
+    module CalculationMethods
+      extend ActiveSupport::Concern
+
+      def future_pluck(*args, &block)
+        FutureArray.new(record_future(:pluck, *args, &block))
+      end
+
+      included do
+        methods = original_calculation_methods - [:pluck]
+
+        # define a "future_" method for each calculation method
+        #
+        methods.each do |method|
+          define_method(futurize(method)) do |*args, &block|
+            FutureValue.new(record_future(method, *args, &block))
+          end
+        end
+      end
+
+      module ClassMethods
+
+        def original_calculation_methods
+          [:count, :average, :minimum, :maximum, :sum, :calculate, :pluck]
+        end
+
+        def future_calculation_methods
+          original_calculation_methods.map { |method| futurize(method) }
+        end
+      end
+    end
+  end
+end

data/lib/active_record/futures/delegation.rb

@@ -2,8 +2,8 @@ module ActiveRecord
   module Futures
     module Delegation
       delegate :future, to: :scoped
-      delegate :future_pluck, to: :scoped
       delegate *Futures.future_calculation_methods, to: :scoped
+      delegate *Futures.future_finder_methods, to: :scoped
     end
   end
 end

data/lib/active_record/futures/finder_methods.rb

@@ -0,0 +1,59 @@
+module ActiveRecord
+  module Futures
+    module FinderMethods
+      extend ActiveSupport::Concern
+
+      def future_find(*args, &block)
+        exec = -> { find(*args, &block) }
+        query, binds = record_query do
+          begin
+            exec.call
+          rescue RecordNotFound
+            nil
+          end
+        end
+
+        args = args.dup
+        args.extract_options!
+
+        # Only expect an array if a block is given, finding :all,
+        # finding by id passing an array or passing multiple ids
+        expects_array = block_given? || args.first == :all ||
+                        args.first.kind_of?(Array) || args.size > 1
+
+        future = Future.new(self, query, binds, exec)
+        if expects_array
+          FutureArray.new(future)
+        else
+          FutureValue.new(future)
+        end
+      end
+
+      def future_all(*args, &block)
+        FutureArray.new(record_future(:all, *args, &block))
+      end
+
+      included do
+        methods = original_finder_methods - [:find, :all]
+
+        # define a "future_" method for each finder method
+        #
+        methods.each do |method|
+          define_method(futurize(method)) do |*args, &block|
+            FutureValue.new(record_future(method, *args, &block))
+          end
+        end
+      end
+
+      module ClassMethods
+        def original_finder_methods
+          [:find, :first, :last, :exists?, :all]
+        end
+
+        def future_finder_methods
+          original_finder_methods.map { |method| futurize(method) }
+        end
+      end
+    end
+  end
+end

data/lib/active_record/futures/future.rb

@@ -1,54 +1,15 @@
 module ActiveRecord
   module Futures
     class Future
-      class << self
-        def futures
-          Thread.current["#{self.name}_futures"] ||= []
-        end
-        alias_method :all, :futures
-
-        def current
-          Thread.current["#{self.name}_current"]
-        end
-
-        def current=(future)
-          Thread.current["#{self.name}_current"] = future
-        end
-
-        def clear
-          all.clear
-        end
-
-        def register(future)
-          self.futures << future
-        end
-
-        def flush
-          self.futures.each(&:load)
-          clear
-        end
-
-      private
-        def fetch_with(method)
-          define_method(method) do
-            # Flush all the futures upon first attempt to exec a future
-            Future.flush unless executed?
-            execute
-          end
+      attr_reader :result, :relation, :query, :binds, :execution
+      private :relation, :execution
 
-          define_method(:inspect) do
-            send(method).inspect
-          end
-        end
-      end
-
-
-      attr_reader :result, :relation
-      private :relation
-
-      def initialize(relation)
+      def initialize(relation, query, binds, execution)
         @relation = relation
-        Future.register(self)
+        @query = query
+        @binds = binds
+        @execution = execution
+        FutureRegistry.register(self)
       end
 
       def fulfill(result)
@@ -64,29 +25,32 @@ module ActiveRecord
         # This allows to fallback to normal query execution in futures
         # when the adapter does not support futures.
         return unless connection_supports_futures?
-        Future.current = self
-        execute
-        Future.current = nil
+        FutureRegistry.current = self
+        execute(false)
+        FutureRegistry.current = nil
       end
 
-      def to_sql
-      end
-      undef_method :to_sql
+      def execute(flush = true)
+        # Flush all the futures upon first attempt to exec a future
+        FutureRegistry.flush if flush && !executed?
 
-    private
-      def execute
+        unless executed?
+          @value = execution.call
+          @executed = true
+        end
+
+        @value
       end
-      undef_method :execute
 
       def executed?
+        @executed
       end
-      undef_method :executed?
 
+    private
       def connection_supports_futures?
         conn = relation.connection
         conn.respond_to?(:supports_futures?) && conn.supports_futures?
       end
-
     end
   end
 end

data/lib/active_record/futures/future_array.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Futures
+    class FutureArray
+      attr_reader :future_execution
+      private :future_execution
+
+      delegate :to_xml, :to_yaml, :length, :collect, :map, :each,
+               :all?, :include?, :to_ary, to: :to_a
+
+      def initialize(future_execution)
+        @future_execution = future_execution
+      end
+
+      def to_a
+        future_execution.execute
+      end
+
+      def inspect
+        to_a
+      end
+    end
+  end
+end

data/lib/active_record/futures/future_registry.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module Futures
+    module FutureRegistry
+      def futures
+        Thread.current["#{self.name}_futures"] ||= []
+      end
+      alias_method :all, :futures
+
+      def current
+        Thread.current["#{self.name}_current"]
+      end
+
+      def current=(future)
+        Thread.current["#{self.name}_current"] = future
+      end
+
+      def clear
+        all.clear
+      end
+
+      def register(future)
+        self.futures << future
+      end
+
+      def flush
+        self.futures.each(&:load)
+        clear
+      end
+
+      extend self
+    end
+  end
+end