ibm_db 5.6.1 → 5.7.0

data/test/cases/query_cache_test.rb

@@ -35,24 +35,74 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def teardown
-    Task.connection.clear_query_cache
-    ActiveRecord::Base.connection.disable_query_cache!
+    Task.connection_pool.clear_query_cache
+    ActiveRecord::Base.connection_pool.disable_query_cache!
     super
   end
 
+  def test_execute_clear_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.execute("SELECT 1")
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 0, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
+  def test_exec_query_clear_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.exec_query("SELECT 1")
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 0, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
   def test_writes_should_always_clear_cache
     assert_cache :off
 
     mw = middleware { |env|
       Post.first
-      query_cache = ActiveRecord::Base.connection.query_cache
-      assert_equal 1, query_cache.length, query_cache.keys
-      Post.connection.uncached do
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.uncached do
         # should clear the cache
         Post.create!(title: "a new post", body: "and a body")
       end
-      query_cache = ActiveRecord::Base.connection.query_cache
-      assert_equal 0, query_cache.length, query_cache.keys
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 0, query_cache.size, query_cache.inspect
+    }
+    mw.call({})
+
+    assert_cache :off
+  end
+
+  def test_reads_dont_clear_disabled_cache
+    assert_cache :off
+
+    mw = middleware { |env|
+      Post.first
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
+      Post.lease_connection.uncached do
+        Post.count # shouldn't clear the cache
+      end
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
     }
     mw.call({})
 
@@ -65,8 +115,8 @@ class QueryCacheTest < ActiveRecord::TestCase
     mw = middleware { |env|
       Task.find 1
       Task.find 1
-      query_cache = ActiveRecord::Base.connection.query_cache
-      assert_equal 1, query_cache.length, query_cache.keys
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
       raise "lol borked"
     }
     assert_raises(RuntimeError) { mw.call({}) }
@@ -74,120 +124,96 @@ class QueryCacheTest < ActiveRecord::TestCase
     assert_cache :off
   end
 
-  def test_query_cache_is_applied_to_legacy_connections_in_all_handlers
-    old_value = ActiveRecord::Base.legacy_connection_handling
-    ActiveRecord::Base.legacy_connection_handling = true
-
-    ActiveRecord::Base.connection_handlers = {
-      writing: ActiveRecord::Base.default_connection_handler,
-      reading: ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-    }
-
+  def test_query_cache_is_applied_to_all_connections
     ActiveRecord::Base.connected_to(role: :reading) do
       db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
       ActiveRecord::Base.establish_connection(db_config)
     end
 
     mw = middleware { |env|
-      reading_handler = ActiveRecord::Base.connection_handlers[:reading]
-      ro_pool = reading_handler.connection_pool_list
-      ro_conn = ro_pool.first.connection
-      assert_predicate ActiveRecord::Base.connection, :query_cache_enabled
-      assert_predicate ro_conn, :query_cache_enabled
+      ActiveRecord::Base.connection_handler.connection_pool_list(:all).each do |pool|
+        assert_predicate pool.lease_connection, :query_cache_enabled
+      end
     }
 
     mw.call({})
   ensure
-    clean_up_legacy_connection_handlers
-    ActiveRecord::Base.legacy_connection_handling = old_value
+    clean_up_connection_handler
   end
 
-  def test_query_cache_is_applied_to_all_connections
+  def test_cache_is_not_applied_when_config_is_false
     ActiveRecord::Base.connected_to(role: :reading) do
       db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
-      ActiveRecord::Base.establish_connection(db_config)
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: false))
     end
 
-    mw = middleware { |env|
-      rw_conn = ActiveRecord::Base.connection_handler.connection_pool_list(:writing).first.connection
-      assert_predicate rw_conn, :query_cache_enabled
-
-      ro_conn = ActiveRecord::Base.connection_handler.connection_pool_list(:reading).first.connection
-      assert_predicate ActiveRecord::Base.connection, :query_cache_enabled
-      assert_predicate ro_conn, :query_cache_enabled
-    }
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :off
+        assert_nil ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
+      end
+    end
 
     mw.call({})
   ensure
     clean_up_connection_handler
   end
 
-  if Process.respond_to?(:fork) && !in_memory_db?
-    def test_query_cache_with_multiple_handlers_and_forked_processes_legacy_handling
-      old_value = ActiveRecord::Base.legacy_connection_handling
-      ActiveRecord::Base.legacy_connection_handling = true
-      ActiveRecord::Base.connection_handlers = {
-        writing: ActiveRecord::Base.default_connection_handler,
-        reading: ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-      }
+  def test_cache_is_applied_when_config_is_string
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: "unlimited"))
+    end
 
+    mw = middleware do |env|
       ActiveRecord::Base.connected_to(role: :reading) do
-        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
-        ActiveRecord::Base.establish_connection(db_config)
+        assert_cache :clean
+        assert_nil ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
       end
