ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/postgresql/transaction_nested_test.rb

@@ -11,25 +11,34 @@ module ActiveRecord
     class Sample < ActiveRecord::Base
       self.table_name = "samples"
     end
+    class Bit < ActiveRecord::Base
+      self.table_name = "bits"
+    end
 
     setup do
       @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
       Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
 
-      connection = ActiveRecord::Base.connection
+      connection = ActiveRecord::Base.lease_connection
 
       connection.transaction do
         connection.drop_table "samples", if_exists: true
+        connection.drop_table "bits", if_exists: true
         connection.create_table("samples") do |t|
           t.integer "value"
         end
+        connection.create_table("bits") do |t|
+          t.integer "value"
+        end
       end
 
       Sample.reset_column_information
+      Bit.reset_column_information
     end
 
     teardown do
-      ActiveRecord::Base.connection.drop_table "samples", if_exists: true
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
+      ActiveRecord::Base.lease_connection.drop_table "bits", if_exists: true
 
       Thread.abort_on_exception = @abort
       Thread.report_on_exception = @original_report_on_exception
@@ -43,7 +52,9 @@ module ActiveRecord
         thread = Thread.new do
           with_warning_suppression do
             Sample.transaction(isolation: :serializable, requires_new: false) do
+              make_parent_transaction_dirty
               Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
                 before.wait
                 Sample.create value: Sample.sum(:value)
                 after.wait
@@ -55,7 +66,9 @@ module ActiveRecord
         begin
           with_warning_suppression do
             Sample.transaction(isolation: :serializable, requires_new: false) do
+              make_parent_transaction_dirty
               Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
                 before.wait
                 Sample.create value: Sample.sum(:value)
                 after.wait
@@ -68,8 +81,50 @@ module ActiveRecord
       end
     end
 
+    test "SerializationFailure inside nested SavepointTransaction is recoverable" do
+      start_right = Concurrent::Event.new
+      commit_left = Concurrent::Event.new
+      finish_right = Concurrent::Event.new
+      Sample.create value: 1
+
+      thread = Thread.new do
+        with_warning_suppression do
+          Sample.transaction(isolation: :serializable, requires_new: false) do
+            Sample.update_all value: 2
+            start_right.set
+            commit_left.wait(1)
+          end
+          finish_right.set
+        end
+      end
+
+      begin
+        with_warning_suppression do
+          start_right.wait
+          Sample.transaction(isolation: :serializable, requires_new: false) do
+            make_parent_transaction_dirty
+            assert_raises(ActiveRecord::SerializationFailure) do
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                Sample.create value: 3
+                commit_left.set
+                finish_right.wait(2)
+                Sample.update_all value: 4
+              end
+            end
+            Bit.create value: 1
+          end
+        end
+      ensure
+        thread.join
+      end
+      assert_equal [2], Sample.pluck(:value)
+      assert_equal [1], Bit.pluck(:value)
+    end
+
     test "deadlock raises Deadlocked inside nested SavepointTransaction" do
       with_warning_suppression do
+        connections = Concurrent::Set.new
         assert_raises(ActiveRecord::Deadlocked) do
           barrier = Concurrent::CyclicBarrier.new(2)
 
@@ -77,8 +132,11 @@ module ActiveRecord
           s2 = Sample.create value: 2
 
           thread = Thread.new do
+            connections.add Sample.lease_connection
             Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
               Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
                 s1.lock!
                 barrier.wait
                 s2.update value: 1
@@ -87,8 +145,11 @@ module ActiveRecord
           end
 
           begin
+            connections.add Sample.lease_connection
             Sample.transaction(requires_new: false) do
+              make_parent_transaction_dirty
               Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
                 s2.lock!
                 barrier.wait
                 s1.update value: 2
@@ -98,17 +159,80 @@ module ActiveRecord
             thread.join
           end
         end
