ibm_db 5.6.1 → 5.7.0

data/test/cases/connection_adapters/type_lookup_test.rb

@@ -2,12 +2,12 @@
 
 require "cases/helper"
 
-unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
-  module ActiveRecord
-    module ConnectionAdapters
-      class TypeLookupTest < ActiveRecord::TestCase
+module ActiveRecord
+  module ConnectionAdapters
+    class TypeLookupTest < ActiveRecord::TestCase
+      unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strings for lookup
         setup do
-          @connection = ActiveRecord::Base.connection
+          @connection = ActiveRecord::Base.lease_connection
         end
 
         def test_boolean_types
@@ -83,28 +83,16 @@ unless current_adapter?(:PostgreSQLAdapter) # PostgreSQL does not use type strin
 
         def test_bigint_limit
           limit = @connection.send(:type_map).lookup("bigint").send(:_limit)
-          if current_adapter?(:OracleAdapter)
-            assert_equal 19, limit
-          else
-            assert_equal 8, limit
-          end
+
+          assert_equal 8, limit
         end
 
         def test_decimal_without_scale
-          if current_adapter?(:OracleAdapter)
-            {
-              decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0)},
-              integer: %w{number(2) number(2,0)}
-            }
-          else
-            { decimal: %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)} }
-          end.each do |expected_type, types|
-            types.each do |type|
-              cast_type = @connection.send(:type_map).lookup(type)
-
-              assert_equal expected_type, cast_type.type
-              assert_equal 2, cast_type.cast(2.1)
-            end
+          %w{decimal(2) decimal(2,0) numeric(2) numeric(2,0) number(2) number(2,0)}.each do |type|
+            cast_type = @connection.send(:type_map).lookup(type)
+
+            assert_equal :decimal, cast_type.type
+            assert_equal 2, cast_type.cast(2.1)
           end
         end
 

data/test/cases/connection_handling_test.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  class ConnectionHandlingTest < ActiveRecord::TestCase
+    fixtures :posts
+
+    setup do
+      @_permanent_connection_checkout_was = ActiveRecord.permanent_connection_checkout
+    end
+
+    teardown do
+      ActiveRecord.permanent_connection_checkout = @_permanent_connection_checkout_was
+    end
+
+    unless in_memory_db?
+      test "#with_connection lease the connection for the duration of the block" do
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        ActiveRecord::Base.with_connection do |connection|
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        end
+
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+      end
+
+      test "#lease_connection makes the lease permanent even inside #with_connection" do
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        conn = nil
+        ActiveRecord::Base.with_connection do |connection|
+          conn = connection
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+          2.times do
+            assert_same connection, ActiveRecord::Base.lease_connection
+          end
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same conn, ActiveRecord::Base.lease_connection
+      end
+
+      test "#lease_connection makes the lease permanent even inside #with_connection(prevent_permanent_checkout: true)" do
+        ActiveRecord::Base.release_connection
+
+        ActiveRecord::Base.with_connection(prevent_permanent_checkout: true) do |connection|
+          assert_same connection, ActiveRecord::Base.lease_connection
+        end
+
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+      end
+
+      test "#with_connection(prevent_permanent_checkout: true) won't clear sticky lease set before by #lease_connection" do
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        leased_connection = nil
+        ActiveRecord::Base.with_connection do |connection|
+          leased_connection = ActiveRecord::Base.lease_connection
+          assert_same connection, leased_connection
+
+          ActiveRecord::Base.with_connection(prevent_permanent_checkout: true) do |inner_connection|
+            assert_same leased_connection, inner_connection
+          end
+
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+          assert_same leased_connection, ActiveRecord::Base.lease_connection
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same leased_connection, ActiveRecord::Base.lease_connection
+      ensure
+        ActiveRecord::Base.release_connection
+      end
+
+      test "#with_connection use the already leased connection if available" do
+        leased_connection = ActiveRecord::Base.lease_connection
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        ActiveRecord::Base.with_connection do |connection|
+          assert_same leased_connection, connection
+          assert_same ActiveRecord::Base.lease_connection, connection
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same ActiveRecord::Base.lease_connection, leased_connection
+      end
+
+      test "#with_connection is reentrant" do
+        leased_connection = ActiveRecord::Base.lease_connection
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        ActiveRecord::Base.with_connection do |connection|
+          assert_same leased_connection, connection
+          assert_same ActiveRecord::Base.lease_connection, connection
+
+          ActiveRecord::Base.with_connection do |connection2|
+            assert_same leased_connection, connection2
+            assert_same ActiveRecord::Base.lease_connection, connection2
+          end
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same ActiveRecord::Base.lease_connection, leased_connection
+      end
+
+      test "#connection is a soft-deprecated alias to #lease_connection" do
+        ActiveRecord.permanent_connection_checkout = true
+
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        conn = nil
+        ActiveRecord::Base.with_connection do |connection|
+          conn = connection
+          assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+          2.times do
+            assert_same connection, ActiveRecord::Base.connection
+          end
+        end
+
+        assert_predicate ActiveRecord::Base.connection_pool, :active_connection?
+        assert_same conn, ActiveRecord::Base.connection
+
+        ActiveRecord::Base.release_connection
+      end
+
+      test "#connection emits a deprecation warning if ActiveRecord.permanent_connection_checkout == :deprecated" do
+        ActiveRecord.permanent_connection_checkout = :deprecated
+
+        ActiveRecord::Base.release_connection
+
+        assert_deprecated(ActiveRecord.deprecator) do
+          ActiveRecord::Base.connection
+        end
+
+        assert_not_deprecated(ActiveRecord.deprecator) do
+          ActiveRecord::Base.connection
+        end
+
+        ActiveRecord::Base.release_connection
+
+        assert_deprecated(ActiveRecord.deprecator) do
+          ActiveRecord::Base.connection
+        end
+
+        ActiveRecord::Base.release_connection
+
+        ActiveRecord::Base.with_connection do
+          assert_deprecated(ActiveRecord.deprecator) do
+            ActiveRecord::Base.connection
+          end
+        end
+      end
+
+      test "#connection raises an error if ActiveRecord.permanent_connection_checkout == :disallowed" do
+        ActiveRecord.permanent_connection_checkout = :disallowed
+
+        ActiveRecord::Base.release_connection
+
+        assert_raises(ActiveRecordError) do
+          ActiveRecord::Base.connection
+        end
+
+        ActiveRecord::Base.with_connection do
+          assert_raises(ActiveRecordError) do
+            ActiveRecord::Base.connection
+          end
+        end
+
+        ActiveRecord::Base.lease_connection
+
+        assert_nothing_raised do
+          ActiveRecord::Base.connection
+        end
+      end
+
+      test "#connection doesn't make the lease permanent if inside #with_connection(prevent_permanent_checkout: true)" do
+        ActiveRecord.permanent_connection_checkout = :disallowed
+
+        ActiveRecord::Base.release_connection
+
+        ActiveRecord::Base.with_connection(prevent_permanent_checkout: true) do |connection|
+          assert_same connection, ActiveRecord::Base.connection
+        end
+
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+      end
+
+      test "common APIs don't permanently hold a connection when permanent checkout is deprecated or disallowed" do
+        ActiveRecord.permanent_connection_checkout = :deprecated
+        ActiveRecord::Base.release_connection
+        assert_not_predicate ActiveRecord::Base.connection_pool, :active_connection?
+
+        Post.create!(title: "foo", body: "bar")
+        assert_not_predicate Post.connection_pool, :active_connection?
+
+        Post.first
+        assert_not_predicate Post.connection_pool, :active_connection?
+
+        Post.count
+        assert_not_predicate Post.connection_pool, :active_connection?
+      end
+    end
+  end
+end

