WIP

Author: byroot

activerecord/lib/active_record/associations/association.rb

@@ -34,7 +34,7 @@ module Associations
     # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association # :nodoc:
       attr_accessor :owner
-      attr_reader :target, :reflection, :disable_joins
+      attr_reader :reflection, :disable_joins
 
       delegate :options, to: :reflection
 
@@ -50,6 +50,13 @@ def initialize(owner, reflection)
         @skip_strict_loading = nil
       end
 
+      def target
+        if @target&.is_a?(Promise)
+          @target = @target.value
+        end
+        @target
+      end
+
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
@@ -172,14 +179,21 @@ def extensions
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        @target = find_target if (@stale_state && stale_target?) || find_target?
+        @target = find_target(async: false) if (@stale_state && stale_target?) || find_target?
 
         loaded! unless loaded?
         target
       rescue ActiveRecord::RecordNotFound
         reset
       end
 
+      def async_load_target
+        @target = find_target(async: true) if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        target
+      end
+
       # We can't dump @reflection and @through_reflection since it contains the scope proc
       def marshal_dump
         ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
@@ -217,7 +231,7 @@ def ensure_klass_exists!
           klass
         end
 
-        def find_target
+        def find_target(async: false)
           if violates_strict_loading?
             Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
@@ -232,7 +246,7 @@ def find_target
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
           klass.with_connection do |c|
-            sc.execute(binds, c) do |record|
+            sc.execute(binds, c, async: async) do |record|
               set_inverse_instance(record)
               if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
                 record.strict_loading!

activerecord/lib/active_record/associations/has_many_through_association.rb

@@ -216,7 +216,8 @@ def delete_through_records(records)
           end
         end
 
-        def find_target
+        def find_target(async: false)
+          raise NotImplementedError if async
           return [] unless target_reflection_has_associated_record?
           return scope.to_a if disable_joins
           super

activerecord/lib/active_record/associations/singular_association.rb

@@ -18,6 +18,7 @@ def reader
       def reset
         super
         @target = nil
+        @future_target = nil
       end
 
       # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
@@ -43,11 +44,12 @@ def scope_for_create
           super.except!(*Array(klass.primary_key))
         end
 
-        def find_target
+        def find_target(async: false)
           if disable_joins
+            raise NotImplementedError if async
             scope.first
           else
-            super.first
+            super.then(&:first)
           end
         end
 

activerecord/lib/active_record/core.rb

@@ -431,7 +431,7 @@ def cached_find_by(keys, values)
           }
 
           begin
-            statement.execute(values.flatten, lease_connection, allow_retry: true).first
+            statement.execute(values.flatten, lease_connection, allow_retry: true).then(&:first)
           rescue TypeError
             raise ActiveRecord::StatementInvalid
           end

activerecord/lib/active_record/querying.rb

@@ -52,8 +52,8 @@ def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
     end
 
     # Same as <tt>#find_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
-    def async_find_by_sql(sql, binds = [], preparable: nil, &block)
-      _query_by_sql(sql, binds, preparable: preparable, async: true).then do |result|
+    def async_find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+      _query_by_sql(sql, binds, preparable: preparable, allow_retry: allow_retry, async: true).then do |result|
         _load_from_sql(result, &block)
       end
     end

activerecord/lib/active_record/statement_cache.rb

@@ -142,14 +142,18 @@ def initialize(query_builder, bind_map, klass)
       @klass = klass
     end
 
-    def execute(params, connection, allow_retry: false, &block)
+    def execute(params, connection, allow_retry: false, async: false, &block)
       bind_values = bind_map.bind params
 
       sql = query_builder.sql_for bind_values, connection
 
-      klass.find_by_sql(sql, bind_values, preparable: true, allow_retry: allow_retry, &block)
+      if async
+        klass.async_find_by_sql(sql, bind_values, preparable: true, allow_retry: allow_retry, &block)
+      else
+        klass.find_by_sql(sql, bind_values, preparable: true, allow_retry: allow_retry, &block)
+      end
     rescue ::RangeError
-      []
+      async ? Promise.wrap([]) : []
     end
 
     def self.unsupported_value?(value)

activerecord/test/cases/associations/belongs_to_associations_test.rb

@@ -1841,3 +1841,21 @@ def test_destroy_linked_models
     assert_not Author.exists?(author.id)
   end
 end
+
+class AsyncBelongsToAssociationsTest < ActiveRecord::TestCase
+  fixtures :companies
+
+  self.use_transactional_tests = false
+
+  def test_temp_async_load_belongs_to
+    # TODO: proper test?
+    client = Client.find(3)
+    first_firm = companies(:first_firm)
+    assert_queries_match(/LIMIT|ROWNUM <=|FETCH FIRST/) do
+      client.association(:firm).async_load_target
+
+      assert_equal first_firm, client.firm
+      assert_equal first_firm.name, client.firm.name
+    end
+  end
+end