seamless_database_pool 1.0.5 → 1.0.6

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'rake/rdoctask'
+require 'yaml'
 
 desc 'Default: run unit tests.'
 task :default => :test
@@ -11,17 +12,61 @@ begin
   Spec::Rake::SpecTask.new(:test) do |t|
     t.spec_files = FileList.new('spec/**/*_spec.rb')
   end
+  
+  namespace :test do
+    desc "Run all tests including for all database adapters"
+    task :all do
+      save_val = ENV['TEST_ADAPTERS']
+      begin
+        ENV['TEST_ADAPTERS'] = YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.join(' ')
+        Rake::Task["test"].execute
+      ensure
+        ENV['TEST_ADAPTERS'] = save_val
+      end
+    end
+    
+    desc "Test all database adapters defined in database.yml or just the one specified in TEST_ADAPTERS"
+    task :adapters do
+      save_val = ENV['TEST_ADAPTERS']
+      begin
+        ENV['TEST_ADAPTERS'] ||= YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.join(' ')
+        Rake::Task["test:adapters:specified"].execute
+      ensure
+        ENV['TEST_ADAPTERS'] = save_val
+      end
+    end
+    
+    namespace :adapters do
+      desc "Internal task to run database adapter tests"
+      Spec::Rake::SpecTask.new(:specified) do |t|
+        t.spec_files = FileList.new('spec/connection_adapters_spec.rb')
+      end
+      
+      YAML.load_file(File.expand_path("../spec/database.yml", __FILE__)).keys.each do |adapter_name|
+        desc "Test the #{adapter_name} database adapter"
+        task adapter_name do
+          save_val = ENV['TEST_ADAPTERS']
+          begin
+            ENV['TEST_ADAPTERS'] = adapter_name
+            Rake::Task["test:adapters:specified"].execute
+          ensure
+            ENV['TEST_ADAPTERS'] = save_val
+          end
+        end
+      end
+    end
+  end
 rescue LoadError
