seamless_database_pool 1.0.2 → 1.0.3

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 spec = Gem::Specification.new do |s| 
   s.name = "seamless_database_pool"
-  s.version = "1.0.2"
+  s.version = "1.0.3"
   s.author = "Brian Durand"
   s.platform = Gem::Platform::RUBY
   s.summary = "Support for master/slave database clusters in ActiveRecord"

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -31,9 +31,14 @@ module ActiveRecord
         end
       end if config[:read_pool]
       
-
-      klass = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
-      klass.new(nil, logger, master_connection, read_connections, pool_weights)
+      @seamless_database_pool_classes ||= {}
+      klass = @seamless_database_pool_classes[master_connection.class]
+      unless klass
+        klass = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(master_connection)
+        @seamless_database_pool_classes[master_connection.class] = klass
+      end
+      
+      return klass.new(nil, logger, master_connection, read_connections, pool_weights)
     end
     
     def self.establish_adapter (adapter)
@@ -66,18 +71,6 @@ module ActiveRecord
     end
     alias_method_chain(:reload, :seamless_database_pool)
   end
-  
-  module Associations
-    class AssociationProxy
-      # Force reload to use the master connection since it's probably being called for a reason.
-      def reload_with_seamless_database_pool
-        SeamlessDatabasePool.use_master_connection do
-          reload_without_seamless_database_pool
-        end
-      end
-      alias_method_chain(:reload, :seamless_database_pool)
-    end
-  end
 
   module ConnectionAdapters
     class SeamlessDatabasePoolAdapter < AbstractAdapter
@@ -87,13 +80,11 @@ module ActiveRecord
       # Create an anonymous class that extends this one and proxies methods to the pool connections.
       def self.adapter_class (master_connection)
         # Define methods to proxy to the appropriate pool
-        read_only_methods = [:select_one, :select_all, :select_value, :select_values, :select_rows, :select]
-        connection_methods = [:adapter_name, :active?, :reconnect!, :disconnect!, :reset!, :verify!, :reset_runtime]
+        read_only_methods = [:select_one, :select_all, :select_value, :select_values, :select_rows]
         master_methods = master_connection.public_methods(false) + master_connection.protected_methods(false) + master_connection.private_methods(false)
-        master_methods -= public_methods(false) + protected_methods(false) + private_methods(false)
+        master_methods -= public_instance_methods(false) + protected_instance_methods(false) + private_instance_methods(false)
         master_methods = master_methods.collect{|m| m.to_sym}
         master_methods -= read_only_methods
-        master_methods -= connection_methods
         master_methods.delete(:transaction)
 
         klass = Class.new(self)
@@ -108,29 +99,6 @@ module ActiveRecord
             end
           ))
         end