+    end
 
-      rd, wr = IO.pipe
-      rd.binmode
-      wr.binmode
-
-      pid = fork {
-        rd.close
-        status = 0
-
-        middleware { |env|
-          begin
-            assert_cache :clean
-
-            # first request dirties cache
-            ActiveRecord::Base.connected_to(role: :reading) do
-              Post.first
-              assert_cache :dirty
-            end
-
-            # should clear the cache
-            Post.create!(title: "a new post", body: "and a body")
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
 
-            # fails because cache is still dirty
-            ActiveRecord::Base.connected_to(role: :reading) do
-              assert_cache :clean
-              Post.first
-            end
+  def test_cache_is_applied_when_config_is_integer
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: 42))
+    end
 
-          rescue Minitest::Assertion => e
-            wr.write Marshal.dump e
-            status = 1
-          end
-        }.call({})
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :clean
+        assert_equal 42, ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
+      end
+    end
 
-        wr.close
-        exit!(status)
-      }
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
 
-      wr.close
+  def test_cache_is_applied_when_config_is_nil
+    ActiveRecord::Base.connected_to(role: :reading) do
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      ActiveRecord::Base.establish_connection(db_config.configuration_hash.merge(query_cache: nil))
+    end
 
-      Process.waitpid pid
-      if !$?.success?
-        raise Marshal.load(rd.read)
-      else
-        assert_predicate $?, :success?
+    mw = middleware do |env|
+      ActiveRecord::Base.connected_to(role: :reading) do
+        assert_cache :clean
+        assert_equal ActiveRecord::ConnectionAdapters::QueryCache::DEFAULT_SIZE, ActiveRecord::Base.lease_connection.pool.query_cache.instance_variable_get(:@max_size)
       end
-
-      rd.close
-    ensure
-      clean_up_legacy_connection_handlers
-      ActiveRecord::Base.legacy_connection_handling = old_value
     end
 
+    mw.call({})
+  ensure
+    clean_up_connection_handler
+  end
+
+  if Process.respond_to?(:fork) && !in_memory_db?
     def test_query_cache_with_forked_processes
       ActiveRecord::Base.connected_to(role: :reading) do
         db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
@@ -257,14 +283,14 @@ class QueryCacheTest < ActiveRecord::TestCase
             t.datetime :ending
           end
         end
-        ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_path, ["tasks"], {}, ActiveRecord::Base)
+        ActiveRecord::FixtureSet.create_fixtures(self.class.fixture_paths, ["tasks"], {}, ActiveRecord::Base)
       end
 
       ActiveRecord::Base.connection_pool.connections.each do |conn|
         assert_cache :off, conn
       end
 
-      assert_not_predicate ActiveRecord::Base.connection, :nil?
+      assert_not_predicate ActiveRecord::Base.lease_connection, :nil?
       assert_cache :off
 
       middleware {
@@ -273,8 +299,8 @@ class QueryCacheTest < ActiveRecord::TestCase
         Task.find 1
         assert_cache :dirty
 
-        thread_1_connection = ActiveRecord::Base.connection
-        ActiveRecord::Base.clear_active_connections!
+        thread_1_connection = ActiveRecord::Base.lease_connection
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
         assert_cache :off, thread_1_connection
 
         started = Concurrent::Event.new
@@ -282,7 +308,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
         thread_2_connection = nil
         thread = Thread.new {
-          thread_2_connection = ActiveRecord::Base.connection
+          thread_2_connection = ActiveRecord::Base.lease_connection
 
           assert_equal thread_2_connection, thread_1_connection
           assert_cache :off
@@ -296,13 +322,13 @@ class QueryCacheTest < ActiveRecord::TestCase
             started.set
             checked.wait
 
-            ActiveRecord::Base.clear_active_connections!
+            ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
           }.call({})
         }
 
         started.wait
 
-        thread_1_connection = ActiveRecord::Base.connection
+        thread_1_connection = ActiveRecord::Base.lease_connection
         assert_not_equal thread_1_connection, thread_2_connection
         assert_cache :dirty, thread_2_connection
         checked.set
@@ -333,8 +359,8 @@ class QueryCacheTest < ActiveRecord::TestCase
     mw = middleware { |env|
       Task.find 1
       Task.find 1
-      query_cache = ActiveRecord::Base.connection.query_cache
-      assert_equal 1, query_cache.length, query_cache.keys
+      query_cache = ActiveRecord::Base.connection_pool.query_cache
+      assert_equal 1, query_cache.size, query_cache.inspect
       [200, {}, nil]
     }
     mw.call({})
@@ -354,30 +380,30 @@ class QueryCacheTest < ActiveRecord::TestCase
     post = Post.first
     Post.cache do
       query = post.categories.select(:post_id)