-  tast :test do
-    STDERR.puts "You must have rspec >= 1.2.9 to run the tests"
+  task :test do
+    STDERR.puts "You must have rspec >= 1.3.0 to run the tests"
   end
 end
 
 desc 'Generate documentation for seamless_database_pool.'
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.options << '--title' << 'Seamless Database Pool' << '--line-numbers' << '--inline-source' << '--main' << 'README'
-  rdoc.rdoc_files.include('README')
+  rdoc.options << '--title' << 'Seamless Database Pool' << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
@@ -33,6 +78,9 @@ begin
     gem.email = "brian@embellishedvisions.com"
     gem.homepage = "http://github.com/bdurand/seamless_database_pool"
     gem.authors = ["Brian Durand"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile"].to_a
+    gem.has_rdoc = true
+    gem.extra_rdoc_files = ["README.rdoc"]
   
     gem.add_dependency('activerecord', '>= 2.2.2')
     gem.add_development_dependency('rspec', '>= 1.2.9')

data/lib/active_record/connection_adapters/seamless_database_pool_adapter.rb

@@ -1,73 +1,83 @@
 module ActiveRecord
   class Base
-    def self.seamless_database_pool_connection (config)
-      pool_weights = {}
-      
-      default_config = {:pool_weight => 1}.merge(config.merge(:adapter => config[:pool_adapter]))
-      default_config.delete(:master)
-      default_config.delete(:read_pool)
-      default_config.delete(:pool_adapter)
-      
-      master_config = default_config.merge(config[:master].symbolize_keys)
-      establish_adapter(master_config[:adapter])
-      master_connection = send("#{master_config[:adapter]}_connection".to_sym, master_config)
-      master_connection.class.send(:include, SeamlessDatabasePool::ConnectTimeout) unless master_connection.class.include?(SeamlessDatabasePool::ConnectTimeout)
-      master_connection.connect_timeout = master_config[:connect_timeout]
-      pool_weights[master_connection] = master_config[:pool_weight].to_i if master_config[:pool_weight].to_i > 0
-      
-      read_connections = []
-      config[:read_pool].each do |read_config|
-        read_config = default_config.merge(read_config.symbolize_keys)
-        read_config[:pool_weight] = read_config[:pool_weight].to_i
-        if read_config[:pool_weight] > 0
-          establish_adapter(read_config[:adapter])
-          conn = send("#{read_config[:adapter]}_connection".to_sym, read_config)
-          conn.class.send(:include, SeamlessDatabasePool::ConnectTimeout) unless conn.class.include?(SeamlessDatabasePool::ConnectTimeout)
-          conn.connect_timeout = read_config[:connect_timeout]
-          read_connections << conn
-          pool_weights[conn] = read_config[:pool_weight]
+    class << self
+      def seamless_database_pool_connection (config)
+        pool_weights = {}
+      
+        config = config.with_indifferent_access
+        default_config = {:pool_weight => 1}.merge(config.merge(:adapter => config[:pool_adapter])).with_indifferent_access
+        default_config.delete(:master)
+        default_config.delete(:read_pool)
+        default_config.delete(:pool_adapter)
+      
+        master_config = default_config.merge(config[:master]).with_indifferent_access
+        establish_adapter(master_config[:adapter])
+        master_connection = send("#{master_config[:adapter]}_connection".to_sym, master_config)
+        master_connection.class.send(:include, SeamlessDatabasePool::ConnectTimeout) unless master_connection.class.include?(SeamlessDatabasePool::ConnectTimeout)
+        master_connection.connect_timeout = master_config[:connect_timeout]
+        pool_weights[master_connection] = master_config[:pool_weight].to_i if master_config[:pool_weight].to_i > 0
+      
+        read_connections = []
+        config[:read_pool].each do |read_config|
+          read_config = default_config.merge(read_config).with_indifferent_access
+          read_config[:pool_weight] = read_config[:pool_weight].to_i
+          if read_config[:pool_weight] > 0
+            establish_adapter(read_config[:adapter])
+            conn = send("#{read_config[:adapter]}_connection".to_sym, read_config)
+            conn.class.send(:include, SeamlessDatabasePool::ConnectTimeout) unless conn.class.include?(SeamlessDatabasePool::ConnectTimeout)
+            conn.connect_timeout = read_config[:connect_timeout]
+            read_connections << conn
+            pool_weights[conn] = read_config[:pool_weight]
+          end
+        end if config[:read_pool]
+      
+        @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
-      end if config[:read_pool]
       
-      @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
+        return klass.new(nil, logger, master_connection, read_connections, pool_weights)
       end
-      
-      return klass.new(nil, logger, master_connection, read_connections, pool_weights)
-    end
     
-    def self.establish_adapter (adapter)
-      unless adapter then raise AdapterNotSpecified, "database configuration does not specify adapter" end
-      raise AdapterNotFound, "database pool must specify adapters" if adapter == 'seamless_database_pool'
-      
-      begin
-        require 'rubygems'
-        gem "activerecord-#{adapter}-adapter"
-        require "active_record/connection_adapters/#{adapter}_adapter"
-      rescue LoadError
+      def establish_adapter (adapter)
+        raise AdapterNotSpecified.new("database configuration does not specify adapter") unless adapter
+        raise AdapterNotFound.new("database pool must specify adapters") if adapter == 'seamless_database_pool'
+      
         begin
+          require 'rubygems'
+          gem "activerecord-#{adapter}-adapter"
           require "active_record/connection_adapters/#{adapter}_adapter"
         rescue LoadError
-          raise "Please install the #{adapter} adapter: `gem install activerecord-#{adapter}-adapter` (#{$!})"
+          begin
+            require "active_record/connection_adapters/#{adapter}_adapter"
+          rescue LoadError
+            raise "Please install the #{adapter} adapter: `gem install activerecord-#{adapter}-adapter` (#{$!})"
+          end
         end
-      end
 
-      adapter_method = "#{adapter}_connection"
-      if !respond_to?(adapter_method)
-        raise AdapterNotFound, "database configuration specifies nonexistent #{adapter} adapter"
+        adapter_method = "#{adapter}_connection"
+        if !respond_to?(adapter_method)
+          raise AdapterNotFound, "database configuration specifies nonexistent #{adapter} adapter"
+        end
       end
     end
-
-    # Force reload to use the master connection since it's probably being called for a reason.
-    def reload_with_seamless_database_pool (options = nil)
-      SeamlessDatabasePool.use_master_connection do
-        reload_without_seamless_database_pool(options)
+    
+    module SeamlessDatabasePoolBehavior
+      def self.included (base)
+        base.alias_method_chain(:reload, :seamless_database_pool)
+      end
+      
+      # Force reload to use the master connection since it's probably being called for a reason.
+      def reload_with_seamless_database_pool (*args)
+        SeamlessDatabasePool.use_master_connection do
+          reload_without_seamless_database_pool(*args)
+        end
       end
     end
-    alias_method_chain(:reload, :seamless_database_pool)
+    
+    include(SeamlessDatabasePoolBehavior) unless include?(SeamlessDatabasePoolBehavior)
   end
 
   module ConnectionAdapters
@@ -78,25 +88,45 @@ 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]
-        master_methods = master_connection.public_methods(false) + master_connection.protected_methods(false) + master_connection.private_methods(false)
+        read_only_methods = [:select_one, :select_all, :select_value, :select_values, :select, :select_rows, :execute, :tables, :columns]
+        master_methods = []
+        master_connection_classes = [AbstractAdapter, Quoting, DatabaseStatements, SchemaStatements]
+        master_connection_classes << DatabaseLimits if const_defined?(:DatabaseLimits)
+        master_connection_class = master_connection.class
+        while ![Object, AbstractAdapter].include?(master_connection_class) do
+          master_connection_classes << master_connection_class
+          master_connection_class = master_connection_class.superclass
+        end
+        master_connection_classes.each do |connection_class|
+          master_methods.concat(connection_class.public_instance_methods(false))
+          master_methods.concat(connection_class.protected_instance_methods(false))
+          #master_methods.concat(connection_class.private_instance_methods(false))
+        end
+        master_methods.uniq!
         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.delete(:transaction)
 
         klass = Class.new(self)
         master_methods.each do |method_name|
