activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/test/cases/coerced_tests.rb

@@ -47,12 +47,26 @@ class UniquenessValidationTest < ActiveRecord::TestCase
   end
 end
 
+class UniquenessValidationWithIndexTest < ActiveRecord::TestCase
+  # Need to explicitly set the WHERE clause to truthy.
+  coerce_tests! :test_partial_index
+  def test_partial_index_coerced
+    Topic.validates_uniqueness_of(:title)
+    @connection.add_index(:topics, :title, unique: true, where: "approved=1", name: :topics_index)
+
+    t = Topic.create!(title: "abc")
+    t.author_name = "John"
+    assert_queries_count(1) do
+      t.valid?
+    end
+  end
+end
+
 require "models/event"
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
     # Legacy binds are not supported.
     coerce_tests! :test_select_all_insert_update_delete_with_casted_binds
-    coerce_tests! :test_select_all_insert_update_delete_with_legacy_binds
 
     # As far as I can tell, SQL Server does not support null bytes in strings.
     coerce_tests! :test_update_prepared_statement
@@ -92,37 +106,17 @@ module ActiveRecord
       Subscriber.send(:load_schema!)
       original_test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_is_called_while_preventing_writes
     end
-  end
-end
-
-module ActiveRecord
-  class AdapterPreventWritesLegacyTest < ActiveRecord::TestCase
-    # Fix randomly failing test. The loading of the model's schema was affecting the test.
-    coerce_tests! :test_errors_when_an_insert_query_is_called_while_preventing_writes
-    def test_errors_when_an_insert_query_is_called_while_preventing_writes_coerced
-      Subscriber.send(:load_schema!)
-      original_test_errors_when_an_insert_query_is_called_while_preventing_writes
-    end
 
-    # Fix randomly failing test. The loading of the model's schema was affecting the test.
-    coerce_tests! :test_errors_when_an_insert_query_prefixed_by_a_slash_star_comment_is_called_while_preventing_writes
-    def test_errors_when_an_insert_query_prefixed_by_a_slash_star_comment_is_called_while_preventing_writes_coerced
-      Subscriber.send(:load_schema!)
-      original_test_errors_when_an_insert_query_prefixed_by_a_slash_star_comment_is_called_while_preventing_writes
-    end
-
-    # Fix randomly failing test. The loading of the model's schema was affecting the test.
-    coerce_tests! :test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_is_called_while_preventing_writes
-    def test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_is_called_while_preventing_writes_coerced
-      Subscriber.send(:load_schema!)
-      original_test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_is_called_while_preventing_writes
-    end
-
-    # Fix randomly failing test. The loading of the model's schema was affecting the test.
-    coerce_tests! :test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_containing_read_command_is_called_while_preventing_writes
-    def test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_containing_read_command_is_called_while_preventing_writes_coerced
-      Subscriber.send(:load_schema!)
-      original_test_errors_when_an_insert_query_prefixed_by_a_double_dash_comment_containing_read_command_is_called_while_preventing_writes
+    # Invalid character encoding causes `ActiveRecord::StatementInvalid` error similar to Postgres.
+    coerce_tests! :test_doesnt_error_when_a_select_query_has_encoding_errors
+    def test_doesnt_error_when_a_select_query_has_encoding_errors_coerced
+      ActiveRecord::Base.while_preventing_writes do
+        # TinyTDS fail on encoding errors.
+        # But at least we can assert it fails in the client and not before when trying to match the query.
+        assert_raises ActiveRecord::StatementInvalid do
+          @connection.select_all("SELECT '\xC8'")
+        end
+      end
     end
   end
 end
@@ -203,7 +197,7 @@ class BasicsTest < ActiveRecord::TestCase
   # Use square brackets as SQL Server escaped character
   coerce_tests! :test_column_names_are_escaped
   def test_column_names_are_escaped_coerced
-    conn = ActiveRecord::Base.connection
+    conn = ActiveRecord::Base.lease_connection
     assert_equal "[t]]]", conn.quote_column_name("t]")
   end
 
@@ -235,18 +229,6 @@ class BasicsTest < ActiveRecord::TestCase
       end
     end
   end
-
-  # SQL Server does not have query for release_savepoint
-  coerce_tests! %r{an empty transaction does not raise if preventing writes}
-  test "an empty transaction does not raise if preventing writes coerced" do
-    ActiveRecord::Base.while_preventing_writes do
-      assert_queries(1, ignore_none: true) do
-        Bird.transaction do
-          ActiveRecord::Base.connection.materialize_transactions
-        end
-      end
-    end
-  end
 end
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
@@ -266,7 +248,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_belongs_to_coerced
     client = Client.find(3)
     first_firm = companies(:first_firm)
-    assert_sql(/FETCH NEXT @(\d) ROWS ONLY(.)*@\1 = 1/) do
+    assert_queries_match(/FETCH NEXT @(\d) ROWS ONLY(.)*@\1 = 1/) do
       assert_equal first_firm, client.firm
       assert_equal first_firm.name, client.firm.name
     end
@@ -329,7 +311,7 @@ module ActiveRecord
 
       authors = Author.where(id: [1, 2, 3, nil])
       assert_equal sql_unprepared, @connection.to_sql(authors.arel)
-      assert_sql(prepared ? sql_prepared : sql_unprepared) { assert_equal 3, authors.length }
+      assert_queries_match(prepared ? sql_prepared : sql_unprepared) { assert_equal 3, authors.length }
 
       # prepared_statements: true
       #
@@ -344,7 +326,7 @@ module ActiveRecord
 
       authors = Author.where(id: [1, 2, 3, 9223372036854775808])
       assert_equal sql_unprepared, @connection.to_sql(authors.arel)
-      assert_sql(prepared ? sql_prepared : sql_unprepared) { assert_equal 3, authors.length }
+      assert_queries_match(prepared ? sql_prepared : sql_unprepared) { assert_equal 3, authors.length }
     end
   end
 end
@@ -357,10 +339,55 @@ module ActiveRecord
       Book.send(:load_schema!)
       original_test_payload_name_on_load
     end
+
+    # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+    coerce_tests! :test_payload_row_count_on_select_all
+    def test_payload_row_count_on_select_all_coerced
+      connection.remove_index(:books, column: [:author_id, :name])
+
+      original_test_payload_row_count_on_select_all
+    ensure
+      Book.where(author_id: nil, name: 'row count book 1').delete_all
+      Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+    end
+
+    # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+    coerce_tests! :test_payload_row_count_on_pluck
+    def test_payload_row_count_on_pluck_coerced
+      connection.remove_index(:books, column: [:author_id, :name])
+
+      original_test_payload_row_count_on_pluck
+    ensure
+      Book.where(author_id: nil, name: 'row count book 2').delete_all
+      Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+    end
+
+    # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+    coerce_tests! :test_payload_row_count_on_raw_sql
+    def test_payload_row_count_on_raw_sql_coerced
+      connection.remove_index(:books, column: [:author_id, :name])
+
+      original_test_payload_row_count_on_raw_sql
+    ensure
+      Book.where(author_id: nil, name: 'row count book 3').delete_all
+      Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+    end
   end
 end
 
 class CalculationsTest < ActiveRecord::TestCase
+  # SELECT columns must be in the GROUP clause.
+  coerce_tests! :test_should_count_with_group_by_qualified_name_on_loaded
+  def test_should_count_with_group_by_qualified_name_on_loaded_coerced
+    accounts = Account.group("accounts.id").select("accounts.id")
+    expected = { 1 => 1, 2 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1 }
+    assert_not_predicate accounts, :loaded?
+    assert_equal expected, accounts.count
+    accounts.load
+    assert_predicate accounts, :loaded?
+    assert_equal expected, accounts.count(:id)
+  end
+  
   # Fix randomly failing test. The loading of the model's schema was affecting the test.
   coerce_tests! :test_offset_is_kept
   def test_offset_is_kept_coerced
@@ -439,7 +466,7 @@ class CalculationsTest < ActiveRecord::TestCase
       FROM companies
       INNER JOIN accounts ON companies.id = accounts.firm_id
       WHERE companies.id = ?
-      GROUP BY companies.id, companies.type, companies.firm_id, companies.firm_name, companies.name, companies.client_of, companies.rating, companies.account_id, companies.description
+      GROUP BY companies.id, companies.type, companies.firm_id, companies.firm_name, companies.name, companies.client_of, companies.rating, companies.account_id, companies.description, companies.status
       ORDER BY companies.id
       OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY
     SQL
@@ -465,7 +492,7 @@ class CalculationsTest < ActiveRecord::TestCase
              .select("companies.*", "AVG(CAST(accounts.credit_limit AS DECIMAL)) AS avg_credit_limit")
              .where(id: rails_core)
              .joins(:account)
-             .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description)
+             .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description, :status)
              .take!
 
     # all the DependentFirm attributes should be present
@@ -479,7 +506,7 @@ class CalculationsTest < ActiveRecord::TestCase
   # Match SQL Server limit implementation
   coerce_tests! :test_limit_is_kept
   def test_limit_is_kept_coerced
-    queries = capture_sql_ss { Account.limit(1).count }
+    queries = capture_sql { Account.limit(1).count }
     assert_equal 1, queries.length
     assert_match(/ORDER BY \[accounts\]\.\[id\] ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/, queries.first)
   end
@@ -487,7 +514,7 @@ class CalculationsTest < ActiveRecord::TestCase
   # Match SQL Server limit implementation
   coerce_tests! :test_limit_with_offset_is_kept
   def test_limit_with_offset_is_kept_coerced
-    queries = capture_sql_ss { Account.limit(1).offset(1).count }
+    queries = capture_sql { Account.limit(1).offset(1).count }
     assert_equal 1, queries.length
     assert_match(/ORDER BY \[accounts\]\.\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY.*@0 = 1, @1 = 1/, queries.first)
   end
@@ -496,12 +523,15 @@ class CalculationsTest < ActiveRecord::TestCase
   coerce_tests! :test_distinct_count_all_with_custom_select_and_order
   def test_distinct_count_all_with_custom_select_and_order_coerced
     accounts = Account.distinct.select("credit_limit % 10 AS the_limit").order(Arel.sql("credit_limit % 10"))