+        assert connections.all?(&:active?)
+      end
+    end
+
+    test "deadlock inside nested SavepointTransaction is recoverable" do
+      with_warning_suppression do
+        barrier = Concurrent::CyclicBarrier.new(2)
+        deadlocks = 0
+
+        s1 = Sample.create value: 1
+        s2 = Sample.create value: 2
+
+        thread = Thread.new do
+          Sample.transaction(requires_new: false) do
+            make_parent_transaction_dirty
+            begin
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s1.lock!
+                barrier.wait
+                s2.update value: 4
+              end
+            rescue ActiveRecord::Deadlocked
+              deadlocks += 1
+            end
+            s2.update value: 10
+          end
+        end
+
+        begin
+          Sample.transaction(requires_new: false) do
+            make_parent_transaction_dirty
+            begin
+              Sample.transaction(requires_new: true) do
+                assert_current_transaction_is_savepoint_transaction
+                s2.lock!
+                barrier.wait
+                s1.update value: 3
+              end
+            rescue ActiveRecord::Deadlocked
+              deadlocks += 1
+            end
+            s1.update value: 10
+          end
+        ensure
+          thread.join
+        end
+        assert_equal 1, deadlocks
+        assert_equal [10, 10], Sample.pluck(:value)
       end
     end
 
     private
       def with_warning_suppression
-        log_level = ActiveRecord::Base.connection.client_min_messages
-        ActiveRecord::Base.connection.client_min_messages = "error"
+        log_level = ActiveRecord::Base.lease_connection.client_min_messages
+        ActiveRecord::Base.lease_connection.client_min_messages = "error"
         yield
       ensure
-        ActiveRecord::Base.clear_active_connections!
-        ActiveRecord::Base.connection.client_min_messages = log_level
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+        ActiveRecord::Base.lease_connection.client_min_messages = log_level
+      end
+
+      # These tests are coordinating a controlled sequence of accesses to rows in `samples` table under serializable isolation.
+      # We need to run a query to dirty our transaction, but must avoid touching `samples` rows
+      # because otherwise our no-op query becomes an active participant of the test setup
+      def make_parent_transaction_dirty
+        Bit.take
+      end
+
+      def assert_current_transaction_is_savepoint_transaction
+        current_transaction = Sample.lease_connection.current_transaction
+        unless current_transaction.is_a?(ActiveRecord::ConnectionAdapters::SavepointTransaction)
+          flunk("current transaction is not a savepoint transaction")
+        end
       end
   end
 end

data/test/cases/adapters/postgresql/transaction_test.rb

@@ -16,7 +16,7 @@ module ActiveRecord
       @abort, Thread.abort_on_exception = Thread.abort_on_exception, false
       Thread.report_on_exception, @original_report_on_exception = false, Thread.report_on_exception
 
-      connection = ActiveRecord::Base.connection
+      connection = ActiveRecord::Base.lease_connection
 
       connection.transaction do
         connection.drop_table "samples", if_exists: true
@@ -29,7 +29,7 @@ module ActiveRecord
     end
 
     teardown do
-      ActiveRecord::Base.connection.drop_table "samples", if_exists: true
+      ActiveRecord::Base.lease_connection.drop_table "samples", if_exists: true
 
       Thread.abort_on_exception = @abort
       Thread.report_on_exception = @original_report_on_exception
@@ -66,6 +66,7 @@ module ActiveRecord
 
     test "raises Deadlocked when a deadlock is encountered" do
       with_warning_suppression do
+        connections = Concurrent::Set.new
         assert_raises(ActiveRecord::Deadlocked) do
           barrier = Concurrent::CyclicBarrier.new(2)
 
@@ -73,6 +74,7 @@ module ActiveRecord
           s2 = Sample.create value: 2
 
           thread = Thread.new do
+            connections.add Sample.lease_connection
             Sample.transaction do
               s1.lock!
               barrier.wait
@@ -81,6 +83,7 @@ module ActiveRecord
           end
 
           begin
+            connections.add Sample.lease_connection
             Sample.transaction do
               s2.lock!
               barrier.wait
@@ -90,6 +93,7 @@ module ActiveRecord
             thread.join
           end
         end
+        assert connections.all?(&:active?)
       end
     end
 
@@ -110,11 +114,11 @@ module ActiveRecord
         begin
           Sample.transaction do
             latch1.wait