-          klass.class_eval(%Q(
+          klass.class_eval %Q(
             def #{method_name}(*args, &block)
-              begin
-                proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
-              rescue DatabaseConnectionError => e
-                raise e.wrapped_exception
+              use_master_connection do
+                return proxy_connection_method(master_connection, :#{method_name}, :master, *args, &block)
               end
             end
-          ))
+          )
+        end
+        
+        read_only_methods.each do |method_name|
+          klass.class_eval %Q(
+            def #{method_name}(*args, &block)
+              connection = @use_master ? master_connection : current_read_connection
+              proxy_connection_method(connection, :#{method_name}, :read, *args, &block)
+            end
+          )
         end
+        klass.send :protected, :select
         
         return klass
       end
@@ -115,7 +145,7 @@ module ActiveRecord
       end
       
       def adapter_name #:nodoc:
-        'Seamless Database Pool'
+        'Seamless_Database_Pool'
       end
       
       # Returns an array of the master connection and the read pool connections
@@ -174,37 +204,6 @@ module ActiveRecord
         return SeamlessDatabasePool.read_only_connection(self)
       end
       
-      def transaction(start_db_transaction = true)
-        use_master_connection do
-          master_connection.transaction(start_db_transaction) do
-            yield if block_given?
-          end
-        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 execute (*args)
-        proxy_connection_method(current_read_connection, :execute, :read, *args)
-      end
-      
-      def select_rows(*args)
-        proxy_connection_method(current_read_connection, :select_rows, :read, *args)
-      end
-      
       def using_master_connection?
         !!@use_master
       end
@@ -221,7 +220,6 @@ module ActiveRecord
       end
       
       class DatabaseConnectionError < StandardError
-        attr_accessor :wrapped_exception
       end
       
       # This simple class puts an expire time on an array of connections. It is used so the a connection
@@ -237,7 +235,7 @@ module ActiveRecord
         end
         
         def expired?
-          @expires < Time.now if @expires
+          @expires <= Time.now if @expires
         end
         
         def reconnect!
@@ -253,7 +251,7 @@ module ActiveRecord
         available = @available_read_connections.last
         if available.expired?
           begin
-            available.reconnect!
+            available.reconnect!# unless available.active?
           rescue
             # Couldn't reconnect so try again in a little bit
             available.expires = 30.seconds.from_now
@@ -266,6 +264,15 @@ module ActiveRecord
         end
       end
       
+      def reset_available_read_connections
+        @available_read_connections.slice!(1, @available_read_connections.length)
+        @available_read_connections.first.connections.each do |connection|
+          unless connection.active?
+            connection.reconnect! rescue nil
+          end
+        end
+      end
+      
       # Temporarily remove a connection from the read pool.
       def suppress_read_connection (conn, expire)
         available = available_read_connections
@@ -276,47 +283,31 @@ module ActiveRecord
         
         if connections.empty?
           # No connections available so we might as well try them all again
-          @available_read_connections.slice!(1, @available_read_connections.length)
+          reset_available_read_connections
         else
           # Available connections will now not include the suppressed connection for a while
           @available_read_connections.push(AvailableConnections.new(connections, conn, expire.seconds.from_now))
         end
       end
       
-      protected
+      private
       
-      def select (*args)
-        connection = current_read_connection
+      def proxy_connection_method (connection, method, proxy_type, *args, &block)
         begin
-          proxy_connection_method(connection, :select, :read, *args)
-        rescue DatabaseConnectionError => e
-          unless using_master_connection?
-            # Try again with a different connection if needed unless it could have a side effect
+          connection.send(method, *args, &block)
+        rescue => e
+          # If the statement was a read statement and it wasn't forced against the master connection
+          # try to reconnect if the connection is dead and then re-run the statement.
+          if proxy_type == :read and !using_master_connection?
             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, *args)
+            proxy_connection_method(connection, method, :retry, *args, &block)
           else
-            raise e.wrapped_exception
-          end
-        end
-      end
-      
-      private
-      
-      def proxy_connection_method (connection, method, proxy_type, *args, &block)
-        begin
-          connection.send(method, *args, &block)
-        rescue => e
-          unless proxy_type == :retry or connection.active?
-            connection.reconnect! rescue nil
-            connection_error = DatabaseConnectionError.new
-            connection_error.wrapped_exception = e
-            raise connection_error
+            raise e
           end
-          raise e
         end
       end
       

data/lib/seamless_database_pool/arel_compiler.rb

@@ -0,0 +1,27 @@
+module Arel
+  module SqlCompiler
+    # Hook into arel to use the compiler used by the master connection.
+    class Seamless_Database_PoolCompiler < GenericCompiler
+      def self.new (relation)
+        @compiler_classes ||= {}
+        master_adapter = relation.engine.connection.master_connection.adapter_name
+        compiler_class = @compiler_classes[master_adapter]
+        unless compiler_class
+          begin
+            require "arel/engines/sql/compilers/#{master_adapter.downcase}_compiler"
+          rescue LoadError
+            begin
+              # try to load an externally defined compiler, in case this adapter has defined the compiler on its own.
+              require "#{master_adapter.downcase}/arel_compiler"
+            rescue LoadError
+              raise "#{master_adapter} is not supported by Arel."
+            end
+          end
+          compiler_class = Arel::SqlCompiler.const_get("#{master_adapter}Compiler")
+          @compiler_classes[master_adapter] = compiler_class
+        end
+        compiler_class.new(relation)
+      end
+    end
+  end
+end

data/lib/seamless_database_pool.rb

@@ -2,6 +2,7 @@ require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'connect_tim
 require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'connection_statistics')
 require File.join(File.dirname(__FILE__), 'seamless_database_pool', 'controller_filter')
 require File.join(File.dirname(__FILE__), 'active_record', 'connection_adapters', 'seamless_database_pool_adapter')