-    assert_queries(1) { assert_equal 3, accounts.count(:all) }
-    assert_queries(1) { assert_equal 3, accounts.load.size }
+    assert_queries_count(1) { assert_equal 3, accounts.count(:all) }
+    assert_queries_count(1) { assert_equal 3, accounts.load.size }
   end
 
   # Leave it up to users to format selects/functions so HAVING works correctly.
   coerce_tests! :test_having_with_strong_parameters
+
+  # SELECT columns must be in the GROUP clause. Since since `ids` only selects the primary key you cannot perform this query in SQL Server.
+  coerce_tests! :test_ids_with_includes_and_non_primary_key_order
 end
 
 module ActiveRecord
@@ -531,29 +561,46 @@ module ActiveRecord
         assert_equal 1, four.default
         assert_equal "hello", five.default
       end
-    end
-  end
-end
 
-module ActiveRecord
-  module ConnectionAdapters
-    class QuoteARBaseTest < ActiveRecord::TestCase
-      # Use our date format.
-      coerce_tests! :test_quote_ar_object
-      def test_quote_ar_object_coerced
-        value = DatetimePrimaryKey.new(id: @time)
-        assert_deprecated do
-          assert_equal "'02-14-2017 12:34:56.79'", @connection.quote(value)
+      # Use precision 6 by default for datetime/timestamp columns. SQL Server uses `datetime2` for date-times with precision.
+      coerce_tests! :test_add_column_with_postgresql_datetime_type
+      def test_add_column_with_postgresql_datetime_type_coerced
+        connection.create_table :testings do |t|
+          t.column :foo, :datetime
         end
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+        assert_equal "datetime2(6)", column.sql_type
+      end
+
+      # Use precision 6 by default for datetime/timestamp columns. SQL Server uses `datetime2` for date-times with precision.
+      coerce_tests! :test_change_column_with_timestamp_type
+      def test_change_column_with_timestamp_type_coerced
+        connection.create_table :testings do |t|
+          t.column :foo, :datetime, null: false
+        end
+
+        connection.change_column :testings, :foo, :timestamp
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+        assert_equal "datetime2(6)", column.sql_type
       end
 
-      # Use our date format.
-      coerce_tests! :test_type_cast_ar_object
-      def test_type_cast_ar_object_coerced
-        value = DatetimePrimaryKey.new(id: @time)
-        assert_deprecated do
-          assert_equal "02-14-2017 12:34:56.79", @connection.type_cast(value)
+      # Use precision 6 by default for datetime/timestamp columns. SQL Server uses `datetime2` for date-times with precision.
+      coerce_tests! :test_add_column_with_timestamp_type
+      def test_add_column_with_timestamp_type_coerced
+        connection.create_table :testings do |t|
+          t.column :foo, :timestamp
         end
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+        assert_equal "datetime2(6)", column.sql_type
       end
     end
   end
@@ -616,6 +663,129 @@ class MigrationTest < ActiveRecord::TestCase
   # For some reason our tests set Rails.@_env which breaks test env switching.
   coerce_tests! :test_internal_metadata_stores_environment_when_other_data_exists
   coerce_tests! :test_internal_metadata_stores_environment