data/test/cases/connection_management_test.rb

@@ -26,8 +26,8 @@ module ActiveRecord
         @management = middleware(@app)
 
         # make sure we have an active connection
-        assert ActiveRecord::Base.connection
-        assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+        assert ActiveRecord::Base.lease_connection
+        assert ActiveRecord::Base.connection_handler.active_connections?(:all)
       end
 
       def test_app_delegation
@@ -47,14 +47,27 @@ module ActiveRecord
       def test_connections_are_cleared_after_body_close
         _, _, body = @management.call(@env)
         body.close
-        assert_not_predicate ActiveRecord::Base.connection_handler, :active_connections?
+        assert_not ActiveRecord::Base.connection_handler.active_connections?(:all)
+      end
+
+      test "connections are cleared even if inside a non-joinable transaction" do
+        ActiveRecord::Base.connection_pool.pin_connection!(Thread.current)
+        Thread.new do
+          assert ActiveRecord::Base.lease_connection
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
+          _, _, body = @management.call(@env)
+          body.close
+          assert_not ActiveRecord::Base.connection_handler.active_connections?(:all)
+        end.join
+      ensure
+        ActiveRecord::Base.connection_pool.unpin_connection!
       end
 
       def test_active_connections_are_not_cleared_on_body_close_during_transaction
         ActiveRecord::Base.transaction do
           _, _, body = @management.call(@env)
           body.close
-          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
         end
       end
 
@@ -62,7 +75,7 @@ module ActiveRecord
         app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
         explosive = middleware(app)
         assert_raises(NotImplementedError) { explosive.call(@env) }
-        assert_not_predicate ActiveRecord::Base.connection_handler, :active_connections?
+        assert_not ActiveRecord::Base.connection_handler.active_connections?(:all)
       end
 
       def test_connections_not_closed_if_exception_inside_transaction
@@ -70,14 +83,36 @@ module ActiveRecord
           app               = Class.new(App) { def call(env); raise RuntimeError; end }.new
           explosive         = middleware(app)
           assert_raises(RuntimeError) { explosive.call(@env) }
-          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
+        end
+      end
+
+      test "cancel asynchronous queries if an exception is raised" do
+        unless ActiveRecord::Base.lease_connection.supports_concurrent_connections?
+          skip "This adapter doesn't support asynchronous queries"
+        end
+
+        app = Class.new(App) do
+          attr_reader :future_result
+
+          def call(env)
+            @future_result = ActiveRecord::Base.lease_connection.select_all("SELECT * FROM does_not_exists", async: true)
+            raise NotImplementedError
+          end
+        end.new
+
+        explosive = middleware(app)
+        assert_raises(NotImplementedError) { explosive.call(@env) }
+
+        assert_raises FutureResult::Canceled do
+          app.future_result.to_a
         end
       end
 
       test "doesn't clear active connections when running in a test case" do
         executor.wrap do
           @management.call(@env)
-          assert_predicate ActiveRecord::Base.connection_handler, :active_connections?
+          assert ActiveRecord::Base.connection_handler.active_connections?(:all)
         end
       end
 
@@ -100,6 +135,8 @@ module ActiveRecord
         def executor
           @executor ||= Class.new(ActiveSupport::Executor).tap do |exe|
             ActiveRecord::QueryCache.install_executor_hooks(exe)
+            ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks(exe)
+            ActiveRecord::ConnectionAdapters::ConnectionPool.install_executor_hooks(exe)
           end
         end