+$LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
 
 # This module allows setting the read pool connection type. Generally you will use one of
 #
@@ -17,97 +18,99 @@ module SeamlessDatabasePool
 
   READ_CONNECTION_METHODS = [:master, :persistent, :random]
 
-  # Call this method to use a random connection from the read pool for every select statement.
-  # This method is good if your replication is very fast. Otherwise there is a chance you could
-  # get inconsistent results from one request to the next. This can result in mysterious failures
-  # if your code selects a value in one statement and then uses in another statement. You can wind
-  # up trying to use a value from one server that hasn't been replicated to another one yet.
-  # This method is best if you have few processes which generate a lot of queries and you have
-  # fast replication.
-  def self.use_random_read_connection
-    if block_given?
-      set_read_only_connection_type(:random){yield}
-    else
-      Thread.current[:read_only_connection] = :random
+  class << self
+    # Call this method to use a random connection from the read pool for every select statement.
+    # This method is good if your replication is very fast. Otherwise there is a chance you could
+    # get inconsistent results from one request to the next. This can result in mysterious failures
+    # if your code selects a value in one statement and then uses in another statement. You can wind
+    # up trying to use a value from one server that hasn't been replicated to another one yet.
+    # This method is best if you have few processes which generate a lot of queries and you have
+    # fast replication.
+    def use_random_read_connection
+      if block_given?
+        set_read_only_connection_type(:random){yield}
+      else
+        Thread.current[:read_only_connection] = :random
+      end
     end