-            Sample.connection.execute("SET lock_timeout = 1")
+            Sample.lease_connection.execute("SET lock_timeout = 1")
             Sample.lock.find(s.id)
           end
         ensure
-          Sample.connection.execute("SET lock_timeout = DEFAULT")
+          Sample.lease_connection.execute("SET lock_timeout = DEFAULT")
           latch2.count_down
           thread.join
         end
@@ -138,11 +142,11 @@ module ActiveRecord
         begin
           Sample.transaction do
             latch1.wait
-            Sample.connection.execute("SET statement_timeout = 1")
+            Sample.lease_connection.execute("SET statement_timeout = 1")
             Sample.lock.find(s.id)
           end
         ensure
-          Sample.connection.execute("SET statement_timeout = DEFAULT")
+          Sample.lease_connection.execute("SET statement_timeout = DEFAULT")
           latch2.count_down
           thread.join
         end
@@ -159,7 +163,7 @@ module ActiveRecord
             Sample.lock.find(s.id)
             latch.count_down
             sleep(0.5)
-            conn = Sample.connection
+            conn = Sample.lease_connection
             pid = conn.query_value("SELECT pid FROM pg_stat_activity WHERE query LIKE '% FOR UPDATE'")
             conn.execute("SELECT pg_cancel_backend(#{pid})")
           end
@@ -176,14 +180,36 @@ module ActiveRecord
       end
     end
 
+    test "raises Interrupt when canceling statement via interrupt" do
+      if PG.library_version >= 18_00_00 && Gem::Version.new(PG::VERSION) < Gem::Version.new("1.6.0")
+        skip "PG::Connection#cancel should not run when libpq of PostgreSQL #{PG.library_version / 10000} with pg gem version #{PG::VERSION}"
+      end
+      start_time = Time.now
+      thread = Thread.new do
+        Sample.transaction do
+          Sample.lease_connection.execute("SELECT pg_sleep(10)")
+        end
+      rescue Exception => e
+        e
+      end
+
+      sleep(0.5)
+      thread.raise Interrupt
+      thread.join
+      duration = Time.now - start_time
+
+      assert_instance_of Interrupt, thread.value
+      assert_operator duration, :<, 5
+    end
+
     private
       def with_warning_suppression
-        log_level = ActiveRecord::Base.connection.client_min_messages
-        ActiveRecord::Base.connection.client_min_messages = "error"
+        log_level = ActiveRecord::Base.lease_connection.client_min_messages
+        ActiveRecord::Base.lease_connection.client_min_messages = "error"
         yield
       ensure
-        ActiveRecord::Base.clear_active_connections!
-        ActiveRecord::Base.connection.client_min_messages = log_level
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+        ActiveRecord::Base.lease_connection.client_min_messages = log_level
       end
   end
 end

data/test/cases/adapters/postgresql/type_lookup_test.rb

@@ -4,7 +4,7 @@ require "cases/helper"
 
 class PostgresqlTypeLookupTest < ActiveRecord::PostgreSQLTestCase
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   test "array delimiters are looked up correctly" do

data/test/cases/adapters/postgresql/uuid_test.rb

@@ -5,7 +5,7 @@ require "support/schema_dumping_helper"
 
 module PostgresqlUUIDHelper
   def connection
-    @connection ||= ActiveRecord::Base.connection
+    @connection ||= ActiveRecord::Base.lease_connection
   end
 
   def drop_table(name)
@@ -39,11 +39,12 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
   end
 
   teardown do
+    UUIDType.reset_column_information
     drop_table "uuid_data_type"
   end
 
-  if ActiveRecord::Base.connection.respond_to?(:supports_pgcrypto_uuid?) &&
-      ActiveRecord::Base.connection.supports_pgcrypto_uuid?
+  if ActiveRecord::Base.lease_connection.respond_to?(:supports_pgcrypto_uuid?) &&
+      ActiveRecord::Base.lease_connection.supports_pgcrypto_uuid?
     def test_uuid_column_default
       connection.add_column :uuid_data_type, :thingy, :uuid, null: false, default: "gen_random_uuid()"
       UUIDType.reset_column_information