+
+  # Same as original but using binary type instead of blob
+  coerce_tests! :test_add_column_with_casted_type_if_not_exists_set_to_true
+  def test_add_column_with_casted_type_if_not_exists_set_to_true_coerced
+    migration_a = Class.new(ActiveRecord::Migration::Current) {
+      def version; 100 end
+      def migrate(x)
+        add_column "people", "last_name", :binary
+      end
+    }.new
+
+    migration_b = Class.new(ActiveRecord::Migration::Current) {
+      def version; 101 end
+      def migrate(x)
+        add_column "people", "last_name", :binary, if_not_exists: true
+      end
+    }.new
+
+    ActiveRecord::Migrator.new(:up, [migration_a], @schema_migration, @internal_metadata, 100).migrate
+    assert_column Person, :last_name, "migration_a should have created the last_name column on people"
+
+    assert_nothing_raised do
+      ActiveRecord::Migrator.new(:up, [migration_b], @schema_migration, @internal_metadata, 101).migrate
+    end
+  ensure
+    Person.reset_column_information
+    if Person.column_names.include?("last_name")
+      Person.lease_connection.remove_column("people", "last_name")
+    end
+  end
+end
+
+module ActiveRecord
+  class Migration
+    class CompatibilityTest < ActiveRecord::TestCase
+      # Error message depends on the database adapter.
+      coerce_tests! :test_create_table_on_7_0
+      def test_create_table_on_7_0_coerced
+        long_table_name = "a" * (connection.table_name_length + 1)
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          @@long_table_name = long_table_name
+          def version; 100 end
+          def migrate(x)
+            create_table @@long_table_name
+          end
+        }.new
+
+        error = assert_raises(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
+        assert_match(/The identifier that starts with '#{long_table_name[0...-1]}' is too long/i, error.message)
+      ensure
+        connection.drop_table(long_table_name) rescue nil
+      end
+
+      # SQL Server truncates long table names when renaming (https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-rename-transact-sql?view=sql-server-ver16).
+      coerce_tests! :test_rename_table_on_7_0
+      def test_rename_table_on_7_0_coerced
+        long_table_name = "a" * (connection.table_name_length + 1)
+        connection.create_table(:more_testings)
+
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          @@long_table_name = long_table_name
+          def version; 100 end
+          def migrate(x)
+            rename_table :more_testings, @@long_table_name
+          end
+        }.new
+
+        ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        assert connection.table_exists?(long_table_name[0...-1])
+        assert_not connection.table_exists?(:more_testings)
+        assert connection.table_exists?(long_table_name[0...-1])
+      ensure
+        connection.drop_table(:more_testings) rescue nil
+        connection.drop_table(long_table_name[0...-1]) rescue nil
+      end
+
+      # SQL Server has a different maximum index name length.
+      coerce_tests! :test_add_index_errors_on_too_long_name_7_0
+      def test_add_index_errors_on_too_long_name_7_0_coerced
+        long_index_name = 'a' * (connection.index_name_length + 1)
+
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          @@long_index_name = long_index_name
+          def migrate(x)
+            add_column :testings, :very_long_column_name_to_test_with, :string
+            add_index :testings, [:foo, :bar, :very_long_column_name_to_test_with], name: @@long_index_name
+          end
+        }.new
+
+        error = assert_raises(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
+        assert_match(/Index name \'#{long_index_name}\' on table \'testings\' is too long/i, error.message)
+      end
+
+      # SQL Server has a different maximum index name length.
+      coerce_tests! :test_create_table_add_index_errors_on_too_long_name_7_0
+      def test_create_table_add_index_errors_on_too_long_name_7_0_coerced
+        long_index_name = 'a' * (connection.index_name_length + 1)
+
+        migration = Class.new(ActiveRecord::Migration[7.0]) {
+          @@long_index_name = long_index_name
+          def migrate(x)
+            create_table :more_testings do |t|
+              t.integer :foo
+              t.integer :bar
+              t.integer :very_long_column_name_to_test_with
+              t.index [:foo, :bar, :very_long_column_name_to_test_with], name: @@long_index_name
+            end
+          end
+        }.new
+
+        error = assert_raises(StandardError) do
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        end
+        assert_match(/Index name \'#{long_index_name}\' on table \'more_testings\' is too long/i, error.message)
+      ensure
+        connection.drop_table :more_testings rescue nil
+      end
+    end
+  end
 end
 
 class CoreTest < ActiveRecord::TestCase
@@ -641,6 +811,7 @@ end
 module ActiveRecord
   # The original module is hardcoded for PostgreSQL/SQLite/MySQL tests.
   module DatabaseTasksSetupper
+    undef_method :setup
     def setup
       @sqlserver_tasks =
         Class.new do
@@ -663,6 +834,7 @@ module ActiveRecord
       $stderr, @original_stderr = StringIO.new, $stderr
     end
 
+    undef_method :with_stubbed_new
     def with_stubbed_new
       ActiveRecord::Tasks::SQLServerDatabaseTasks.stub(:new, @sqlserver_tasks) do
         yield
@@ -782,52 +954,16 @@ end
 class DefaultScopingTest < ActiveRecord::TestCase
   # We are not doing order duplicate removal anymore.
   coerce_tests! :test_order_in_default_scope_should_not_prevail
-
-  # Use our escaped format in assertion.
-  coerce_tests! :test_with_abstract_class_scope_should_be_executed_in_correct_context
-  def test_with_abstract_class_scope_should_be_executed_in_correct_context_coerced
-    vegetarian_pattern, gender_pattern = [/[lions].[is_vegetarian]/, /[lions].[gender]/]
-    assert_match vegetarian_pattern, Lion.all.to_sql
-    assert_match gender_pattern, Lion.female.to_sql
-  end
-end
-
-require "models/post"
-require "models/subscriber"
-class EachTest < ActiveRecord::TestCase
-  # Quoting in tests does not cope with bracket quoting.
-  coerce_tests! :test_find_in_batches_should_quote_batch_order
-  def test_find_in_batches_should_quote_batch_order_coerced
-    Post.connection
-    assert_sql(/ORDER BY \[posts\]\.\[id\]/) do
-      Post.find_in_batches(:batch_size => 1) do |batch|
-        assert_kind_of Array, batch
-        assert_kind_of Post, batch.first
-      end
-    end
-  end
-
-  # Quoting in tests does not cope with bracket quoting.
-  coerce_tests! :test_in_batches_should_quote_batch_order
-  def test_in_batches_should_quote_batch_order_coerced
-    Post.connection
-    assert_sql(/ORDER BY \[posts\]\.\[id\]/) do
-      Post.in_batches(of: 1) do |relation|
-        assert_kind_of ActiveRecord::Relation, relation
-        assert_kind_of Post, relation.first
-      end
-    end
-  end
 end
 
 class EagerAssociationTest < ActiveRecord::TestCase
-  # Use LEN() vs length() function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! :test_count_with_include
   def test_count_with_include_coerced
     assert_equal 3, authors(:david).posts_with_comments.where("LEN(comments.body) > 15").references(:comments).count
   end
 
-  # Use TOP (1) in scope vs limit 1.
+  # The raw SQL in the scope uses `limit 1`.
   coerce_tests! %r{including association based on sql condition and no database column}
 end
 
@@ -841,20 +977,12 @@ class FinderTest < ActiveRecord::TestCase
   coerce_tests! %r{doesn't have implicit ordering},
                 :test_find_doesnt_have_implicit_ordering
 
-  # Square brackets around column name
-  coerce_tests! :test_exists_does_not_select_columns_without_alias
-  def test_exists_does_not_select_columns_without_alias_coerced
-    assert_sql(/SELECT\s+1 AS one FROM \[topics\].*OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) do
-      Topic.exists?
-    end
-  end
-
   # Assert SQL Server limit implementation
   coerce_tests! :test_take_and_first_and_last_with_integer_should_use_sql_limit
   def test_take_and_first_and_last_with_integer_should_use_sql_limit_coerced
-    assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 3/) { Topic.take(3).entries }
-    assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 2/) { Topic.first(2).entries }
-    assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 5/) { Topic.last(5).entries }
+    assert_queries_match(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 3/) { Topic.take(3).entries }
+    assert_queries_match(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 2/) { Topic.first(2).entries }
+    assert_queries_match(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 5/) { Topic.last(5).entries }
   end
 
   # This fails only when run in the full test suite task. Just taking it out of the mix.
@@ -885,7 +1013,7 @@ class FinderTest < ActiveRecord::TestCase
   # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
   coerce_tests! :test_include_on_unloaded_relation_with_match
   def test_include_on_unloaded_relation_with_match_coerced
-    assert_sql(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
+    assert_queries_match(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
       assert_equal true, Customer.where(name: "David").include?(customers(:david))
     end
   end
@@ -893,7 +1021,7 @@ class FinderTest < ActiveRecord::TestCase
   # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
   coerce_tests! :test_include_on_unloaded_relation_without_match
   def test_include_on_unloaded_relation_without_match_coerced
-    assert_sql(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
+    assert_queries_match(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
       assert_equal false, Customer.where(name: "David").include?(customers(:mary))
     end
   end
@@ -901,7 +1029,7 @@ class FinderTest < ActiveRecord::TestCase
   # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
   coerce_tests! :test_member_on_unloaded_relation_with_match
   def test_member_on_unloaded_relation_with_match_coerced
-    assert_sql(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
+    assert_queries_match(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
       assert_equal true, Customer.where(name: "David").member?(customers(:david))
     end
   end
@@ -909,7 +1037,7 @@ class FinderTest < ActiveRecord::TestCase
   # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
   coerce_tests! :test_member_on_unloaded_relation_without_match
   def test_member_on_unloaded_relation_without_match_coerced
-    assert_sql(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
+    assert_queries_match(/1 AS one.*FETCH NEXT @2 ROWS ONLY.*@2 = 1/) do
       assert_equal false, Customer.where(name: "David").member?(customers(:mary))
     end
   end
@@ -923,8 +1051,8 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal topics(:fifth), Topic.first
     assert_equal topics(:third), Topic.last
 
-    c = Topic.connection
-    assert_sql(/ORDER BY #{Regexp.escape(c.quote_table_name("topics.title"))} DESC, #{Regexp.escape(c.quote_table_name("topics.id"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) {
+    c = Topic.lease_connection
+    assert_queries_match(/ORDER BY #{Regexp.escape(c.quote_table_name("topics.title"))} DESC, #{Regexp.escape(c.quote_table_name("topics.id"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) {
       Topic.last
     }
   ensure
@@ -937,8 +1065,8 @@ class FinderTest < ActiveRecord::TestCase
     old_implicit_order_column = Topic.implicit_order_column
     Topic.implicit_order_column = "id"
 
-    c = Topic.connection
-    assert_sql(/ORDER BY #{Regexp.escape(c.quote_table_name("topics.id"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) {
+    c = Topic.lease_connection
+    assert_queries_match(/ORDER BY #{Regexp.escape(c.quote_table_name("topics.id"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) {
       Topic.last
     }
   ensure
@@ -951,15 +1079,101 @@ class FinderTest < ActiveRecord::TestCase
     old_implicit_order_column = NonPrimaryKey.implicit_order_column
     NonPrimaryKey.implicit_order_column = "created_at"
 
-    c = NonPrimaryKey.connection
+    c = NonPrimaryKey.lease_connection
 
-    assert_sql(/ORDER BY #{Regexp.escape(c.quote_table_name("non_primary_keys.created_at"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) {
+    assert_queries_match(/ORDER BY #{Regexp.escape(c.quote_table_name("non_primary_keys.created_at"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) {
       NonPrimaryKey.last
     }
   ensure
     NonPrimaryKey.implicit_order_column = old_implicit_order_column
   end
 
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_member_on_unloaded_relation_with_composite_primary_key
+  def test_member_on_unloaded_relation_with_composite_primary_key_coerced
+    assert_queries_match(/1 AS one.* FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1/) do
+      book = cpk_books(:cpk_great_author_first_book)
+      assert Cpk::Book.where(title: "The first book").member?(book)
+    end
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_implicit_order_column_prepends_query_constraints
+  def test_implicit_order_column_prepends_query_constraints_coerced
+    c = ClothingItem.lease_connection
+    ClothingItem.implicit_order_column = "description"
+    quoted_type = Regexp.escape(c.quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(c.quote_table_name("clothing_items.color"))
+    quoted_descrption = Regexp.escape(c.quote_table_name("clothing_items.description"))
+
+    assert_queries_match(/ORDER BY #{quoted_descrption} ASC, #{quoted_type} ASC, #{quoted_color} ASC OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
+    end
+  ensure
+    ClothingItem.implicit_order_column = nil
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! %r{#last for a model with composite query constraints}
+  test "#last for a model with composite query constraints coerced" do
+    c = ClothingItem.lease_connection
+    quoted_type = Regexp.escape(c.quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(c.quote_table_name("clothing_items.color"))
+
+    assert_queries_match(/ORDER BY #{quoted_type} DESC, #{quoted_color} DESC OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1/i) do
+      assert_kind_of ClothingItem, ClothingItem.last
+    end
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! %r{#first for a model with composite query constraints}
+  test "#first for a model with composite query constraints coerced" do
+    c = ClothingItem.lease_connection
+    quoted_type = Regexp.escape(c.quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(c.quote_table_name("clothing_items.color"))
+
+    assert_queries_match(/ORDER BY #{quoted_type} ASC, #{quoted_color} ASC OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
+    end
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_implicit_order_column_reorders_query_constraints
+  def test_implicit_order_column_reorders_query_constraints_coerced
+    c = ClothingItem.lease_connection
+    ClothingItem.implicit_order_column = "color"
+    quoted_type = Regexp.escape(c.quote_table_name("clothing_items.clothing_type"))
+    quoted_color = Regexp.escape(c.quote_table_name("clothing_items.color"))
+
+    assert_queries_match(/ORDER BY #{quoted_color} ASC, #{quoted_type} ASC OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1/i) do
+      assert_kind_of ClothingItem, ClothingItem.first
+    end
+  ensure
+    ClothingItem.implicit_order_column = nil
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_include_on_unloaded_relation_with_composite_primary_key
+  def test_include_on_unloaded_relation_with_composite_primary_key_coerced
+    assert_queries_match(/1 AS one.*OFFSET 0 ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1/) do
+      book = cpk_books(:cpk_great_author_first_book)
+      assert Cpk::Book.where(title: "The first book").include?(book)
+    end
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_nth_to_last_with_order_uses_limit
+  def test_nth_to_last_with_order_uses_limit_coerced
+    c = Topic.lease_connection
+    assert_queries_match(/ORDER BY #{Regexp.escape(c.quote_table_name("topics.id"))} DESC OFFSET @(\d) ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1.*@\2 = 1/i) do
+      Topic.second_to_last
+    end
+
+    assert_queries_match(/ORDER BY #{Regexp.escape(c.quote_table_name("topics.updated_at"))} DESC OFFSET @(\d) ROWS FETCH NEXT @(\d) ROWS ONLY.*@\1 = 1.*@\2 = 1/i) do
+      Topic.order(:updated_at).second_to_last
+    end
+  end
+
   # SQL Server is unable to use aliased SELECT in the HAVING clause.
   coerce_tests! :test_include_on_unloaded_relation_with_having_referencing_aliased_select
 end
@@ -967,7 +1181,7 @@ end
 module ActiveRecord
   class Migration
     class ForeignKeyTest < ActiveRecord::TestCase
-      # We do not support :restrict.
+      # SQL Server does not support 'restrict' for 'on_update' or 'on_delete'.
       coerce_tests! :test_add_on_delete_restrict_foreign_key
       def test_add_on_delete_restrict_foreign_key_coerced
         assert_raises ArgumentError do
@@ -977,6 +1191,19 @@ module ActiveRecord
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :restrict
         end
       end
+
+      # Error message depends on the database adapter.
+      coerce_tests! :test_add_foreign_key_with_if_not_exists_not_set
+      def test_add_foreign_key_with_if_not_exists_not_set_coerced
+        @connection.add_foreign_key :astronauts, :rockets
+        assert_equal 1, @connection.foreign_keys("astronauts").size
+
+        error = assert_raises do
+          @connection.add_foreign_key :astronauts, :rockets
+        end
+
+        assert_match(/TinyTds::Error: There is already an object named '.*' in the database/, error.message)
+      end
     end
   end
 end
@@ -990,7 +1217,7 @@ class HasOneAssociationsTest < ActiveRecord::TestCase
   def test_has_one_coerced
     firm = companies(:first_firm)
     first_account = Account.find(1)
-    assert_sql(/FETCH NEXT @(\d) ROWS ONLY(.)*@\1 = 1/) do
+    assert_queries_match(/FETCH NEXT @(\d) ROWS ONLY(.)*@\1 = 1/) do
       assert_equal first_account, firm.account
       assert_equal first_account.credit_limit, firm.account.credit_limit
     end
@@ -1002,33 +1229,12 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   coerce_tests! :test_has_one_through_executes_limited_query
   def test_has_one_through_executes_limited_query_coerced
     boring_club = clubs(:boring_club)
-    assert_sql(/FETCH NEXT @(\d) ROWS ONLY(.)*@\1 = 1/) do
+    assert_queries_match(/FETCH NEXT @(\d) ROWS ONLY(.)*@\1 = 1/) do
       assert_equal boring_club, @member.general_club
     end
   end
 end
 
-require "models/company"
-class InheritanceTest < ActiveRecord::TestCase
-  # Rails test required inserting to a identity column.
-  coerce_tests! :test_a_bad_type_column
-  def test_a_bad_type_column_coerced
-    Company.connection.with_identity_insert_enabled("companies") do
-      Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
-    end
-    assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
-  end
-
-  # Use Square brackets around column name
-  coerce_tests! :test_eager_load_belongs_to_primary_key_quoting
-  def test_eager_load_belongs_to_primary_key_quoting_coerced
-    Account.connection
-    assert_sql(/\[companies\]\.\[id\] = @0.* @0 = 1/) do
-      Account.all.merge!(:includes => :firm).find(1)
-    end
-  end
-end
-
 class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   # Uses || operator in SQL. Just trust core gets value out of this test.
   coerce_tests! :test_does_not_override_select
@@ -1073,6 +1279,9 @@ class PersistenceTest < ActiveRecord::TestCase
     assert_not_predicate topic, :approved?
     assert_equal "The First Topic", topic.title
   end
+
+  # In SQL Server it's not possible to set the primary key column using a trigger and to get it then to return.
+  coerce_tests! :test_model_with_no_auto_populated_fields_still_returns_primary_key_after_insert
 end
 
 require "models/author"
@@ -1084,12 +1293,46 @@ class UpdateAllTest < ActiveRecord::TestCase
     _(david.id).must_equal 1
     _(mary.id).must_equal 2
     _(david.name).wont_equal mary.name
-    assert_sql(/UPDATE.*\(SELECT \[authors\].\[id\] FROM \[authors\].*ORDER BY \[authors\].\[id\]/i) do
+    assert_queries_match(/UPDATE.*\(SELECT \[authors\].\[id\] FROM \[authors\].*ORDER BY \[authors\].\[id\]/i) do
       Author.where("[id] > 1").order(:id).update_all(name: "Test")
     end
     _(david.reload.name).must_equal "David"
     _(mary.reload.name).must_equal "Test"
   end
+
+  # SELECT columns must be in the GROUP clause.
+  coerce_tests! :test_update_all_with_group_by
+  def test_update_all_with_group_by_coerced
+    minimum_comments_count = 2
+
+    Post.most_commented(minimum_comments_count).update_all(title: "ig")
+    posts = Post.select(:id, :title).group(:title).most_commented(minimum_comments_count).all.to_a
+
+    assert_operator posts.length, :>, 0
+    assert posts.all? { |post| post.comments.length >= minimum_comments_count }
+    assert posts.all? { |post| "ig" == post.title }
+
+    post = Post.select(:id, :title).group(:title).joins(:comments).group("posts.id").having("count(comments.id) < #{minimum_comments_count}").first
+    assert_not_equal "ig", post.title
+  end
+end
+
+class DeleteAllTest < ActiveRecord::TestCase
+  # SELECT columns must be in the GROUP clause.
+  coerce_tests! :test_delete_all_with_group_by_and_having
+  def test_delete_all_with_group_by_and_having_coerced
+    minimum_comments_count = 2
+    posts_to_be_deleted = Post.select(:id).most_commented(minimum_comments_count).all.to_a
+    assert_operator posts_to_be_deleted.length, :>, 0
+
+    assert_difference("Post.count", -posts_to_be_deleted.length) do
+      Post.most_commented(minimum_comments_count).delete_all
+    end
+
+    posts_to_be_deleted.each do |deleted_post|
+      assert_raise(ActiveRecord::RecordNotFound) { deleted_post.reload }
+    end
+  end
 end
 
 require "models/topic"
@@ -1109,65 +1352,27 @@ module ActiveRecord
   end
 end
 
-class PrimaryKeysTest < ActiveRecord::TestCase
-  # SQL Server does not have query for release_savepoint
-  coerce_tests! :test_create_without_primary_key_no_extra_query
-  def test_create_without_primary_key_no_extra_query_coerced
-    klass = Class.new(ActiveRecord::Base) do
-      self.table_name = "dashboards"
-    end
-    klass.create! # warmup schema cache
-    assert_queries(2, ignore_none: true) { klass.create! }
-  end
-end
-
 require "models/task"
 class QueryCacheTest < ActiveRecord::TestCase
   # SQL Server adapter not in list of supported adapters in original test.
   coerce_tests! :test_cache_does_not_wrap_results_in_arrays
   def test_cache_does_not_wrap_results_in_arrays_coerced
     Task.cache do
-      assert_equal 2, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-    end
-  end
-
-  # Same as original test except that we expect one query to be performed to retrieve the table's primary key.
-  # When we generate the SQL for the `find` it includes ordering on the primary key. If we reset the column
-  # information then the primary key needs to be retrieved from the database again to generate the SQL causing the
-  # original test's `assert_no_queries` assertion to fail. Assert that the query was to get the primary key.
-  coerce_tests! :test_query_cached_even_when_types_are_reset
-  def test_query_cached_even_when_types_are_reset_coerced
-    Task.cache do
-      # Warm the cache
-      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)
-
-      # Clear places where type information is cached
-      Task.reset_column_information
-      Task.initialize_find_by_cache
-      Task.define_attribute_methods
-
-      assert_queries(1, ignore_none: true) do
-        Task.find(1)
-      end
-
-      assert_includes ActiveRecord::SQLCounter.log_all.first, "TC.CONSTRAINT_TYPE = N''PRIMARY KEY''"
+      assert_equal 2, Task.lease_connection.select_value("SELECT count(*) AS count_all FROM tasks")
     end
   end
 end
 
 require "models/post"
 class RelationTest < ActiveRecord::TestCase
-  # Use LEN vs LENGTH function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! :test_reverse_order_with_function
   def test_reverse_order_with_function_coerced
     topics = Topic.order(Arel.sql("LEN(title)")).reverse_order
     assert_equal topics(:second).title, topics.first.title
   end
 
-  # Use LEN vs LENGTH function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! :test_reverse_order_with_function_other_predicates
   def test_reverse_order_with_function_other_predicates_coerced
     topics = Topic.order(Arel.sql("author_name, LEN(title), id")).reverse_order
@@ -1185,24 +1390,19 @@ class RelationTest < ActiveRecord::TestCase
     sql_log = capture_sql do
       assert Post.order(:title).reorder(nil).take
     end
-    assert sql_log.none? { |sql| /order by [posts].[title]/i.match?(sql) }, "ORDER BY title was used in the query: #{sql_log}"
+    assert sql_log.none? { |sql| /order by \[posts\]\.\[title\]/i.match?(sql) }, "ORDER BY title was used in the query: #{sql_log}"
     assert sql_log.all?  { |sql| /order by \[posts\]\.\[id\]/i.match?(sql) }, "default ORDER BY ID was not used in the query: #{sql_log}"
   end
 
   # We have implicit ordering, via FETCH.
   coerce_tests! :test_reorder_with_first
   def test_reorder_with_first_coerced
+    post = nil
     sql_log = capture_sql do
-      message = <<~MSG.squish
-        `.reorder(nil)` with `.first` / `.first!` no longer
-        takes non-deterministic result in Rails 6.2.
-        To continue taking non-deterministic result, use `.take` / `.take!` instead.
-      MSG
-      assert_deprecated(message) do
-        assert Post.order(:title).reorder(nil).first
-      end
+      post = Post.order(:title).reorder(nil).first
     end
-    assert sql_log.none? { |sql| /order by [posts].[title]/i.match?(sql) }, "ORDER BY title was used in the query: #{sql_log}"
+    assert_equal posts(:welcome), post
+    assert sql_log.none? { |sql| /order by \[posts\]\.\[title\]/i.match?(sql) }, "ORDER BY title was used in the query: #{sql_log}"
     assert sql_log.all?  { |sql| /order by \[posts\]\.\[id\]/i.match?(sql) }, "default ORDER BY ID was not used in the query: #{sql_log}"
   end
 
@@ -1212,22 +1412,55 @@ class RelationTest < ActiveRecord::TestCase
   # We are not doing order duplicate removal anymore.
   coerce_tests! :test_default_scope_order_with_scope_order
 
-  # Leave it up to users to format selects/functions so HAVING works correctly.
+  # Order column must be in the GROUP clause.
   coerce_tests! :test_multiple_where_and_having_clauses
+  def test_multiple_where_and_having_clauses_coerced
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title)
+                            .having(id: post.id).where(title: post.title).group(:id).select(:id)
+
+    assert_equal [post], having_then_where
+  end
+
+  # Order column must be in the GROUP clause.
   coerce_tests! :test_having_with_binds_for_both_where_and_having
+  def test_having_with_binds_for_both_where_and_having
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title).group(:id).select(:id)
+    where_then_having = Post.where(title: post.title).having(id: post.id).group(:id).select(:id)
+
+    assert_equal [post], having_then_where
+    assert_equal [post], where_then_having
+  end
 
   # Find any limit via our expression.
   coerce_tests! %r{relations don't load all records in #inspect}
   def test_relations_dont_load_all_records_in_inspect_coerced
-    assert_sql(/NEXT @0 ROWS.*@0 = \d+/) do
+    assert_queries_match(/NEXT @0 ROWS.*@0 = \d+/) do
       Post.all.inspect
     end
   end
 
-  # I wanted to add `.order("author_id")` scope to avoid error: Column "posts.id" is invalid in the ORDER BY
-  # However, this pull request on Rails core drops order on exists relation. https://github.com/rails/rails/pull/28699
-  # so we are skipping all together.
+  # Find any limit via our expression.
+  coerce_tests! %r{relations don't load all records in #pretty_print}
+  def test_relations_dont_load_all_records_in_pretty_print_coerced
+    assert_queries_match(/FETCH NEXT @(\d) ROWS ONLY/) do
+      PP.pp Post.all, StringIO.new # avoid outputting.
+    end
+  end
+
+  # Order column must be in the GROUP clause.
   coerce_tests! :test_empty_complex_chained_relations
+  def test_empty_complex_chained_relations_coerced
+    posts = Post.select("comments_count").where("id is not null").group("author_id", "id").where("legacy_comments_count > 0")
+
+    assert_queries_count(1) { assert_equal false, posts.empty? }
+    assert_not_predicate posts, :loaded?
+
+    no_posts = posts.where(title: "")
+    assert_queries_count(1) { assert_equal true, no_posts.empty? }
+    assert_not_predicate no_posts, :loaded?
+  end
 
   # Can't apply offset without ORDER
   coerce_tests! %r{using a custom table affects the wheres}
@@ -1245,7 +1478,7 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal post, custom_post_relation.joins(:author).where!(title: post.title).order(:id).take
   end
 
-  # Use LEN() vs length() function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! :test_reverse_arel_assoc_order_with_function
   def test_reverse_arel_assoc_order_with_function_coerced
     topics = Topic.order(Arel.sql("LEN(title)") => :asc).reverse_order
@@ -1260,21 +1493,11 @@ module ActiveRecord
 
     coerce_tests! :test_does_not_duplicate_optimizer_hints_on_merge
     def test_does_not_duplicate_optimizer_hints_on_merge_coerced
-      escaped_table = Post.connection.quote_table_name("posts")
+      escaped_table = Post.lease_connection.quote_table_name("posts")
       expected = "SELECT #{escaped_table}.* FROM #{escaped_table} OPTION (OMGHINT)"
       query = Post.optimizer_hints("OMGHINT").merge(Post.optimizer_hints("OMGHINT")).to_sql
       assert_equal expected, query
     end
-
-    # Original Rails test fails on Windows CI because the dump file was not being binary read.
-    coerce_tests! :test_marshal_load_legacy_relation
-    def test_marshal_load_legacy_relation_coerced
-      path = File.expand_path(
-        "support/marshal_compatibility_fixtures/legacy_relation.dump",
-        ARTest::SQLServer.root_activerecord_test
-      )
-      assert_equal 11, Marshal.load(File.binread(path)).size
-    end
   end
 end
 
@@ -1293,17 +1516,44 @@ class SanitizeTest < ActiveRecord::TestCase
       }
     end
 
-    assert_sql(/LIKE N'20!% !_reduction!_!!'/) do
+    assert_queries_match(/LIKE @0/) do
       searchable_post.search_as_method("20% _reduction_!").to_a
     end
 
-    assert_sql(/LIKE N'20!% !_reduction!_!!'/) do
+    assert_queries_match(/LIKE @0/) do
       searchable_post.search_as_scope("20% _reduction_!").to_a
     end
   end
+
+  # Use nvarchar string (N'') in assert
+  coerce_tests! :test_named_bind_with_literal_colons
+  def test_named_bind_with_literal_colons_coerced
+    assert_equal "TO_TIMESTAMP(N'2017/08/02 10:59:00', 'YYYY/MM/DD HH12:MI:SS')", bind("TO_TIMESTAMP(:date, 'YYYY/MM/DD HH12\\:MI\\:SS')", date: "2017/08/02 10:59:00")
+    assert_raise(ActiveRecord::PreparedStatementInvalid) { bind "TO_TIMESTAMP(:date, 'YYYY/MM/DD HH12:MI:SS')", date: "2017/08/02 10:59:00" }
+  end
 end
 
 class SchemaDumperTest < ActiveRecord::TestCase
+  # Use nvarchar string (N'') in assert
+  coerce_tests! :test_dump_schema_information_outputs_lexically_reverse_ordered_versions_regardless_of_database_order
+  def test_dump_schema_information_outputs_lexically_reverse_ordered_versions_regardless_of_database_order_coerced
+    versions = %w{ 20100101010101 20100201010101 20100301010101 }
+    versions.shuffle.each do |v|
+      @schema_migration.create_version(v)
+    end
+
+    schema_info = ActiveRecord::Base.lease_connection.dump_schema_information
+    expected = <<~STR
+    INSERT INTO #{ActiveRecord::Base.lease_connection.quote_table_name("schema_migrations")} (version) VALUES
+    (N'20100301010101'),
+    (N'20100201010101'),
+    (N'20100101010101');
+    STR
+    assert_equal expected.strip, schema_info
+  ensure
+    @schema_migration.delete_all_versions
+  end
+
   # We have precision to 38.
   coerce_tests! :test_schema_dump_keeps_large_precision_integer_columns_as_decimal
   def test_schema_dump_keeps_large_precision_integer_columns_as_decimal_coerced
@@ -1311,7 +1561,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
     assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 38}, output
   end
 
-  # This is a poorly written test and really does not catch the bottom'ness it is meant too. Ours throw it off.
+  # This is a poorly written test and really does not catch the bottom'ness it is meant to. Ours throw it off.
   coerce_tests! :test_foreign_keys_are_dumped_at_the_bottom_to_circumvent_dependency_issues
 
   # Fall through false positive with no filter.
@@ -1327,11 +1577,50 @@ class SchemaDumperTest < ActiveRecord::TestCase
     output = dump_all_table_schema([/^[^n]/])
     assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 2\.78}, output
   end
+
+  # Tests are not about a specific adapter.
+  coerce_tests! :test_do_not_dump_foreign_keys_when_bypassed_by_config
+
+  # SQL Server formats the check constraint expression differently.
+  coerce_tests! :test_schema_dumps_check_constraints
+  def test_schema_dumps_check_constraints_coerced
+    constraint_definition = dump_table_schema("products").split(/\n/).grep(/t.check_constraint.*products_price_check/).first.strip
+    assert_equal 't.check_constraint "[price]>[discounted_price]", name: "products_price_check"', constraint_definition
+  end
 end
 
 class SchemaDumperDefaultsTest < ActiveRecord::TestCase
   # These date formats do not match ours. We got these covered in our dumper tests.
   coerce_tests! :test_schema_dump_defaults_with_universally_supported_types
+
+  # SQL Server uses different method to generate a UUID than Rails test uses. Reimplemented the
+  # test in 'SchemaDumperDefaultsCoerceTest'.
+  coerce_tests! :test_schema_dump_with_text_column
+end
+
+class SchemaDumperDefaultsCoerceTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table :dump_defaults, force: true do |t|
+      t.string   :string_with_default,   default: "Hello!"
+      t.date     :date_with_default,     default: "2014-06-05"
+      t.datetime :datetime_with_default, default: "2014-06-05 07:17:04"
+      t.time     :time_with_default,     default: "07:17:04"
+      t.decimal  :decimal_with_default,  default: "1234567890.0123456789", precision: 20, scale: 10
+
+      t.text     :text_with_default, default: "John' Doe"
+      t.text     :uuid, default: -> { "newid()" }
+    end
+  end
+
+  def test_schema_dump_with_text_column_coerced
+    output = dump_table_schema("dump_defaults")
+
+    assert_match %r{t\.text\s+"text_with_default",.*?default: "John' Doe"}, output
+    assert_match %r{t\.text\s+"uuid",.*?default: -> \{ "newid\(\)" \}}, output
+  end
 end
 
 class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
@@ -1341,14 +1630,92 @@ end
 
 require "models/topic"
 class TransactionTest < ActiveRecord::TestCase
-  # SQL Server does not have query for release_savepoint
+  # SQL Server does not have query for release_savepoint.
   coerce_tests! :test_releasing_named_savepoints
   def test_releasing_named_savepoints_coerced
     Topic.transaction do
-      Topic.connection.create_savepoint("another")
-      Topic.connection.release_savepoint("another")
-      # We do not have a notion of releasing, so this does nothing vs raise an error.
-      Topic.connection.release_savepoint("another")
+      Topic.lease_connection.materialize_transactions
+
+      Topic.lease_connection.create_savepoint("another")
+      Topic.lease_connection.release_savepoint("another")
+
+      # We do not have a notion of releasing, so this does nothing and doesn't raise an error.
+      assert_nothing_raised do
+        Topic.lease_connection.release_savepoint("another")
+      end
+    end
+  end
+
+  # SQL Server does not have query for release_savepoint.
+  coerce_tests! :test_nested_transactions_after_disable_lazy_transactions
+  def test_nested_transactions_after_disable_lazy_transactions_coerced
+    Topic.lease_connection.disable_lazy_transactions!
+
+    actual_queries = capture_sql(include_schema: true) do
+      # RealTransaction (begin..commit)
+      Topic.transaction(requires_new: true) do
+        # ResetParentTransaction (no queries)
+        Topic.transaction(requires_new: true) do
+          Topic.delete_all
+          # SavepointTransaction (savepoint..release)
+          Topic.transaction(requires_new: true) do
+            # ResetParentTransaction (no queries)
+            Topic.transaction(requires_new: true) do
+              # no-op
+            end
+          end
+        end
+        Topic.delete_all
+      end
+    end
+
+    expected_queries = [
+      /BEGIN/i,
+      /DELETE/i,
+      /^SAVE TRANSACTION/i,
+      /DELETE/i,
+      /COMMIT/i,
+    ]
+
+    assert_equal expected_queries.size, actual_queries.size
+    expected_queries.zip(actual_queries) do |expected, actual|
+      assert_match expected, actual
+    end
+  end
+
+  # SQL Server does not have query for release_savepoint.
+  coerce_tests! :test_nested_transactions_skip_excess_savepoints
+  def test_nested_transactions_skip_excess_savepoints_coerced
+    actual_queries = capture_sql(include_schema: true) do
+      # RealTransaction (begin..commit)
+      Topic.transaction(requires_new: true) do
+        # ResetParentTransaction (no queries)
+        Topic.transaction(requires_new: true) do
+          Topic.delete_all
+          # SavepointTransaction (savepoint..release)
+          Topic.transaction(requires_new: true) do
+            # ResetParentTransaction (no queries)
+            Topic.transaction(requires_new: true) do
+              Topic.delete_all
+            end
+          end
+        end
+        Topic.delete_all
+      end
+    end
+
+    expected_queries = [
+      /BEGIN/i,
+      /DELETE/i,
+      /^SAVE TRANSACTION/i,
+      /DELETE/i,
+      /DELETE/i,
+      /COMMIT/i,
+    ]
+
+    assert_equal expected_queries.size, actual_queries.size
+    expected_queries.zip(actual_queries) do |expected, actual|
+      assert_match expected, actual
     end
   end
 end
@@ -1402,7 +1769,8 @@ class YamlSerializationTest < ActiveRecord::TestCase
   coerce_tests! :test_types_of_virtual_columns_are_not_changed_on_round_trip
   def test_types_of_virtual_columns_are_not_changed_on_round_trip_coerced
     author = Author.select("authors.*, 5 as posts_count").first
-    dumped = YAML.load(YAML.dump(author))
+    dumped_author = YAML.dump(author)
+    dumped = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(dumped_author) : YAML.load(dumped_author)
     assert_equal 5, author.posts_count
     assert_equal 5, dumped.posts_count
   end
@@ -1463,6 +1831,9 @@ class TimePrecisionTest < ActiveRecord::TestCase
 
   # SQL Server uses default precision for time.
   coerce_tests! :test_no_time_precision_isnt_truncated_on_assignment
+
+  # SQL Server accepts precision of 7 for time.
+  coerce_tests! :test_invalid_time_precision_raises_error
 end
 
 class DefaultNumbersTest < ActiveRecord::TestCase
@@ -1478,8 +1849,8 @@ class DefaultNumbersTest < ActiveRecord::TestCase
   coerce_tests! :test_default_negative_integer
   def test_default_negative_integer_coerced
     record = DefaultNumber.new
-    assert_equal -5, record.negative_integer
-    assert_equal -5, record.negative_integer_before_type_cast
+    assert_equal (-5), record.negative_integer
+    assert_equal (-5), record.negative_integer_before_type_cast
   end
 
   # We do better with native types and do not return strings for everything.
@@ -1517,12 +1888,12 @@ module ActiveRecord
     # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
     coerce_tests! :test_statement_cache_values_differ
     def test_statement_cache_values_differ_coerced
-      Book.connection.remove_index(:books, column: [:author_id, :name])
+      Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
       original_test_statement_cache_values_differ
     ensure
       Book.where(author_id: nil, name: 'my book').delete_all
-      Book.connection.add_index(:books, [:author_id, :name], unique: true)
+      Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
     end
   end
 end
@@ -1568,8 +1939,9 @@ module ActiveRecord
       end
 
       # We need to give the full path for this to work.
+      undef_method :schema_dump_path
       def schema_dump_path
-        File.join ARTest::SQLServer.root_activerecord, "test/assets/schema_dump_5_1.yml"
+        File.join(ARTest::SQLServer.root_activerecord, "test/assets/schema_dump_5_1.yml")
       end
     end
   end
@@ -1580,7 +1952,7 @@ require "models/comment"
 class UnsafeRawSqlTest < ActiveRecord::TestCase
   fixtures :posts
 
-  # Use LEN() vs length() function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! %r{order: always allows Arel}
   test "order: always allows Arel" do
     titles = Post.order(Arel.sql("len(title)")).pluck(:title)
@@ -1588,7 +1960,7 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_not_empty titles
   end
 
-  # Use LEN() vs length() function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! %r{pluck: always allows Arel}
   test "pluck: always allows Arel" do
     excepted_values = Post.includes(:comments).pluck(:title).map { |title| [title, title.size] }
@@ -1597,7 +1969,7 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_equal excepted_values, values
   end
 
-  # Use LEN() vs length() function.
+  # Use LEN() instead of LENGTH() function.
   coerce_tests! %r{order: allows valid Array arguments}
   test "order: allows valid Array arguments" do
     ids_expected = Post.order(Arel.sql("author_id, len(title)")).pluck(:id)
@@ -1607,6 +1979,27 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_equal ids_expected, ids
   end
 
+  # Use LEN() instead of LENGTH() function.
+  coerce_tests! %r{order: allows nested functions}
+  test "order: allows nested functions" do
+    ids_expected = Post.order(Arel.sql("author_id, len(trim(title))")).pluck(:id)
+
+    # $DEBUG = true
+    ids = Post.order("author_id, len(trim(title))").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  # Use LEN() instead of LENGTH() function.
+  coerce_tests! %r{pluck: allows nested functions}
+  test "pluck: allows nested functions" do
+    title_lengths_expected = Post.pluck(Arel.sql("len(trim(title))"))
+
+    title_lengths = Post.pluck("len(trim(title))")
+
+    assert_equal title_lengths_expected, title_lengths
+  end
+
   test "order: allows string column names that are quoted" do
     ids_expected = Post.order(Arel.sql("id")).pluck(:id)
 
@@ -1670,6 +2063,18 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
 
     assert_equal titles_expected, titles
   end
+
+  # Collation name should not be quoted. Hardcoded values for different adapters.
+  coerce_tests! %r{order: allows valid arguments with COLLATE}
+  test "order: allows valid arguments with COLLATE" do
+    collation_name = "Latin1_General_CS_AS_WS"
+
+    ids_expected = Post.order(Arel.sql(%Q'author_id, title COLLATE #{collation_name} DESC')).pluck(:id)
+
+    ids = Post.order(["author_id", %Q'title COLLATE #{collation_name} DESC']).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
 end
 
 class ReservedWordTest < ActiveRecord::TestCase
@@ -1718,14 +2123,14 @@ class RelationMergingTest < ActiveRecord::TestCase
 
     non_mary_and_bob = Author.where.not(id: [mary, bob])
 
-    author_id = Author.connection.quote_table_name("authors.id")
-    assert_sql(/WHERE #{Regexp.escape(author_id)} NOT IN \((@\d), \g<1>\)'/) do
+    author_id = Author.lease_connection.quote_table_name("authors.id")
+    assert_queries_match(/WHERE #{Regexp.escape(author_id)} NOT IN \((@\d), \g<1>\)'/) do
       assert_equal [david], non_mary_and_bob.merge(non_mary_and_bob)
     end
 
     only_david = Author.where("#{author_id} IN (?)", david)
 
-    assert_sql(/WHERE \(#{Regexp.escape(author_id)} IN \(1\)\)\z/) do
+    assert_queries_match(/WHERE \(#{Regexp.escape(author_id)} IN \(@\d\)\)/) do
       assert_equal [david], only_david.merge(only_david)
     end
   end
@@ -1745,45 +2150,56 @@ class EnumTest < ActiveRecord::TestCase
   # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
   coerce_tests! %r{enums are distinct per class}
   test "enums are distinct per class coerced" do
-    Book.connection.remove_index(:books, column: [:author_id, :name])
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
     send(:'original_enums are distinct per class')
   ensure
     Book.where(author_id: nil, name: nil).delete_all
-    Book.connection.add_index(:books, [:author_id, :name], unique: true)
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
   end
 
   # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
   coerce_tests! %r{creating new objects with enum scopes}
   test "creating new objects with enum scopes coerced" do
-    Book.connection.remove_index(:books, column: [:author_id, :name])
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
     send(:'original_creating new objects with enum scopes')
   ensure
     Book.where(author_id: nil, name: nil).delete_all
-    Book.connection.add_index(:books, [:author_id, :name], unique: true)
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
   end
 
   # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
   coerce_tests! %r{enums are inheritable}
   test "enums are inheritable coerced" do
-    Book.connection.remove_index(:books, column: [:author_id, :name])
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
     send(:'original_enums are inheritable')
   ensure
     Book.where(author_id: nil, name: nil).delete_all
-    Book.connection.add_index(:books, [:author_id, :name], unique: true)
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
   end
 
   # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
   coerce_tests! %r{declare multiple enums at a time}
   test "declare multiple enums at a time coerced" do
-    Book.connection.remove_index(:books, column: [:author_id, :name])
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
     send(:'original_declare multiple enums at a time')
   ensure
     Book.where(author_id: nil, name: nil).delete_all
-    Book.connection.add_index(:books, [:author_id, :name], unique: true)
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+  end
+
+  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+  coerce_tests! %r{serializable\? with large number label}
+  test "serializable? with large number label coerced" do
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
+
+    send(:'original_serializable\? with large number label')
+  ensure
+    Book.where(author_id: nil, name: nil).delete_all
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
   end
 end
 
@@ -1796,18 +2212,6 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
       Task.cache { 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 }]) }
-    end
-
-    assert_called(ActiveRecord::Base.connection, :clear_query_cache, times: 2) do
-      Task.cache { 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 }]) }
-    end
-
     assert_raises(ArgumentError, /does not support upsert/) do
       Task.cache { Task.upsert({ starting: Time.now }) }
     end
@@ -1815,6 +2219,16 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
     assert_raises(ArgumentError, /does not support upsert/) do
       Task.cache { Task.upsert_all([{ starting: Time.now }]) }
     end
+
+    Task.cache do
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert_all!([ starting: Time.now ])
+      end
+
+      assert_called(ActiveRecord::Base.connection_pool.query_cache, :clear, times: 1) do
+        Task.insert!({ starting: Time.now })
+      end
+    end
   end
 end
 
@@ -1836,7 +2250,7 @@ class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
 
     # Perform test
     citation_count = Citation.count
-    assert_sql(/WHERE \[citations\]\.\[id\] IN \(0, 1/) do
+    assert_queries_match(/WHERE \[citations\]\.\[id\] IN \(0, 1/) do
       assert_equal citation_count, Citation.eager_load(:citations).offset(0).size
     end
   end
@@ -1844,9 +2258,9 @@ end
 
 class LogSubscriberTest < ActiveRecord::TestCase
   # Call original test from coerced test. Fixes issue on CI with Rails installed as a gem.
-  coerce_tests! :test_vebose_query_logs
-  def test_vebose_query_logs_coerced
-    original_test_vebose_query_logs
+  coerce_tests! :test_verbose_query_logs
+  def test_verbose_query_logs_coerced
+    original_test_verbose_query_logs
   end
 
   # Bindings logged slightly differently.
@@ -1858,69 +2272,19 @@ class LogSubscriberTest < ActiveRecord::TestCase
   end
 end
 
-class ActiveRecordSchemaTest < ActiveRecord::TestCase
-  # Workaround for randomly failing test.
-  coerce_tests! :test_has_primary_key
-  def test_has_primary_key_coerced
-    @schema_migration.reset_column_information
-    original_test_has_primary_key
-  end
-end
-
 class ReloadModelsTest < ActiveRecord::TestCase
   # Skip test on Windows. The number of arguments passed to `IO.popen` in
   # `activesupport/lib/active_support/testing/isolation.rb` exceeds what Windows can handle.
   coerce_tests! :test_has_one_with_reload if RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
 end
 
-require "models/post"
-class AnnotateTest < ActiveRecord::TestCase
-  # Same as original coerced test except our SQL starts with `EXEC sp_executesql`.
-  # TODO: Remove coerce after Rails 7 (see https://github.com/rails/rails/pull/42027)
-  coerce_tests! :test_annotate_wraps_content_in_an_inline_comment
-  def test_annotate_wraps_content_in_an_inline_comment_coerced
-    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
-
-    assert_sql(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
-      posts = Post.select(:id).annotate("foo")
-      assert posts.first
-    end
-  end
-
-  # Same as original coerced test except our SQL starts with `EXEC sp_executesql`.
-  # TODO: Remove coerce after Rails 7 (see https://github.com/rails/rails/pull/42027)
-  coerce_tests! :test_annotate_is_sanitized
-  def test_annotate_is_sanitized_coerced
-    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
-
-    assert_sql(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
-      posts = Post.select(:id).annotate("*/foo/*")
-      assert posts.first
-    end
-
-    assert_sql(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
-      posts = Post.select(:id).annotate("**//foo//**")
-      assert posts.first
-    end
-
-    assert_sql(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/ /\* bar \*/}i) do
-      posts = Post.select(:id).annotate("*/foo/*").annotate("*/bar")
-      assert posts.first
-    end
-
-    assert_sql(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \+ MAX_EXECUTION_TIME\(1\) \*/}i) do
-      posts = Post.select(:id).annotate("+ MAX_EXECUTION_TIME(1)")
-      assert posts.first
-    end
-  end
-end
-
 class MarshalSerializationTest < ActiveRecord::TestCase
   private
 
+  undef_method :marshal_fixture_path
   def marshal_fixture_path(file_name)
     File.expand_path(
-      "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.connection.adapter_name}/#{file_name}.dump",
+      "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.lease_connection.adapter_name}/#{file_name}.dump",
       ARTest::SQLServer.test_root_sqlserver
     )
   end
@@ -1952,31 +2316,56 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   end
 end
 
-class BasePreventWritesTest < ActiveRecord::TestCase
-  # SQL Server does not have query for release_savepoint
-  coerce_tests! %r{an empty transaction does not raise if preventing writes}
-  test "an empty transaction does not raise if preventing writes coerced" do
-    ActiveRecord::Base.while_preventing_writes do
-      assert_queries(1, ignore_none: true) do
-        Bird.transaction do
-          ActiveRecord::Base.connection.materialize_transactions
-        end
-      end
+class PreloaderTest < ActiveRecord::TestCase
+  # Need to handle query parameters in SQL regex.
+  coerce_tests! :test_preloads_has_many_on_model_with_a_composite_primary_key_through_id_attribute
+  def test_preloads_has_many_on_model_with_a_composite_primary_key_through_id_attribute_coerced
+    order = cpk_orders(:cpk_groceries_order_2)
+    _shop_id, order_id = order.id
+    order_agreements = Cpk::OrderAgreement.where(order_id: order_id).to_a
+
+    assert_not_empty order_agreements
+    assert_equal order_agreements.sort, order.order_agreements.sort
+
+    loaded_order = nil
+    sql = capture_sql do
+      loaded_order = Cpk::Order.where(id: order_id).includes(:order_agreements).to_a.first
     end
+
+    assert_equal 2, sql.size
+    preload_sql = sql.last
+
+    c = Cpk::OrderAgreement.lease_connection
+    order_id_column = Regexp.escape(c.quote_table_name("cpk_order_agreements.order_id"))
+    order_id_constraint = /#{order_id_column} = @0.*@0 = \d+$/
+    expectation = /SELECT.*WHERE.* #{order_id_constraint}/
+
+    assert_match(expectation, preload_sql)
+    assert_equal order_agreements.sort, loaded_order.order_agreements.sort
   end
 
-  class BasePreventWritesLegacyTest < ActiveRecord::TestCase
-    # SQL Server does not have query for release_savepoint
-    coerce_tests! %r{an empty transaction does not raise if preventing writes}
-    test "an empty transaction does not raise if preventing writes coerced" do
-      ActiveRecord::Base.connection_handler.while_preventing_writes do
-        assert_queries(1, ignore_none: true) do
-          Bird.transaction do
-            ActiveRecord::Base.connection.materialize_transactions
-          end
-        end
-      end
+  # Need to handle query parameters in SQL regex.
+  coerce_tests! :test_preloads_belongs_to_a_composite_primary_key_model_through_id_attribute
+  def test_preloads_belongs_to_a_composite_primary_key_model_through_id_attribute_coerced
+    order_agreement = cpk_order_agreements(:order_agreement_three)
+    order = cpk_orders(:cpk_groceries_order_2)
+    assert_equal order, order_agreement.order
+
+    loaded_order_agreement = nil
+    sql = capture_sql do
+      loaded_order_agreement = Cpk::OrderAgreement.where(id: order_agreement.id).includes(:order).to_a.first
     end
+
+    assert_equal 2, sql.size
+    preload_sql = sql.last
+
+    c = Cpk::Order.lease_connection
+    order_id = Regexp.escape(c.quote_table_name("cpk_orders.id"))
+    order_constraint = /#{order_id} = @0.*@0 = \d+$/
+    expectation = /SELECT.*WHERE.* #{order_constraint}/
+
+    assert_match(expectation, preload_sql)
+    assert_equal order, loaded_order_agreement.order
   end
 end
 
@@ -1989,3 +2378,395 @@ class MultiDbMigratorTest < ActiveRecord::TestCase
   # Test fails on Windows AppVeyor CI for unknown reason.
   coerce_tests! :test_migrator_db_has_no_schema_migrations_table if RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
 end
+
+require "models/book"
+class FieldOrderedValuesTest < ActiveRecord::TestCase
+  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+  coerce_tests! :test_in_order_of_with_enums_values
+  def test_in_order_of_with_enums_values_coerced
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
+
+    original_test_in_order_of_with_enums_values
+  ensure
+    Book.where(author_id: nil, name: nil).delete_all
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+  end
+
+  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+  coerce_tests! :test_in_order_of_with_string_column
+  def test_in_order_of_with_string_column_coerced
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
+
+    original_test_in_order_of_with_string_column
+  ensure
+    Book.where(author_id: nil, name: nil).delete_all
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+  end
+
+  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+  coerce_tests! :test_in_order_of_with_enums_keys
+  def test_in_order_of_with_enums_keys_coerced
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
+
+    original_test_in_order_of_with_enums_keys
+  ensure
+    Book.where(author_id: nil, name: nil).delete_all
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+  end
+
+  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+  coerce_tests! :test_in_order_of_with_nil
+  def test_in_order_of_with_nil_coerced
+    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
+
+    original_test_in_order_of_with_nil
+  ensure
+    Book.where(author_id: nil, name: nil).delete_all
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+  end
+end
+
+require "models/dashboard"
+class QueryLogsTest < ActiveRecord::TestCase
+  # SQL requires double single-quotes.
+  coerce_tests! :test_sql_commenter_format
+  def test_sql_commenter_format_coerced
+    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+    assert_queries_match(%r{/\*application=''active_record''\*/}) do
+      Dashboard.first
+    end
+  end
+
+  # SQL requires double single-quotes.
+  coerce_tests! :test_sqlcommenter_format_value
+  def test_sqlcommenter_format_value_coerced
+    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { tracestate: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7", custom_proc: -> { "Joe's Shack" } },
+    ]
+
+    assert_queries_match(%r{custom_proc=''Joe%27s%20Shack'',tracestate=''congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7''\*/}) do
+      Dashboard.first
+    end
+  end
+
+  # SQL requires double single-quotes.
+  coerce_tests! :test_sqlcommenter_format_value_string_coercible
+  def test_sqlcommenter_format_value_string_coercible_coerced
+    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { custom_proc: -> { 1234 } },
+    ]
+
+    assert_queries_match(%r{custom_proc=''1234''\*/}) do
+      Dashboard.first
+    end
+  end
+
+  # SQL requires double single-quotes.
+  coerce_tests! :test_sqlcommenter_format_allows_string_keys
+  def test_sqlcommenter_format_allows_string_keys_coerced
+    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      {
+        "string" => "value",
+        tracestate: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7",
+        custom_proc: -> { "Joe's Shack" }
+      },
+    ]
+
+    assert_queries_match(%r{custom_proc=''Joe%27s%20Shack'',string=''value'',tracestate=''congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7''\*/}) do
+      Dashboard.first
+    end
+  end
+
+  # Invalid character encoding causes `ActiveRecord::StatementInvalid` error similar to Postgres.
+  coerce_tests! :test_invalid_encoding_query
+  def test_invalid_encoding_query_coerced
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    assert_raises ActiveRecord::StatementInvalid do
+      ActiveRecord::Base.lease_connection.execute "select 1 as '\xFF'"
+    end
+  end
+end
+
+class InsertAllTest < ActiveRecord::TestCase
+  # Same as original but using INSERTED.name as UPPER argument
+  coerce_tests! :test_insert_all_returns_requested_sql_fields
+  def test_insert_all_returns_requested_sql_fields_coerced
+    skip unless supports_insert_returning?
+
+    result = Book.insert_all! [{ name: "Rework", author_id: 1 }], returning: Arel.sql("UPPER(INSERTED.name) as name")
+    assert_equal %w[ REWORK ], result.pluck("name")
+  end
+end
+
+module ActiveRecord
+  class Migration
+    class InvalidOptionsTest < ActiveRecord::TestCase
+      # Include the additional SQL Server migration options.
+      undef_method :invalid_add_column_option_exception_message
+      def invalid_add_column_option_exception_message(key)
+        default_keys = [":limit", ":precision", ":scale", ":default", ":null", ":collation", ":comment", ":primary_key", ":if_exists", ":if_not_exists"]
+        default_keys.concat([":is_identity"]) # SQL Server additional valid keys
+
+        "Unknown key: :#{key}. Valid keys are: #{default_keys.join(", ")}"
+      end
+    end
+  end
+end
+
+# SQL Server does not support upsert. Removed dependency on `insert_all` that uses upsert.
+class ActiveRecord::Encryption::ConcurrencyTest < ActiveRecord::EncryptionTestCase
+  undef_method :thread_encrypting_and_decrypting
+  def thread_encrypting_and_decrypting(thread_label)
+    posts = 100.times.collect { |index| EncryptedPost.create! title: "Article #{index} (#{thread_label})", body: "Body #{index} (#{thread_label})" }
+
+    Thread.new do
+      posts.each.with_index do |article, index|
+        assert_encrypted_attribute article, :title, "Article #{index} (#{thread_label})"
+        article.decrypt
+        assert_not_encrypted_attribute article, :title, "Article #{index} (#{thread_label})"
+      end
+    end
+  end
+end
+
+# Need to use `install_unregistered_type_fallback` instead of `install_unregistered_type_error` so that message-pack
+# can read and write `ActiveRecord::ConnectionAdapters::SQLServer::Type::Data` objects.
+class ActiveRecordMessagePackTest < ActiveRecord::TestCase
+  private
+  undef_method :serializer
+  def serializer
+    @serializer ||= ::MessagePack::Factory.new.tap do |factory|
+      ActiveRecord::MessagePack::Extensions.install(factory)
+      ActiveSupport::MessagePack::Extensions.install(factory)
+      ActiveSupport::MessagePack::Extensions.install_unregistered_type_fallback(factory)
+    end
+  end
+end
+
+class StoreTest < ActiveRecord::TestCase
+  # Set the attribute as JSON type for the `StoreTest#saved changes tracking for accessors with json column` test.
+  Admin::User.attribute :json_options, ActiveRecord::Type::SQLServer::Json.new
+end
+
+class TestDatabasesTest < ActiveRecord::TestCase
+  # Tests are not about a specific adapter.
+  coerce_all_tests!
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlersShardingDbTest  < ActiveRecord::TestCase
+      # Tests are not about a specific adapter.
+      coerce_all_tests!
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionSwappingNestedTest < ActiveRecord::TestCase
+      # Tests are not about a specific adapter.
+      coerce_all_tests!
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlersMultiDbTest < ActiveRecord::TestCase
+      # Tests are not about a specific adapter.
+      coerce_tests! :test_switching_connections_via_handler
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandlersMultiPoolConfigTest < ActiveRecord::TestCase
+      # Tests are not about a specific adapter.
+      coerce_all_tests!
+    end
+  end
+end
+
+module ActiveRecord
+  class Migration
+    class CheckConstraintTest < ActiveRecord::TestCase
+      # SQL Server formats the check constraint expression differently.
+      coerce_tests! :test_check_constraints
+      def test_check_constraints_coerced
+        check_constraints = @connection.check_constraints("products")
+        assert_equal 1, check_constraints.size
+
+        constraint = check_constraints.first
+        assert_equal "products", constraint.table_name
+        assert_equal "products_price_check", constraint.name
+        assert_equal "[price]>[discounted_price]", constraint.expression
+      end
+
+      # SQL Server formats the check constraint expression differently.
+      coerce_tests! :test_add_check_constraint
+      def test_add_check_constraint_coerced
+        @connection.add_check_constraint :trades, "quantity > 0"
+
+        check_constraints = @connection.check_constraints("trades")
+        assert_equal 1, check_constraints.size
+
+        constraint = check_constraints.first
+        assert_equal "trades", constraint.table_name
+        assert_equal "chk_rails_2189e9f96c", constraint.name
+        assert_equal "[quantity]>(0)", constraint.expression
+      end
+
+      # SQL Server formats the check constraint expression differently.
+      coerce_tests! :test_remove_check_constraint
+      def test_remove_check_constraint_coerced
+        @connection.add_check_constraint :trades, "price > 0", name: "price_check"
+        @connection.add_check_constraint :trades, "quantity > 0", name: "quantity_check"
+
+        assert_equal 2, @connection.check_constraints("trades").size
+        @connection.remove_check_constraint :trades, name: "quantity_check"
+        assert_equal 1, @connection.check_constraints("trades").size
+
+        constraint = @connection.check_constraints("trades").first
+        assert_equal "trades", constraint.table_name
+        assert_equal "price_check", constraint.name
+        assert_equal "[price]>(0)", constraint.expression
+
+        @connection.remove_check_constraint :trades, name: :price_check # name as a symbol
+        assert_empty @connection.check_constraints("trades")
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PoolConfig
+      class ResolverTest < ActiveRecord::TestCase
+        # SQL Server was not included in the list of available adapters in the error message.
+        coerce_tests! :test_url_invalid_adapter
+        def test_url_invalid_adapter_coerced
+          error = assert_raises(AdapterNotFound) do
+            Base.connection_handler.establish_connection "ridiculous://foo?encoding=utf8"
+          end
+
+          assert_match "Database configuration specifies nonexistent 'ridiculous' adapter. Available adapters are: abstract, fake, mysql2, postgresql, sqlite3, sqlserver, trilogy. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile if it's not in the list of available adapters.", error.message
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class TableMetadataTest < ActiveSupport::TestCase
+    # Adapter returns an object that is subclass of what is expected in the original test.
+    coerce_tests! %r{#associated_table creates the right type caster for joined table with different association name}
+    def associated_table_creates_the_right_type_caster_for_joined_table_with_different_association_name_coerced
+      base_table_metadata = TableMetadata.new(AuditRequiredDeveloper, Arel::Table.new("developers"))
+
+      associated_table_metadata = base_table_metadata.associated_table("audit_logs")
+
+      assert associated_table_metadata.arel_table.type_for_attribute(:message).is_a?(ActiveRecord::Type::String)
+    end
+  end
+end
+
+module ActiveRecord
+  module TypeCaster
+    class ConnectionTest < ActiveSupport::TestCase
+      # Adapter returns an object that is subclass of what is expected in the original test.
+      coerce_tests! %r{#type_for_attribute is not aware of custom types}
+      def type_for_attribute_is_not_aware_of_custom_types_coerced
+        type_caster = Connection.new(AttributedDeveloper, "developers")
+
+        type = type_caster.type_for_attribute(:name)
+
+        assert_not_equal DeveloperName, type.class
+        assert type.is_a?(ActiveRecord::Type::String)
+      end
+    end
+  end
+end
+
+require "models/car"
+class ExplainTest < ActiveRecord::TestCase
+  # Expected query slightly different from because of 'sp_executesql' and query parameters.
+  coerce_tests! :test_relation_explain_with_first
+  def test_relation_explain_with_first_coerced
+    expected_query = capture_sql {
+      Car.all.first
+    }.first[/EXEC sp_executesql N'(.*?) NEXT/, 1]
+    message = Car.all.explain.first
+    assert_match(/^EXPLAIN/, message)
+    assert_match(expected_query, message)
+  end
+
+  # Expected query slightly different from because of 'sp_executesql' and query parameters.
+  coerce_tests! :test_relation_explain_with_last
+  def test_relation_explain_with_last_coerced
+    expected_query = capture_sql {
+      Car.all.last
+    }.first[/EXEC sp_executesql N'(.*?) NEXT/, 1]
+    expected_query = expected_query
+    message = Car.all.explain.last
+
+    assert_match(/^EXPLAIN/, message)
+    assert_match(expected_query, message)
+  end
+end
+
+module ActiveRecord
+  module Assertions
+    class QueryAssertionsTest < ActiveSupport::TestCase
+      # Query slightly different in original test.
+      coerce_tests! :test_assert_queries_match
+      def test_assert_queries_match_coerced
+        assert_queries_match(/ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY/i, count: 1) { Post.first }
+        assert_queries_match(/ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY/i) { Post.first }
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_match(/ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY/i, count: 2) { Post.first }
+        }
+        assert_match(/1 instead of 2 queries/, error.message)
+
+        error = assert_raises(Minitest::Assertion) {
+          assert_queries_match(/ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY/i, count: 0) { Post.first }
+        }
+        assert_match(/1 instead of 0 queries/, error.message)
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class WithTest < ActiveRecord::TestCase
+    # SQL contains just 'WITH' instead of 'WITH RECURSIVE' as expected by the original test.
+    coerce_tests! :test_with_recursive
+    def test_with_recursive_coerced
+      top_companies = Company.where(firm_id: nil).to_a
+      child_companies = Company.where(firm_id: top_companies).to_a
+      top_companies_and_children = (top_companies.map(&:id) + child_companies.map(&:id)).sort
+
+      relation = Company.with_recursive(
+        top_companies_and_children: [
+          Company.where(firm_id: nil),
+          Company.joins("JOIN top_companies_and_children ON companies.firm_id = top_companies_and_children.id"),
+        ]
+      ).from("top_companies_and_children AS companies")
+
+      assert_equal top_companies_and_children, relation.order(:id).pluck(:id)
+      assert_match "WITH ", relation.to_sql
+    end
+  end
+end
+