-  end
   
-  # Call this method to pick a random connection from the read pool and use it for all subsequent
-  # select statements. This provides consistency from one select statement to the next. This
-  # method should always be called with a block otherwise you can end up with an imbalanced read
-  # pool. This method is best if you have lots of processes which have a relatively few select
-  # statements or a slow replication mechanism. Generally this is the best method to use for web
-  # applications.
-  def self.use_persistent_read_connection
-    if block_given?
-      set_read_only_connection_type(:persistent){yield}
-    else
-      Thread.current[:read_only_connection] = {}
+    # Call this method to pick a random connection from the read pool and use it for all subsequent
+    # select statements. This provides consistency from one select statement to the next. This
+    # method should always be called with a block otherwise you can end up with an imbalanced read
+    # pool. This method is best if you have lots of processes which have a relatively few select
+    # statements or a slow replication mechanism. Generally this is the best method to use for web
+    # applications.
+    def use_persistent_read_connection
+      if block_given?
+        set_read_only_connection_type(:persistent){yield}
+      else
+        Thread.current[:read_only_connection] = {}
+      end
     end
-  end
   
-  # Call this method to use the master connection for all subsequent select statements. This
-  # method is most useful when you are doing lots of updates since it guarantees consistency
-  # if you do a select immediately after an update or insert.
-  #
-  # The master connection will also be used for selects inside any transaction blocks. It will
-  # also be used if you pass :readonly => false to any ActiveRecord.find method.
-  def self.use_master_connection
-    if block_given?
-      set_read_only_connection_type(:master){yield}
-    else
-      Thread.current[:read_only_connection] = :master
+    # Call this method to use the master connection for all subsequent select statements. This
+    # method is most useful when you are doing lots of updates since it guarantees consistency
+    # if you do a select immediately after an update or insert.
+    #
+    # The master connection will also be used for selects inside any transaction blocks. It will
+    # also be used if you pass :readonly => false to any ActiveRecord.find method.
+    def use_master_connection
+      if block_given?
+        set_read_only_connection_type(:master){yield}
+      else
+        Thread.current[:read_only_connection] = :master
+      end
     end