-      assert Post.connection.select_all(query).is_a?(ActiveRecord::Result)
+      assert Post.lease_connection.select_all(query).is_a?(ActiveRecord::Result)
     end
   end
 
   def test_find_queries
-    assert_queries(2) { Task.find(1); Task.find(1) }
+    assert_queries_count(2) { Task.find(1); Task.find(1) }
   end
 
   def test_find_queries_with_cache
     Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
   end
 
   def test_find_queries_with_cache_multi_record
     Task.cache do
-      assert_queries(2) { Task.find(1); Task.find(1); Task.find(2) }
+      assert_queries_count(2) { Task.find(1); Task.find(1); Task.find(2) }
     end
   end
 
   def test_find_queries_with_multi_cache_blocks
     Task.cache do
       Task.cache do
-        assert_queries(2) { Task.find(1); Task.find(2) }
+        assert_queries_count(2) { Task.find(1); Task.find(2) }
       end
       assert_no_queries { Task.find(1); Task.find(1); Task.find(2) }
     end
@@ -385,52 +411,52 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_count_queries_with_cache
     Task.cache do
-      assert_queries(1) { Task.count; Task.count }
+      assert_queries_count(1) { Task.count; Task.count }
     end
   end
 
   def test_exists_queries_with_cache
     Post.cache do
-      assert_queries(1) { Post.exists?; Post.exists? }
+      assert_queries_count(1) { Post.exists?; Post.exists? }
     end
   end
 
   def test_select_all_with_cache
     Post.cache do
-      assert_queries(1) do
-        2.times { Post.connection.select_all(Post.all) }
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_all(Post.all) }
       end
     end
   end
 
   def test_select_one_with_cache
     Post.cache do
-      assert_queries(1) do
-        2.times { Post.connection.select_one(Post.all) }
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_one(Post.all) }
       end
     end
   end
 
   def test_select_value_with_cache
     Post.cache do
-      assert_queries(1) do
-        2.times { Post.connection.select_value(Post.all) }
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_value(Post.all) }
       end
     end
   end
 
   def test_select_values_with_cache
     Post.cache do
-      assert_queries(1) do
-        2.times { Post.connection.select_values(Post.all) }
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_values(Post.all) }
       end
     end
   end
 
   def test_select_rows_with_cache
     Post.cache do
-      assert_queries(1) do
-        2.times { Post.connection.select_rows(Post.all) }
+      assert_queries_count(1) do
+        2.times { Post.lease_connection.select_rows(Post.all) }
       end
     end
   end
@@ -450,15 +476,15 @@ class QueryCacheTest < ActiveRecord::TestCase
     logger = ShouldNotHaveExceptionsLogger.new
     subscriber = ActiveSupport::Notifications.subscribe "sql.active_record", logger
 
-    connection = ActiveRecord::Base.connection.dup
+    connection = ActiveRecord::Base.lease_connection.dup
 
     def connection.cache_notification_info(sql, name, binds)
       super.merge(neat: true)
     end
 
     connection.cache do
-      connection.select_all "select 1 from SYSIBM.DUAL"
-      connection.select_all "select 1 from SYSIBM.DUAL"
+      connection.select_all "select 1"
+      connection.select_all "select 1"
     end
 
     assert_equal true, logger.events.last.payload[:neat]
@@ -471,7 +497,7 @@ class QueryCacheTest < ActiveRecord::TestCase
     subscriber = ActiveSupport::Notifications.subscribe "sql.active_record", logger
 
     ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
 
     assert_not_predicate logger, :exception?
@@ -481,12 +507,14 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_query_cache_does_not_allow_sql_key_mutation
     subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |_, _, _, _, payload|
-      payload[:sql].downcase!
+      payload[:sql].downcase! if payload[:name] == "Task Load"
     end
 
-    assert_raises FrozenError do
-      ActiveRecord::Base.cache do
-        assert_queries(1) { Task.find(1); Task.find(1) }
+    ActiveRecord::Base.cache do
+      assert_queries_count(1) do
+        assert_raises FrozenError do
+          Task.find(1)
+        end
       end
     end
   ensure
@@ -495,17 +523,17 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_cache_is_flat
     Task.cache do
-      assert_queries(1) { Topic.find(1); Topic.find(1); }
+      assert_queries_count(1) { Topic.find(1); Topic.find(1) }
     end
 
     ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
   end
 
   def test_cache_does_not_wrap_results_in_arrays
     Task.cache do
-      assert_equal 2, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
+      assert_equal 2, Task.lease_connection.select_value("SELECT count(*) AS count_all FROM tasks")
     end
   end
 
@@ -513,7 +541,7 @@ class QueryCacheTest < ActiveRecord::TestCase
     task = Task.find 1
 
     Task.cache do
-      assert_queries(2) { task.lock!; task.lock! }
+      assert_queries_count(2) { task.lock!; task.lock! }
     end
   end
 
