Initial test case for deferred preloading; Log per query Socket and Thread identifier

Author: methodmissing

lib/active_record/connection_adapters/mysqlplus_adapter.rb

@@ -36,7 +36,7 @@ def execute(sql, name = nil, skip_logging = false) #:nodoc:
         if skip_logging
           @connection.c_async_query( sql )
         else  
-          log("(Socket #{socket.to_s}) #{sql}",name) do 
+          log("(Socket #{socket.to_s}, Thread #{Thread.current.object_id.to_s}) #{sql}",name) do 
             @connection.c_async_query( sql )
           end
         end  

lib/active_record/connection_adapters/mysqlplus_adapter/deferrable/macro.rb

@@ -7,7 +7,7 @@ class << self
         def install!
           ActiveRecord::Base.send :extend, SingletonMethods      
           ar_eigenclass::VALID_FIND_OPTIONS << :defer
-          alias_deferred :find, :find_by_sql, :preload_associations
+          alias_deferred :find, :find_by_sql, :preload_associations, :find_every
         end
 
         private
@@ -35,13 +35,26 @@ module SingletonMethods
       # connection.
       # 
       # ....
-      # Record.find(:first, :include => [:other. :another], :defer => true)
+      # Record.find(:first, :include => [:other, :another], :defer => true)
       # .... 
       #
       def preload_associations_with_defer(records, associations, preload_options={})
         if preload_options.key?(:defer)
-          ActiveRecord::Deferrable::Result.new do
-            preload_associations_without_defer(records, associations, preload_options)
+          records = [records].flatten.compact.uniq
+          return if records.empty?
+          case associations
+          when Array then associations.each {|association| ActiveRecord::Deferrable::Result.new{ preload_associations(records, association, preload_options) } }
+          when Symbol, String then ActiveRecord::Deferrable::Result.new{ preload_one_association(records, associations.to_sym, preload_options) }
+          when Hash then
+            associations.each do |parent, child|
+              raise "parent must be an association name" unless parent.is_a?(String) || parent.is_a?(Symbol)
+              preload_associations(records, parent, preload_options)
+              reflection = reflections[parent]
+              parents = records.map {|record| record.send(reflection.name)}.flatten.compact
+              unless parents.empty?
+                parents.first.class.preload_associations(parents, child)
+              end
+            end
           end
         else
           preload_associations_without_defer(records, associations, preload_options)
@@ -91,6 +104,22 @@ def with_deferred_scope( &block ) #:nodoc:
           with_scope( { :find => { :defer => true } }, :merge, &block )
         end
 
+        def find_every_with_defer(options) #:nodoc:
+          include_associations = merge_includes(scope(:find, :include), options[:include])
+          if include_associations.any? && references_eager_loaded_tables?(options)
+            records = find_with_associations(options)
+          else
+            records = find_by_sql(construct_finder_sql(options))
+            if include_associations.any?
+              preload_associations(records, include_associations, options)
+            end
+          end
+
+          records.each { |record| record.readonly! } if options[:readonly]
+
+          records
+        end
+
     end
 
   end

lib/active_record/connection_adapters/mysqlplus_adapter/deferrable/result.rb

@@ -16,6 +16,7 @@ def initialize( &deferrable )
       #
       def defer!( deferrable )
         @result = Thread.new( deferrable ) do |deferrable|
+          puts '*'
           begin
             deferrable.call 
           rescue => exception

test/deferrable/macro_test.rb

@@ -0,0 +1,24 @@
+require "#{File.dirname(__FILE__)}/../helper"
+Mysqlplus::Test.prepare!
+
+class MacroTest < ActiveSupport::TestCase
+
+  def test_should_be_able_to_find_records_in_a_background_thread
+    ActiveRecord::Base.connection_pool.expects(:release_connection).twice 
+    assert_equal MysqlUser.find(:first, :defer => true), MysqlUser.find(:first) 
+    assert_instance_of MysqlUser, MysqlUser.find(:first, :defer => true)
+  end
+
+  def test_should_be_able_to_find_records_by_sql_background_thread
+    ActiveRecord::Base.connection_pool.expects(:release_connection).once    
+    assert_equal MysqlUser.find_by_sql("SELECT * FROM mysql.user WHERE User = 'root'", true), MysqlUser.find(:all, :conditions => ['user.User = ?', 'root'])
+  end
+
+  def test_should_be_able_to_preload_related_records_on_multiple_connections
+    ActiveRecord::Base.connection_pool.expects(:release_connection).twice
+    assert_instance_of MysqlUser, MysqlUser.find( :first, :defer => true, :include => [:mysql_user_info])
+  end
+    
+end
+
+Thread.list.each{|t| t.join unless t == Thread.main }

test/deferrable_test.rb

@@ -1,6 +1,8 @@
 require 'rubygems'
 require 'active_support'
+require 'active_support/test_case'
 require 'activerecord'
+
 ActiveRecord.load_all!
 
 module Mysqlplus
@@ -32,7 +34,7 @@ def active_record_test_files
       end
 
       def test_files
-        glob( "#{File.dirname(__FILE__)}/*_test.rb" )
+        glob( "#{File.dirname(__FILE__)}/**/*_test.rb" )
       end
 
       private

test/helper.rb

@@ -1,3 +1,6 @@
 class MysqlUser < ActiveRecord::Base  
   set_table_name 'user'
+  set_primary_key :User
+  
+  has_one :mysql_user_info, :class_name => 'MysqlUserInfo', :foreign_key => :User
 end

test/models/mysql_user.rb

@@ -0,0 +1,6 @@
+class MysqlUserInfo < ActiveRecord::Base  
+  set_table_name 'user_info'
+  set_primary_key :User
+  
+  belongs_to :mysql_user, :class_name => 'MysqlUser', :foreign_key => :User
+end