-
-        read_only_methods.each do |method_name|
-          klass.class_eval(%Q(
-            def #{method_name}(*args, &block)
-              connection = current_read_connection
-              begin
-                proxy_connection_method(connection, :#{method_name}, :read, *args, &block)
-              rescue DatabaseConnectionError => e
-                unless block or using_master_connection?
-                  # Try again with a different connection if needed unless it could have a side effect
-                  unless connection.active?
-                    suppress_read_connection(connection, 30)
-                    connection = current_read_connection
-                    SeamlessDatabasePool.set_persistent_read_connection(self, connection)
-                  end
-                  proxy_connection_method(connection, :#{method_name}, :retry, *args, &block)
-                else
-                  raise e.wrapped_exception
-                end
-              end
-            end
-          ))
-        end
         
         return klass
       end
@@ -162,6 +130,10 @@ module ActiveRecord
         return @weighted_read_connections.select{|conn| conn == connection}.size
       end
       
+      def requires_reloading?
+        false
+      end
+      
       def active?
         active = true
         all_connections.each{|conn| active &= conn.active?}
@@ -212,6 +184,21 @@ module ActiveRecord
         end
       end
 
+      # Returns the last auto-generated ID from the affected table.
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        master_connection.insert(sql, name, pk, id_value, sequence_name)
+      end
+
+      # Executes the update statement and returns the number of rows affected.
+      def update(sql, name = nil)
+        master_connection.update(sql, name)
+      end
+
+      # Executes the delete statement and returns the number of rows affected.
+      def delete(sql, name = nil)
+        master_connection.delete(sql, name)
+      end
+      
       def using_master_connection?
         !!@use_master
       end
@@ -290,6 +277,27 @@ module ActiveRecord
         end
       end
       
+      protected
+      
+      def select (sql, name = nil)
+        connection = current_read_connection
+        begin
+          proxy_connection_method(connection, :select, :read, *[sql, name])
+        rescue DatabaseConnectionError => e
+          unless using_master_connection?
+            # Try again with a different connection if needed unless it could have a side effect
+            unless connection.active?
+              suppress_read_connection(connection, 30)
+              connection = current_read_connection
+              SeamlessDatabasePool.set_persistent_read_connection(self, connection)
+            end
+            proxy_connection_method(connection, :select, :retry, *[sql, name])
+          else
+            raise e.wrapped_exception
+          end
+        end
+      end
+      
       private
       
       def proxy_connection_method (connection, method, proxy_type, *args, &block)

data/spec/seamless_database_pool_adapter_spec.rb

@@ -118,16 +118,16 @@ describe "SeamlessDatabasePoolAdapter" do
     connection_class = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter.adapter_class(@master_connection)
     connection = connection_class.new(nil, mock(:logger), @master_connection, [@read_connection_1], {@read_connection_1 => 1})
     @master_connection.should_receive(:transaction).with(true).and_yield
-    @master_connection.should_receive(:select_one).with('Transaction SQL')
-    @read_connection_1.should_receive(:select_one).with('SQL 1')
-    @read_connection_1.should_receive(:select_one).with('SQL 2')
+    @master_connection.should_receive(:select).with('Transaction SQL', nil)
+    @read_connection_1.should_receive(:select).with('SQL 1', nil)
+    @read_connection_1.should_receive(:select).with('SQL 2', nil)
     
     SeamlessDatabasePool.use_persistent_read_connection do
-      connection.select_one('SQL 1')
+      connection.send(:select, 'SQL 1', nil)
       connection.transaction do
-        connection.select_one('Transaction SQL')
+        connection.send(:select, 'Transaction SQL', nil)
       end
-      connection.select_one('SQL 2')
+      connection.send(:select, 'SQL 2', nil)
     end
   end
 
@@ -135,58 +135,23 @@ describe "SeamlessDatabasePoolAdapter" do
   
   it "should proxy select methods to a read connection" do
     @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @read_connection_1.should_receive(:select_one).with('SQL').and_return(:retval)
-    @pool_connection.select_one('SQL').should == :retval
-  end
-  
-  it "should proxy select methods to a read connection" do
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @read_connection_1.should_receive(:select_all).with('SQL').and_return(:retval)
-    @pool_connection.select_all('SQL').should == :retval
-  end
-  
-  it "should proxy select methods to a read connection" do
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @read_connection_1.should_receive(:select_value).with('SQL').and_return(:retval)
-    @pool_connection.select_value('SQL').should == :retval
-  end
-  
-  it "should proxy select methods to a read connection" do
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @read_connection_1.should_receive(:select_values).with('SQL').and_return(:retval)
-    @pool_connection.select_values('SQL').should == :retval
-  end
-  
-  it "should proxy select methods to a read connection" do
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @read_connection_1.should_receive(:select_rows).with('SQL').and_return(:retval)
-    @pool_connection.select_rows('SQL').should == :retval
-  end
-  
-  it "should proxy select methods to a read connection" do
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @read_connection_1.should_receive(:select).with('SQL', 'name').and_return(:retval)
-    @pool_connection.send(:select, 'SQL', 'name').should == :retval
+    @read_connection_1.should_receive(:select).with('SQL', nil).and_return(:retval)
+    @pool_connection.send(:select, 'SQL').should == :retval
   end
   
   # Master connection methods
   
-  it "should proxy quote method to the master connection" do
-    @master_connection.should_receive(:insert).with('SQL').and_return(:retval)
+  it "should proxy insert method to the master connection" do
+    @master_connection.should_receive(:insert).with('SQL', nil, nil, nil, nil).and_return(:retval)
     @pool_connection.insert('SQL').should == :retval
   end
   
-  it "should proxy quote method to the master connection" do
-    @master_connection.should_receive(:update).with('SQL').and_return(:retval)
+  it "should proxy update method to the master connection" do
+    @master_connection.should_receive(:update).with('SQL', nil).and_return(:retval)
     @pool_connection.update('SQL').should == :retval
   end
   
-  it "should proxy quote method to the master connection" do
-    @master_connection.should_receive(:execute).with('SQL').and_return(:retval)
-    @pool_connection.execute('SQL').should == :retval
-  end
-  
-  it "should proxy quote method to the master connection" do
+  it "should proxy columns method to the master connection" do
     @master_connection.should_receive(:columns).with(:table).and_return(:retval)
     @pool_connection.columns(:table).should == :retval
   end
@@ -282,48 +247,40 @@ describe "SeamlessDatabasePoolAdapter" do
     connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
     connection_error.wrapped_exception = StandardError.new("Error")
     @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select_value, :read, 'SQL').and_raise(connection_error)
+    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :read, 'SQL', nil).and_raise(connection_error)
     @read_connection_1.should_receive(:active?).and_return(true)
     @pool_connection.should_not_receive(:suppress_read_connection)
     SeamlessDatabasePool.should_not_receive(:set_persistent_read_connection)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select_value, :retry, 'SQL').and_return(:results)