@@ -522,7 +550,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
     ActiveRecord::Base.configurations = {}
     Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1); Task.find(1) }
     end
   ensure
     ActiveRecord::Base.configurations = conf
@@ -530,23 +558,25 @@ class QueryCacheTest < ActiveRecord::TestCase
 
   def test_cache_is_available_when_using_a_not_connected_connection
     skip "In-Memory DB can't test for using a not connected connection" if in_memory_db?
-    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary").dup
-    db_config.owner_name = "test2"
-    ActiveRecord::Base.connection_handler.establish_connection(db_config)
+    db_config = ActiveRecord::Base.connection_db_config
+    original_connection = ActiveRecord::Base.remove_connection
+
+    ActiveRecord::Base.establish_connection(db_config)
     assert_not_predicate Task, :connected?
 
     Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
+      assert_queries_count(1) { Task.find(1) }
+      assert_no_queries { Task.find(1) }
     ensure
-      ActiveRecord::Base.connection_handler.remove_connection_pool(db_config.owner_name)
+      ActiveRecord::Base.establish_connection(original_connection)
     end
   end
 
   def test_query_cache_executes_new_queries_within_block
-    ActiveRecord::Base.connection.enable_query_cache!
+    ActiveRecord::Base.lease_connection.enable_query_cache!
 
     # Warm up the cache by running the query
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_equal 0, Post.where(title: "test").to_a.count
     end
 
@@ -555,16 +585,16 @@ class QueryCacheTest < ActiveRecord::TestCase
       assert_equal 0, Post.where(title: "test").to_a.count
     end
 
-    ActiveRecord::Base.connection.uncached do
+    ActiveRecord::Base.lease_connection.uncached do
       # Check that new query is executed, avoiding the cache
-      assert_queries(1) do
+      assert_queries_count(1) do
         assert_equal 0, Post.where(title: "test").to_a.count
       end
     end
   end
 
   def test_query_cache_doesnt_leak_cached_results_of_rolled_back_queries
-    ActiveRecord::Base.connection.enable_query_cache!
+    ActiveRecord::Base.lease_connection.enable_query_cache!
     post = Post.first
 
     Post.transaction do
@@ -575,7 +605,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
     assert_equal 0, Post.where(title: "rollback").to_a.count
 
-    ActiveRecord::Base.connection.uncached do
+    ActiveRecord::Base.lease_connection.uncached do
       assert_equal 0, Post.where(title: "rollback").to_a.count
     end
 
@@ -590,7 +620,7 @@ class QueryCacheTest < ActiveRecord::TestCase
 
     assert_equal 0, Post.where(title: "rollback").to_a.count
 
-    ActiveRecord::Base.connection.uncached do
+    ActiveRecord::Base.lease_connection.uncached do
       assert_equal 0, Post.where(title: "rollback").to_a.count
     end
   end
@@ -601,7 +631,7 @@ class QueryCacheTest < ActiveRecord::TestCase
       Task.find(1)
 
       # Preload the type cache again (so we don't have those queries issued during our assertions)
-      Task.connection.send(:reload_type_map)
+      Task.lease_connection.send(:reload_type_map) if Task.lease_connection.respond_to?(:reload_type_map, true)
 
       # Clear places where type information is cached
       Task.reset_column_information
@@ -615,150 +645,209 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 
   def test_query_cache_does_not_establish_connection_if_unconnected
-    ActiveRecord::Base.clear_active_connections!
-    assert_not ActiveRecord::Base.connection_handler.active_connections? # sanity check
+    ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+    assert_not ActiveRecord::Base.connection_handler.active_connections?(:all) # Double check they are cleared
 
     middleware {
-      assert_not ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in setup"
+      assert_not ActiveRecord::Base.connection_handler.active_connections?(:all), "QueryCache forced ActiveRecord::Base to establish a connection in setup"
     }.call({})
 
-    assert_not ActiveRecord::Base.connection_handler.active_connections?, "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
+    assert_not ActiveRecord::Base.connection_handler.active_connections?(:all), "QueryCache forced ActiveRecord::Base to establish a connection in cleanup"
   end
 
   def test_query_cache_is_enabled_on_connections_established_after_middleware_runs
-    ActiveRecord::Base.clear_active_connections!
-    assert_not ActiveRecord::Base.connection_handler.active_connections? # sanity check
+    ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+    assert_not ActiveRecord::Base.connection_handler.active_connections?(:all) # Double check they are cleared
 
     middleware {
-      assert_predicate ActiveRecord::Base.connection, :query_cache_enabled
+      assert_predicate ActiveRecord::Base.lease_connection, :query_cache_enabled
     }.call({})
-    assert_not_predicate ActiveRecord::Base.connection, :query_cache_enabled
+    assert_not_predicate ActiveRecord::Base.lease_connection, :query_cache_enabled
   end
 
   def test_query_caching_is_local_to_the_current_thread