-  end
   
-  # Set the read only connection type to either :master, :random, or :persistent.
-  def self.set_read_only_connection_type (connection_type)
-    saved_connection = Thread.current[:read_only_connection]
-    retval = nil
-    begin
-      connection_type = {} if connection_type == :persistent
-      Thread.current[:read_only_connection] = connection_type
-      retval = yield if block_given?
-    ensure
-      Thread.current[:read_only_connection] = saved_connection
+    # Set the read only connection type to either :master, :random, or :persistent.
+    def set_read_only_connection_type (connection_type)
+      saved_connection = Thread.current[:read_only_connection]
+      retval = nil
+      begin
+        connection_type = {} if connection_type == :persistent
+        Thread.current[:read_only_connection] = connection_type
+        retval = yield if block_given?
+      ensure
+        Thread.current[:read_only_connection] = saved_connection
+      end
+      return retval
     end
-    return retval
-  end
   
-  # Get the read only connection type currently in use. Will be one of :master, :random, or :persistent.
-  def self.read_only_connection_type (default = :master)
-    connection_type = Thread.current[:read_only_connection] || default
-    connection_type = :persistent if connection_type.kind_of?(Hash)
-    return connection_type
-  end
+    # Get the read only connection type currently in use. Will be one of :master, :random, or :persistent.
+    def read_only_connection_type (default = :master)
+      connection_type = Thread.current[:read_only_connection] || default
+      connection_type = :persistent if connection_type.kind_of?(Hash)
+      return connection_type
+    end
   
-  # Get a read only connection from a connection pool.
-  def self.read_only_connection (pool_connection)
-    return pool_connection.master_connection if pool_connection.using_master_connection?
-    connection_type = Thread.current[:read_only_connection]
+    # Get a read only connection from a connection pool.
+    def read_only_connection (pool_connection)
+      return pool_connection.master_connection if pool_connection.using_master_connection?
+      connection_type = Thread.current[:read_only_connection]
     
-    if connection_type.kind_of?(Hash)
-      connection = connection_type[pool_connection]
-      unless connection
-        connection = pool_connection.random_read_connection
-        connection_type[pool_connection] = connection
+      if connection_type.kind_of?(Hash)
+        connection = connection_type[pool_connection]
+        unless connection
+          connection = pool_connection.random_read_connection
+          connection_type[pool_connection] = connection
+        end
+        return connection
+      elsif connection_type == :random
+        return pool_connection.random_read_connection
+      else
+        return pool_connection.master_connection
       end
-      return connection
-    elsif connection_type == :random
-      return pool_connection.random_read_connection
-    else
-      return pool_connection.master_connection
     end
-  end
   
-  # This method is provided as a way to change the persistent connection when it fails and a new one is substituted.
-  def self.set_persistent_read_connection (pool_connection, read_connection)
-    connection_type = Thread.current[:read_only_connection]
-    connection_type[pool_connection] = read_connection if connection_type.kind_of?(Hash)
-  end
+    # This method is provided as a way to change the persistent connection when it fails and a new one is substituted.
+    def set_persistent_read_connection (pool_connection, read_connection)
+      connection_type = Thread.current[:read_only_connection]
+      connection_type[pool_connection] = read_connection if connection_type.kind_of?(Hash)
+    end
   
-  def self.clear_read_only_connection
-    Thread.current[:read_only_connection] = nil
+    def clear_read_only_connection
+      Thread.current[:read_only_connection] = nil
+    end
   end
   
 end