-    @pool_connection.select_value('SQL').should == :results
+    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :retry, 'SQL', nil).and_return(:results)
+    @pool_connection.send(:select, 'SQL').should == :results
   end
   
   it "should not try to execute a read statement again after a connection error if the master connection must be used" do
     connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
     connection_error.wrapped_exception = StandardError.new("Error")
     @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select_value, :read, 'SQL').and_raise(connection_error)
+    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :read, 'SQL', nil).and_raise(connection_error)
     @pool_connection.use_master_connection do
-      lambda{@pool_connection.select_value('SQL')}.should raise_error("Error")
+      lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("Error")
     end
   end
   
-  it "should not try to execute a read statement again after a connection error if there is a block" do
-    connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
-    connection_error.wrapped_exception = StandardError.new("Error")
-    @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select_value, :read, 'SQL').and_raise(connection_error)
-    lambda{@pool_connection.select_value('SQL'){}}.should raise_error("Error")
-  end
-  
   it "should not try to execute a read statement again after a non-connection error" do
     @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select_value, :read, 'SQL').and_raise("SQL Error")
-    lambda{@pool_connection.select_value('SQL')}.should raise_error("SQL Error")
+    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :read, 'SQL', nil).and_raise("SQL Error")
+    lambda{@pool_connection.send(:select, 'SQL')}.should raise_error("SQL Error")
   end
   
   it "should use a different connection on a retry if the original connection could not be reconnected" do
     connection_error = ActiveRecord::ConnectionAdapters::SeamlessDatabasePoolAdapter::DatabaseConnectionError.new
     connection_error.wrapped_exception = StandardError.new("Error")
     @pool_connection.should_receive(:current_read_connection).and_return(@read_connection_1, @read_connection_2)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select_value, :read, 'SQL').and_raise(connection_error)
+    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_1, :select, :read, 'SQL', nil).and_raise(connection_error)
     @read_connection_1.should_receive(:active?).and_return(false)
     @pool_connection.should_receive(:suppress_read_connection).with(@read_connection_1, 30)
     SeamlessDatabasePool.should_receive(:set_persistent_read_connection).with(@pool_connection, @read_connection_2)
-    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_2, :select_value, :retry, 'SQL').and_return(:results)
-    @pool_connection.select_value('SQL').should == :results
+    @pool_connection.should_receive(:proxy_connection_method).with(@read_connection_2, :select, :retry, 'SQL', nil).and_return(:results)
+    @pool_connection.send(:select, 'SQL').should == :results
   end
   
   it "should keep track of read connections that can't be reconnected for a set period" do
@@ -427,11 +384,4 @@ describe "Reload extensions" do
     @record.should_receive(:reload_without_seamless_database_pool).with(:options)
     @record.reload(:options)
   end
-  
-  it "should force the master connection on reload of an association" do
-    association = @record.seamless_database_pool_test_things
-    SeamlessDatabasePool.should_receive(:use_master_connection).and_yield
-    association.should_receive(:reload_without_seamless_database_pool)
-    @record.seamless_database_pool_test_things(true)
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: seamless_database_pool
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors: 
 - Brian Durand
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-06 00:00:00 -05:00
+date: 2009-05-26 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -22,10 +22,7 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
-- lib/active_record
-- lib/active_record/connection_adapters
 - lib/active_record/connection_adapters/seamless_database_pool_adapter.rb
-- lib/seamless_database_pool
 - lib/seamless_database_pool/connect_timeout.rb
 - lib/seamless_database_pool/connection_statistics.rb
 - lib/seamless_database_pool/controller_filter.rb
@@ -36,6 +33,8 @@ files:
 - README
 has_rdoc: true
 homepage: http://seamlessdbpool.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
@@ -61,9 +60,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - rspec 1.0.8 or higher is needed to run the tests
 rubyforge_project: seamlessdbpool
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Support for master/slave database clusters in ActiveRecord
 test_files: 
 - spec/connection_statistics_spec.rb