-    ActiveRecord::Base.clear_active_connections!
+    ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
 
     middleware {
       assert ActiveRecord::Base.connection_pool.query_cache_enabled
-      assert ActiveRecord::Base.connection.query_cache_enabled
+      assert ActiveRecord::Base.connection_pool.query_cache_enabled
 
       Thread.new {
         assert_not ActiveRecord::Base.connection_pool.query_cache_enabled
-        assert_not ActiveRecord::Base.connection.query_cache_enabled
+        assert_not ActiveRecord::Base.connection_pool.query_cache_enabled
+
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
       }.join
     }.call({})
   end
 
   def test_query_cache_is_enabled_on_all_connection_pools
     middleware {
-      ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
+      ActiveRecord::Base.connection_handler.connection_pool_list(:all).each do |pool|
         assert pool.query_cache_enabled
-        assert pool.connection.query_cache_enabled
+        assert pool.with_connection(&:query_cache_enabled)
       end
     }.call({})
   end
 
-  def test_clear_query_cache_is_called_on_all_legacy_connections
-    skip "with in memory db, reading role won't be able to see database on writing role" if in_memory_db?
-    old_value = ActiveRecord::Base.legacy_connection_handling
-    ActiveRecord::Base.legacy_connection_handling = true
+  # with in memory db, reading role won't be able to see database on writing role
+  unless in_memory_db?
+    def test_clear_query_cache_is_called_on_all_connections
+      ActiveRecord::Base.connected_to(role: :reading) do
+        db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+        ActiveRecord::Base.establish_connection(db_config)
+      end
 
-    ActiveRecord::Base.connection_handlers = {
-      writing: ActiveRecord::Base.default_connection_handler,
-      reading: ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-    }
+      mw = middleware { |env|
+        ActiveRecord::Base.connected_to(role: :reading) do
+          @topic = Topic.first
+        end
 
-    ActiveRecord::Base.connected_to(role: :reading) do
-      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
-      ActiveRecord::Base.establish_connection(db_config)
-    end
+        assert @topic
 
-    mw = middleware { |env|
-      ActiveRecord::Base.connected_to(role: :reading) do
-        @topic = Topic.first
-      end
+        ActiveRecord::Base.connected_to(role: :writing) do
+          @topic.title = "Topic title"
+          @topic.save!
+        end
 
-      assert @topic
+        assert_equal "Topic title", @topic.title
 
-      ActiveRecord::Base.connected_to(role: :writing) do
-        @topic.title = "It doesn't have to be crazy at work"
-        @topic.save!
-      end
+        ActiveRecord::Base.connected_to(role: :reading) do
+          @topic = Topic.first
+          assert_equal "Topic title", @topic.title
+        end
+      }
+
+      mw.call({})
+    ensure
+      clean_up_connection_handler
+    end
+  end
 
-      assert_equal "It doesn't have to be crazy at work", @topic.title
+  test "query cache is enabled in threads with shared connection" do
+    ActiveRecord::Base.connection_pool.pin_connection!(ActiveSupport::IsolatedExecutionState.context)
 
-      ActiveRecord::Base.connected_to(role: :reading) do
-        @topic = Topic.first
-        assert_equal "It doesn't have to be crazy at work", @topic.title
+    begin
+      assert_cache :off
+      ActiveRecord::Base.lease_connection.enable_query_cache!
+      assert_cache :clean
+
+      main_thread_cache = ActiveRecord::Base.lease_connection.query_cache
+      assert_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+
+      thread_a = Thread.new do
+        middleware { |env|
+          assert_cache :clean
+
+          # In a background thread, the cache instance must stay consistent but be different from the main
+          # thread.
+          background_thread_cache = ActiveRecord::Base.lease_connection.query_cache
+          assert_same background_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+          assert_not_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+          [200, {}, nil]
+        }.call({})
       end
-    }
 
-    mw.call({})
-  ensure
-    unless in_memory_db?
-      clean_up_legacy_connection_handlers
-      ActiveRecord::Base.legacy_connection_handling = old_value
+      thread_a.join
+
+      assert_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
+    ensure
+      ActiveRecord::Base.connection_pool.unpin_connection!
+      assert_same main_thread_cache, ActiveRecord::Base.lease_connection.query_cache
     end
   end
 
-  def test_clear_query_cache_is_called_on_all_connections
-    skip "with in memory db, reading role won't be able to see database on writing role" if in_memory_db?
+  test "query cache is cleared for all thread when a connection is shared" do
+    ActiveRecord::Base.connection_pool.pin_connection!(ActiveSupport::IsolatedExecutionState.context)
 
-    ActiveRecord::Base.connected_to(role: :reading) do
-      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
-      ActiveRecord::Base.establish_connection(db_config)
-    end
+    begin
+      assert_cache :off
+      ActiveRecord::Base.lease_connection.enable_query_cache!
+      assert_cache :clean
 