@@ -120,10 +121,13 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     assert_empty UUIDType.where(guid: "foobar")
   end
 
-  def test_uuid_change_case_does_not_mark_dirty
+  def test_uuid_change_format_does_not_mark_dirty
     model = UUIDType.create!(guid: "abcd-0123-4567-89ef-dead-beef-0101-1010")
     model.guid = model.guid.swapcase
     assert_not_predicate model, :changed?
+
+    model.guid = "{#{model.guid}}"
+    assert_not_predicate model, :changed?
   end
 
   class DuckUUID
@@ -201,7 +205,7 @@ class PostgresqlUUIDTest < ActiveRecord::PostgreSQLTestCase
     record = klass.create!(guid: "a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11")
     duplicate = klass.new(guid: record.guid)
 
-    assert record.guid.present? # Ensure we actually are testing a UUID
+    assert_predicate record.guid, :present? # Ensure we actually are testing a UUID
     assert_not_predicate duplicate, :valid?
   end
 end
@@ -299,14 +303,16 @@ class PostgresqlUUIDGenerationTest < ActiveRecord::PostgreSQLTestCase
         create_table("pg_uuids_4", id: :uuid)
       end
     end.new
-    ActiveRecord::Migrator.new(:up, [migration], ActiveRecord::Base.connection.schema_migration).migrate
+
+    pool = ActiveRecord::Base.connection_pool
+    ActiveRecord::Migrator.new(:up, [migration], pool.schema_migration, pool.internal_metadata).migrate
 
     schema = dump_table_schema "pg_uuids_4"
     assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: -> { "uuid_generate_v4\(\)" }/, schema)
   ensure
     drop_table "pg_uuids_4"
     ActiveRecord::Migration.verbose = @verbose_was
-    ActiveRecord::Base.connection.schema_migration.delete_all
+    ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions
   end
   uses_transaction :test_schema_dumper_for_uuid_primary_key_default_in_legacy_migration
 end
@@ -349,14 +355,16 @@ class PostgresqlUUIDTestNilDefault < ActiveRecord::PostgreSQLTestCase
         create_table("pg_uuids_4", id: :uuid, default: nil)
       end
     end.new
-    ActiveRecord::Migrator.new(:up, [migration], ActiveRecord::Base.connection.schema_migration).migrate
+
+    pool = ActiveRecord::Base.connection_pool
+    ActiveRecord::Migrator.new(:up, [migration], pool.schema_migration, pool.internal_metadata).migrate
 
     schema = dump_table_schema "pg_uuids_4"
     assert_match(/\bcreate_table "pg_uuids_4", id: :uuid, default: nil/, schema)
   ensure
     drop_table "pg_uuids_4"
     ActiveRecord::Migration.verbose = @verbose_was
-    ActiveRecord::Base.connection.schema_migration.delete_all
+    ActiveRecord::Base.connection_pool.schema_migration.delete_all_versions
   end
   uses_transaction :test_schema_dumper_for_uuid_primary_key_with_default_nil_in_legacy_migration
 end
@@ -409,3 +417,63 @@ class PostgresqlUUIDTestInverseOf < ActiveRecord::PostgreSQLTestCase
     assert_nil UuidPost.find_by(id: 789)
   end
 end