-    mw = middleware { |env|
-      ActiveRecord::Base.connected_to(role: :reading) do
-        @topic = Topic.first
-      end
+      Post.first
+      assert_cache :dirty
+
+      thread_a = Thread.new do
+        middleware { |env|
+          assert_cache :clean
+
+          Post.first
+          assert_cache :dirty
 
-      assert @topic
+          Post.delete_all
 
-      ActiveRecord::Base.connected_to(role: :writing) do
-        @topic.title = "It doesn't have to be crazy at work"
-        @topic.save!
+          assert_cache :clean
+
+          [200, {}, nil]
+        }.call({})
       end
 
-      assert_equal "It doesn't have to be crazy at work", @topic.title
+      thread_a.join
 
-      ActiveRecord::Base.connected_to(role: :reading) do
-        @topic = Topic.first
-        assert_equal "It doesn't have to be crazy at work", @topic.title
+      assert_cache :clean
+    ensure
+      ActiveRecord::Base.connection_pool.unpin_connection!
+    end
+  end
+
+  def test_query_cache_uncached_dirties
+    mw = middleware { |env|
+      Post.first
+      assert_no_changes -> { ActiveRecord::Base.connection_pool.query_cache.size } do
+        Post.uncached(dirties: false) { Post.create!(title: "a new post", body: "and a body") }
       end
-    }
 
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.uncached(dirties: true) { Post.create!(title: "a new post", body: "and a body") }
+      end
+    }
     mw.call({})
-  ensure
-    clean_up_connection_handler
   end
 
-  test "query cache is enabled in threads with shared connection" do
-    ActiveRecord::Base.connection_pool.lock_thread = true
-
-    assert_cache :off
+  def test_query_cache_connection_uncached_dirties
+    mw = middleware { |env|
+      Post.first
+      assert_no_changes -> { ActiveRecord::Base.connection_pool.query_cache.size } do
+        Post.lease_connection.uncached(dirties: false) { Post.create!(title: "a new post", body: "and a body") }
+      end
 
-    thread_a = Thread.new do
-      middleware { |env|
-        assert_cache :clean
-        [200, {}, nil]
-      }.call({})
-    end
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.lease_connection.uncached(dirties: true) { Post.create!(title: "a new post", body: "and a body") }
+      end
+    }
+    mw.call({})
+  end
 
-    thread_a.join
+  def test_query_cache_uncached_dirties_disabled_with_nested_cache
+    mw = middleware { |env|
+      Post.first
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.uncached(dirties: false) do
+          Post.cache do
+            Post.create!(title: "a new post", body: "and a body")
+          end
+        end
+      end
 
-    ActiveRecord::Base.connection_pool.lock_thread = false
+      Post.first
+      assert_changes -> { ActiveRecord::Base.connection_pool.query_cache.size }, from: 1, to: 0 do
+        Post.lease_connection.uncached(dirties: false) do
+          Post.lease_connection.cache do
+            Post.create!(title: "a new post", body: "and a body")
+          end
+        end
+      end
+    }
+    mw.call({})
   end
 
   private
-    def with_temporary_connection_pool
-      pool_config = ActiveRecord::Base.connection_handler.send(:owner_to_pool_manager).fetch("ActiveRecord::Base").get_pool_config(ActiveRecord::Base.writing_role, :default)
+    def with_temporary_connection_pool(&block)
+      pool_config = ActiveRecord::Base.lease_connection.pool.pool_config
       new_pool = ActiveRecord::ConnectionAdapters::ConnectionPool.new(pool_config)
 
-      pool_config.stub(:pool, new_pool) do
-        yield
-      end
+      pool_config.stub(:pool, new_pool, &block)
     end
 
     def middleware(&app)
@@ -767,28 +856,135 @@ class QueryCacheTest < ActiveRecord::TestCase
       lambda { |env| executor.wrap { app.call(env) } }
     end
 
-    def assert_cache(state, connection = ActiveRecord::Base.connection)
+    def assert_cache(state, connection = ActiveRecord::Base.lease_connection)
       case state
       when :off
         assert_not connection.query_cache_enabled, "cache should be off"
-        assert connection.query_cache.empty?, "cache should be empty"
+        if connection.query_cache.nil?
+          assert_nil connection.query_cache
+        else
+          assert_predicate connection.query_cache, :empty?, "cache should be nil or empty"
+        end
       when :clean
         assert connection.query_cache_enabled, "cache should be on"
-        assert connection.query_cache.empty?, "cache should be empty"
+        assert_not_nil connection.query_cache
+        assert_predicate connection.query_cache, :empty?, "cache should be empty"
       when :dirty
         assert connection.query_cache_enabled, "cache should be on"
-        assert_not connection.query_cache.empty?, "cache should be dirty"
+        assert_not_nil connection.query_cache
+        assert_not_predicate connection.query_cache, :empty?, "cache should be dirty"
       else
         raise "unknown state"
       end
     end
 end
 
+class QueryCacheMutableParamTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class JsonObj < ActiveRecord::Base
+    self.table_name = "json_objs"
+
+    attribute :payload, :json
+  end
+
+  class ObjectFixedHash < Struct.new(:a, :b)
+    # this isn't very realistic, but it is the worst case and therefore a good
+    # case to test
+    def hash
+      1
+    end
+  end
+
+  def setup
+    ActiveRecord::Base.lease_connection.create_table("json_objs", force: true) do |t|
+      if current_adapter?(:PostgreSQLAdapter)
+        t.jsonb "payload"
+      else
+        t.json "payload"
+      end
+    end
+
+    ActiveRecord::Base.lease_connection.enable_query_cache!
+  end
+
+  def test_query_cache_handles_mutated_binds
+    JsonObj.create(payload: ObjectFixedHash.new({ a: 1 }))
+
+    search = ObjectFixedHash.new({ a: 1 })
+    JsonObj.where(payload: search).first # populate the cache
+
+    search.b = 2
+    assert_nil JsonObj.where(payload: search).first, "cache returned a false positive"
+  end
+
+  def teardown
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+    ActiveRecord::Base.lease_connection.drop_table("json_objs", if_exists: true)
+  end
+end
+
+class QuerySerializedParamTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  fixtures :topics
+
+  class YAMLObj < ActiveRecord::Base
+    self.table_name = "yaml_objs"
+
+    serialize :payload
+  end
+
+  def setup
+    @use_yaml_unsafe_load_was = ActiveRecord.use_yaml_unsafe_load
+
+    ActiveRecord::Base.lease_connection.create_table("yaml_objs", force: true) do |t|
+      t.text "payload"
+    end
+
+    ActiveRecord::Base.lease_connection.enable_query_cache!
+  end
+
+  def teardown
+    ActiveRecord::Base.lease_connection.disable_query_cache!
+    ActiveRecord::Base.lease_connection.drop_table("yaml_objs", if_exists: true)
+
+    ActiveRecord.use_yaml_unsafe_load = @use_yaml_unsafe_load_was
+  end
+
+  def test_query_serialized_active_record
+    skip if current_adapter?(:IBM_DBAdapter)
+
+    ActiveRecord.use_yaml_unsafe_load = true
+
+    topic = Topic.first
+    assert_not_nil topic
+
+    obj = YAMLObj.create!(payload: { topic: topic })
+
+    # This is absolutely terrible, no-one should ever do this
+    assert_equal obj, YAMLObj.where(payload: { topic: topic }).first
+
+    relation = YAMLObj.where(payload: { topic: topic })
+    topic.title = "New Title"
+    assert_equal obj, relation.first
+
+    assert_nil YAMLObj.where(payload: { topic: topic }).first
+  end
+
+  def test_query_serialized_string
+    ActiveRecord.use_yaml_unsafe_load = false
+
+    obj = YAMLObj.create!(payload: "payload")
+    assert_equal obj, YAMLObj.find_by!(payload: "payload")
+  end
+end
+
 class QueryCacheExpiryTest < ActiveRecord::TestCase
   fixtures :tasks, :posts, :categories, :categories_posts
 
   def teardown
-    Task.connection.clear_query_cache
+    Task.lease_connection.clear_query_cache
   end
 
   def test_cache_gets_cleared_after_migration
@@ -796,34 +992,44 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     Post.find(1)
 
     # change the column definition
-    Post.connection.change_column :posts, :title, :string, limit: 80
+    Post.lease_connection.change_column :posts, :title, :string, limit: 80
     assert_nothing_raised { Post.find(1) }
 
     # restore the old definition
-    Post.connection.change_column :posts, :title, :string
+    Post.lease_connection.change_column :posts, :title, :string
   end
 
   def test_find
-    assert_called(Task.connection, :clear_query_cache) do
-      assert_not Task.connection.query_cache_enabled
+    assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
+      assert_not Task.connection_pool.query_cache_enabled
       Task.cache do
-        assert Task.connection.query_cache_enabled
+        assert Task.connection_pool.query_cache_enabled
         Task.find(1)
 
         Task.uncached do
-          assert_not Task.connection.query_cache_enabled
+          assert_not Task.connection_pool.query_cache_enabled
           Task.find(1)
         end
 
-        assert Task.connection.query_cache_enabled
+        assert Task.connection_pool.query_cache_enabled
       end
-      assert_not Task.connection.query_cache_enabled
+      assert_not Task.connection_pool.query_cache_enabled
+    end
+  end
+
+  def test_enable_disable
+    assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
+      Task.cache { }
+    end
+
+    assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
+      Task.cache { Task.cache { } }
     end
   end
 
   def test_update