+
+class PostgresqlUUIDHasManyThroughDisableJoinsTest < ActiveRecord::PostgreSQLTestCase
+  include PostgresqlUUIDHelper
+
+  class UuidForum < ActiveRecord::Base
+    self.table_name = "pg_uuid_forums"
+    has_many :uuid_posts, -> { order("title DESC") }
+    has_many :uuid_comments, through: :uuid_posts
+    has_many :uuid_comments_without_joins, through: :uuid_posts, source: :uuid_comments, disable_joins: true
+  end
+
+  class UuidPost < ActiveRecord::Base
+    self.table_name = "pg_uuid_posts"
+    belongs_to :uuid_forum
+    has_many :uuid_comments
+  end
+
+  class UuidComment < ActiveRecord::Base
+    self.table_name = "pg_uuid_comments"
+    belongs_to :uuid_post
+    has_one :uuid_forum, through: :uuid_post
+    has_one :uuid_forum_without_joins, through: :uuid_post, source: :uuid_forum, disable_joins: true
+  end
+
+  setup do
+    connection.transaction do
+      connection.create_table("pg_uuid_forums", id: :uuid, **uuid_default) do |t|
+        t.string "name"
+      end
+      connection.create_table("pg_uuid_posts", id: :uuid, **uuid_default) do |t|
+        t.references :uuid_forum, type: :uuid
+        t.string "title"
+      end
+      connection.create_table("pg_uuid_comments", id: :uuid, **uuid_default) do |t|
+        t.references :uuid_post, type: :uuid
+        t.string "content"
+      end
+    end
+  end
+
+  teardown do
+    drop_table "pg_uuid_comments"
+    drop_table "pg_uuid_posts"
+    drop_table "pg_uuid_forums"
+  end
+
+  def test_uuid_primary_key_and_disable_joins_with_delegate_cache
+    uuid_forum = UuidForum.create!
+    uuid_post_1 = uuid_forum.uuid_posts.create!
+    uuid_comment_1_1 = uuid_post_1.uuid_comments.create!
+    uuid_comment_1_2 = uuid_post_1.uuid_comments.create!
+    uuid_post_2 = uuid_forum.uuid_posts.create!
+    uuid_comment_2_1 = uuid_post_2.uuid_comments.create!
+    uuid_comment_2_2 = uuid_post_2.uuid_comments.create!
+    uuid_comment_2_3 = uuid_post_2.uuid_comments.create!
+
+    assert_equal uuid_forum.uuid_comments_without_joins.order(:id).to_a.map(&:id).sort,
+      [uuid_comment_1_1.id, uuid_comment_1_2.id, uuid_comment_2_1.id, uuid_comment_2_2.id, uuid_comment_2_3.id].sort
+  end
+end