-    assert_called(Task.connection, :clear_query_cache, times: 2) do
-      Task.cache do
+    Task.cache do
+      assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
         task = Task.find(1)
         task.starting = Time.now.utc
         task.save!
@@ -832,16 +1038,16 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   end
 
   def test_destroy
-    assert_called(Task.connection, :clear_query_cache, times: 2) do
-      Task.cache do
+    Task.cache do
+      assert_called(Task.connection_pool.query_cache, :clear, times: 1) do
         Task.find(1).destroy
       end
     end
   end
 
   def test_insert
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache do
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
         Task.create!
       end
     end
@@ -850,40 +1056,46 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   def test_insert_all
     skip unless supports_insert_on_duplicate_skip?
 
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { Task.insert({ starting: Time.now }) }
-    end
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert({ starting: Time.now })
+      end
 
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { Task.insert_all([{ starting: Time.now }]) }
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert_all([{ starting: Time.now }])
+      end
     end
   end
 
   def test_insert_all_bang
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { Task.insert!({ starting: Time.now }) }
-    end
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert!({ starting: Time.now })
+      end
 
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { Task.insert_all!([{ starting: Time.now }]) }
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert_all!([{ starting: Time.now }])
+      end
     end
   end
 
   def test_upsert_all
     skip unless supports_insert_on_duplicate_update?
 
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { Task.upsert({ starting: Time.now }) }
-    end
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.upsert({ starting: Time.now })
+      end
 
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { Task.upsert_all([{ starting: Time.now }]) }
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.upsert_all([{ starting: Time.now }])
+      end
     end
   end
 
   def test_cache_is_expired_by_habtm_update
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      ActiveRecord::Base.cache do
+    ActiveRecord::Base.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
         c = Category.first
         p = Post.first
         p.categories << c
@@ -892,8 +1104,8 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   end
 
   def test_cache_is_expired_by_habtm_delete
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      ActiveRecord::Base.cache do
+    ActiveRecord::Base.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
         p = Post.find(1)
         assert_predicate p.categories, :any?
         p.categories.delete_all
@@ -901,11 +1113,47 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     end
   end
 
+  def test_query_cache_lru_eviction
+    store = ActiveRecord::ConnectionAdapters::QueryCache::Store.new(Concurrent::AtomicFixnum.new, 2)
+    store.enabled = true
+
+    connection = Post.lease_connection
+    old_store, connection.query_cache = connection.query_cache, store
+    begin
+      select1 = current_adapter?(:IBM_DBAdapter) ? "SELECT 1 FROM SYSIBM.SYSDUMMY1" : "SELECT 1"
+      select2 = current_adapter?(:IBM_DBAdapter) ? "SELECT 2 FROM SYSIBM.SYSDUMMY1" : "SELECT 2"
+      select3 = current_adapter?(:IBM_DBAdapter) ? "SELECT 3 FROM SYSIBM.SYSDUMMY1" : "SELECT 3"
+
+      Post.cache do
+        assert_queries_count(2) do
+          connection.select_all(select1)
+          connection.select_all(select2)
+          connection.select_all(select1)
+        end
+
+        assert_queries_count(1) do
+          connection.select_all(select3)
+          connection.select_all(select3)
+        end
+
+        assert_no_queries do
+          connection.select_all(select1)
+        end
+
+        assert_queries_count(1) do
+          connection.select_all(select2)
+        end
+      end
+    ensure
+      connection.query_cache = old_store
+    end
+  end
+
   test "threads use the same connection" do
-    @connection_1 = ActiveRecord::Base.connection.object_id
+    @connection_1 = ActiveRecord::Base.lease_connection.object_id
 
     thread_a = Thread.new do
-      @connection_2 = ActiveRecord::Base.connection.object_id
+      @connection_2 = ActiveRecord::Base.lease_connection.object_id
     end
 
     thread_a.join
@@ -913,3 +1161,50 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     assert_equal @connection_1, @connection_2
   end
 end
+
+class TransactionInCachedSqlActiveRecordPayloadTest < ActiveRecord::TestCase
+  # We need current_transaction to return the null transaction.
+  self.use_transactional_tests = false
+
+  def test_payload_without_open_transaction
+    asserted = false
+
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      if event.payload[:cached]
+        assert_nil event.payload.fetch(:transaction)
+        asserted = true
+      end
+    end
+    Task.cache do
+      2.times { Task.count }
+    end
+
+    assert asserted
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+
+  def test_payload_with_open_transaction
+    asserted = false
+    expected_transaction = nil
+
+    subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |event|
+      if event.payload[:cached]
+        assert_same expected_transaction, event.payload[:transaction]
+        asserted = true
+      end
+    end
+
+    Task.transaction do |transaction|
+      expected_transaction = transaction
+
+      Task.cache do
+        2.times { Task.count }
+      end
+    end
+
+    assert asserted
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+end