data/test/cases/adapters/postgresql/virtual_column_test.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+if ActiveRecord::Base.lease_connection.supports_virtual_columns?
+  class PostgresqlVirtualColumnTest < ActiveRecord::PostgreSQLTestCase
+    include SchemaDumpingHelper
+
+    class VirtualColumn < ActiveRecord::Base
+    end
+
+    def setup
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :virtual_columns, force: true do |t|
+        t.string  :name
+        t.virtual :upper_name,  type: :string,  as: "UPPER(name)", stored: true
+        t.virtual :name_length, type: :integer, as: "LENGTH(name)", stored: true
+        t.virtual :name_octet_length, type: :integer, as: "OCTET_LENGTH(name)", stored: true
+        t.integer :column1
+        t.virtual :column2, type: :integer, as: "column1 + 1", stored: true
+      end
+      VirtualColumn.create(name: "Rails")
+    end
+
+    def test_virtual_column_with_full_inserts
+      partial_inserts_was = VirtualColumn.partial_inserts
+      VirtualColumn.partial_inserts = false
+      assert_nothing_raised do
+        VirtualColumn.create!(name: "Rails")
+      end
+    ensure
+      VirtualColumn.partial_inserts = partial_inserts_was
+    end
+
+    def teardown
+      @connection.drop_table :virtual_columns, if_exists: true
+      VirtualColumn.reset_column_information
+    end
+
+    def test_virtual_column
+      column = VirtualColumn.columns_hash["upper_name"]
+      assert_predicate column, :virtual?
+      assert_equal "RAILS", VirtualColumn.take.upper_name
+    end
+
+    def test_stored_column
+      column = VirtualColumn.columns_hash["name_length"]
+      assert_predicate column, :virtual?
+      assert_equal 5, VirtualColumn.take.name_length
+    end
+
+    def test_change_table
+      @connection.change_table :virtual_columns do |t|
+        t.virtual :lower_name, type: :string, as: "LOWER(name)", stored: true
+      end
+      VirtualColumn.reset_column_information
+      column = VirtualColumn.columns_hash["lower_name"]
+      assert_predicate column, :virtual?
+      assert_equal "rails", VirtualColumn.take.lower_name
+    end
+
+    def test_non_persisted_column
+      message = <<~MSG
+        PostgreSQL currently does not support VIRTUAL (not persisted) generated columns.
+        Specify 'stored: true' option for 'invalid_definition'
+      MSG
+
+      assert_raise ArgumentError, message do
+        @connection.change_table :virtual_columns do |t|
+          t.virtual :invalid_definition, type: :string, as: "LOWER(name)"
+        end
+      end
+    end
+
+    def test_schema_dumping
+      output = dump_table_schema("virtual_columns")
+      assert_match(/t\.virtual\s+"upper_name",\s+type: :string,\s+as: "upper\(\(name\)::text\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"name_length",\s+type: :integer,\s+as: "length\(\(name\)::text\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"name_octet_length",\s+type: :integer,\s+as: "octet_length\(\(name\)::text\)", stored: true$/i, output)
+      assert_match(/t\.virtual\s+"column2",\s+type: :integer,\s+as: "\(column1 \+ 1\)", stored: true$/i, output)
+    end
+
+    def test_build_fixture_sql
+      fixtures = ActiveRecord::FixtureSet.create_fixtures(FIXTURES_ROOT, :virtual_columns).first
+      assert_equal 2, fixtures.size
+    end
+
+    def test_virtual_column_does_not_deduplicate_with_regular_column
+      @connection.create_table :regular_columns, force: true do |t|
+        t.string :name
+      end
+
+      regular_model = Class.new(ActiveRecord::Base) { self.table_name = "regular_columns" }
+
+      # Ensure deduplication has seen the virtual column first
+      VirtualColumn.columns_hash
+
+      regular_col = regular_model.columns_hash["name"]
+      virtual_col = VirtualColumn.columns_hash["upper_name"]
+
+      assert_predicate virtual_col, :virtual?
+      assert_not_predicate regular_col, :virtual?
+      assert_not_equal regular_col, virtual_col
+
+      # The regular column must not be excluded from inserts
+      record = regular_model.create!(name: "hello")
+      record.reload
+      assert_equal "hello", record.name
+    ensure
+      @connection.drop_table :regular_columns, if_exists: true
+    end
+  end
+end

data/test/cases/adapters/postgresql/xml_test.rb

@@ -10,7 +10,7 @@ class PostgresqlXMLTest < ActiveRecord::PostgreSQLTestCase
   end
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table("xml_data_type") do |t|
       t.xml "payload"
     end

data/test/cases/adapters/sqlite3/bind_parameter_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/post"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3Adapter
+      class BindParameterTest < ActiveRecord::SQLite3TestCase
+        fixtures :posts
+
+        def test_where_with_string_for_string_column_using_bind_parameters
+          assert_quoted_as "'Welcome to the weblog'", "Welcome to the weblog", match: 1
+        end
+
+        def test_where_with_integer_for_string_column_using_bind_parameters
+          assert_quoted_as "0", 0
+        end
+
+        def test_where_with_float_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", 0.0
+        end
+
+        def test_where_with_boolean_for_string_column_using_bind_parameters
+          assert_quoted_as "0", false
+        end
+
+        def test_where_with_decimal_for_string_column_using_bind_parameters
+          assert_quoted_as "0.0", BigDecimal(0)
+        end
+
+        def test_where_with_rational_for_string_column_using_bind_parameters
+          assert_quoted_as "0/1", Rational(0)
+        end
+
+        private
+          def assert_quoted_as(expected, value, match: 0)
+            relation = Post.where("title = ?", value)
+            assert_equal(
+              %{SELECT "posts".* FROM "posts" WHERE (title = #{expected})},
+              relation.to_sql,
+            )
+            if match == 0
+              assert_empty relation.to_a
+            else
+              assert_equal match, relation.count
+            end
+          end
+      end
+    end
+  end
+end

data/test/cases/adapters/sqlite3/collation_test.rb

@@ -7,7 +7,7 @@ class SQLite3CollationTest < ActiveRecord::SQLite3TestCase
   include SchemaDumpingHelper
 
   def setup
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table :collation_table_sqlite3, force: true do |t|
       t.string :string_nocase, collation: "NOCASE"
       t.text :text_rtrim, collation: "RTRIM"