activerecord-sqlserver-adapter 6.0.1 → 6.1.1.0

data/test/cases/adapter_test_sqlserver.rb

@@ -6,6 +6,7 @@ require "models/task"
 require "models/post"
 require "models/subscriber"
 require "models/minimalistic"
+require "models/college"
 
 class AdapterTestSQLServer < ActiveRecord::TestCase
   fixtures :tasks
@@ -42,17 +43,49 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert connection.supports_ddl_transactions?
   end
 
-  it "allow owner table name prefixs like dbo to still allow table exists to return true" do
+  it "table exists works if table name prefixed by schema and owner" do
     begin
       assert_equal "topics", Topic.table_name
       assert Topic.table_exists?
+
+      # Test when owner included in table name.
       Topic.table_name = "dbo.topics"
-      assert Topic.table_exists?, "Tasks table name of dbo.topics should return true for exists."
+      assert Topic.table_exists?, "Topics table name of 'dbo.topics' should return true for exists."
+
+      # Test when database and owner included in table name.
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      Topic.table_name = "#{db_config.database}.dbo.topics"
+      assert Topic.table_exists?, "Topics table name of '[DATABASE].dbo.topics' should return true for exists."
     ensure
       Topic.table_name = "topics"
     end
   end
 
+  it "test table existence across database schemas" do
+    arunit_connection = Topic.connection
+    arunit2_connection = College.connection
+
+    arunit_database = arunit_connection.pool.db_config.database
+    arunit2_database = arunit2_connection.pool.db_config.database
+
+    # Assert that connections use different default databases schemas.
+    assert_not_equal arunit_database, arunit2_database
+
+    # Assert that the Topics table exists when using the Topics connection.
+    assert arunit_connection.table_exists?('topics'), 'Topics table exists using table name'
+    assert arunit_connection.table_exists?('dbo.topics'), 'Topics table exists using owner and table name'
+    assert arunit_connection.table_exists?("#{arunit_database}.dbo.topics"), 'Topics table exists using database, owner and table name'
+
+    # Assert that the Colleges table exists when using the Colleges connection.
+    assert arunit2_connection.table_exists?('colleges'), 'College table exists using table name'
+    assert arunit2_connection.table_exists?('dbo.colleges'), 'College table exists using owner and table name'
+    assert arunit2_connection.table_exists?("#{arunit2_database}.dbo.colleges"), 'College table exists using database, owner and table name'
+
+    # Assert that the tables exist when using each others connection.
+    assert arunit_connection.table_exists?("#{arunit2_database}.dbo.colleges"), 'Colleges table exists using Topics connection'
+    assert arunit2_connection.table_exists?("#{arunit_database}.dbo.topics"), 'Topics table exists using Colleges connection'
+  end
+
   it "return true to insert sql query for inserts only" do
     assert connection.send(:insert_sql?, "INSERT...")
     assert connection.send(:insert_sql?, "EXEC sp_executesql N'INSERT INTO [fk_test_has_fks] ([fk_id]) VALUES (@0); SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident', N'@0 int', @0 = 0")
@@ -68,21 +101,23 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
   it "test bad connection" do
     assert_raise ActiveRecord::NoDatabaseError do
-      config = ActiveRecord::Base.configurations["arunit"].merge(database: "inexistent_activerecord_unittest")
-      ActiveRecord::Base.sqlserver_connection config
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      configuration = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+      ActiveRecord::Base.sqlserver_connection configuration
     end
   end
 
   it "test database exists returns false if database does not exist" do
-    config = ActiveRecord::Base.configurations["arunit"].merge(database: "inexistent_activerecord_unittest")
-    assert_not ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(config),
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    configuration = db_config.configuration_hash.merge(database: "inexistent_activerecord_unittest")
+    assert_not ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(configuration),
                "expected database to not exist"
   end
 
   it "test database exists returns true when the database exists" do
-    config = ActiveRecord::Base.configurations["arunit"]
-    assert ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(config),
-           "expected database #{config[:database]} to exist"
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+    assert ActiveRecord::ConnectionAdapters::SQLServerAdapter.database_exists?(db_config.configuration_hash),
+           "expected database #{db_config.database} to exist"
   end
 
   describe "with different language" do
@@ -342,7 +377,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert !SSTestCustomersView.columns.blank?
       assert_equal columns.size, SSTestCustomersView.columns.size
       columns.each do |colname|
-        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
+        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServer::Column,
                            SSTestCustomersView.columns_hash[colname],
                            "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
       end
@@ -369,7 +404,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert !SSTestStringDefaultsView.columns.blank?
       assert_equal columns.size, SSTestStringDefaultsView.columns.size
       columns.each do |colname|
-        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
+        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServer::Column,
                            SSTestStringDefaultsView.columns_hash[colname],
                            "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
       end
@@ -434,12 +469,11 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   describe "block writes to a database" do
     def setup
       @conn = ActiveRecord::Base.connection
-      @connection_handler = ActiveRecord::Base.connection_handler
     end
 
     def test_errors_when_an_insert_query_is_called_while_preventing_writes
       assert_raises(ActiveRecord::ReadOnlyError) do
-        @connection_handler.while_preventing_writes do
+        ActiveRecord::Base.while_preventing_writes do
           @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
         end
       end
@@ -449,7 +483,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @conn.insert("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
       assert_raises(ActiveRecord::ReadOnlyError) do
-        @connection_handler.while_preventing_writes do
+        ActiveRecord::Base.while_preventing_writes do
           @conn.update("UPDATE [subscribers] SET [subscribers].[name] = 'Aidan' WHERE [subscribers].[nick] = 'aido'")
         end
       end
@@ -459,7 +493,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
       assert_raises(ActiveRecord::ReadOnlyError) do
-        @connection_handler.while_preventing_writes do
+        ActiveRecord::Base.while_preventing_writes do
           @conn.execute("DELETE FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
         end
       end
@@ -468,7 +502,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     def test_doesnt_error_when_a_select_query_is_called_while_preventing_writes
       @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
-      @connection_handler.while_preventing_writes do
+      ActiveRecord::Base.while_preventing_writes do
         assert_equal 1, @conn.execute("SELECT * FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
       end
     end

data/test/cases/change_column_collation_test_sqlserver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "migrations/create_clients_and_change_column_collation"
+
+class ChangeColumnCollationTestSqlServer < ActiveRecord::TestCase
+  before do
+    @old_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+    CreateClientsAndChangeColumnCollation.new.up
+  end
+
+  after do
+    CreateClientsAndChangeColumnCollation.new.down
+    ActiveRecord::Migration.verbose = @old_verbose
+  end
+
+  def find_column(table, name)
+    table.find { |column| column.name == name }
+  end
+
+  let(:clients_table) { connection.columns("clients") }
+  let(:name_column) { find_column(clients_table, "name") }
+  let(:code_column) { find_column(clients_table, "code") }
+
+  it "change column collation to other than default" do
+    _(name_column.collation).must_equal "SQL_Latin1_General_CP1_CS_AS"
+  end
+
+  it "change column collation to default" do
+    _(code_column.collation).must_equal "SQL_Latin1_General_CP1_CI_AS"
+  end
+end

data/test/cases/coerced_tests.rb

@@ -24,22 +24,35 @@ class UniquenessValidationTest < ActiveRecord::TestCase
     end
   end
 
-  # Skip the test if database is case-insensitive.
-  coerce_tests! :test_validate_case_sensitive_uniqueness_by_default
-  def test_validate_case_sensitive_uniqueness_by_default_coerced
-    database_collation = connection.select_one("SELECT collation_name FROM sys.databases WHERE name = 'activerecord_unittest'").values.first
-    skip if database_collation.include?("_CI_")
+  # Same as original coerced test except that it handles default SQL Server case-insensitive collation.
+  coerce_tests! :test_validate_uniqueness_by_default_database_collation
+  def test_validate_uniqueness_by_default_database_collation_coerced
+    Topic.validates_uniqueness_of(:author_email_address)
 
-    original_test_validate_case_sensitive_uniqueness_by_default_coerced
+    topic1 = Topic.new(author_email_address: "david@loudthinking.com")
+    topic2 = Topic.new(author_email_address: "David@loudthinking.com")
+
+    assert_equal 1, Topic.where(author_email_address: "david@loudthinking.com").count
+
+    assert_not topic1.valid?
+    assert_not topic1.save
+
+    # Case insensitive collation (SQL_Latin1_General_CP1_CI_AS) by default.
+    # Should not allow "David" if "david" exists.
+    assert_not topic2.valid?
+    assert_not topic2.save
+
+    assert_equal 1, Topic.where(author_email_address: "david@loudthinking.com").count
+    assert_equal 1, Topic.where(author_email_address: "David@loudthinking.com").count
   end
 end
 
 require "models/event"
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
-    # I really don`t think we can support legacy binds.
-    coerce_tests! :test_select_all_with_legacy_binds
-    coerce_tests! :test_insert_update_delete_with_legacy_binds
+    # 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
@@ -54,13 +67,63 @@ module ActiveRecord
         assert_not_nil error.cause
       end
     end
+  end
+end
+
+module ActiveRecord
+  class AdapterPreventWritesTest < 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_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
+    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
+  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
+    end
   end
 end
 
@@ -176,7 +239,7 @@ class BasicsTest < 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
+    ActiveRecord::Base.while_preventing_writes do
       assert_queries(1, ignore_none: true) do
         Bird.transaction do
           ActiveRecord::Base.connection.materialize_transactions
@@ -234,6 +297,55 @@ module ActiveRecord
     coerce_tests! :test_statement_cache_with_find_by
     coerce_tests! :test_statement_cache_with_in_clause
     coerce_tests! :test_statement_cache_with_sql_string_literal
+
+    # Same as original coerced test except prepared statements include `EXEC sp_executesql` wrapper.
+    coerce_tests! :test_bind_params_to_sql_with_prepared_statements, :test_bind_params_to_sql_with_unprepared_statements
+    def test_bind_params_to_sql_with_prepared_statements_coerced
+      assert_bind_params_to_sql_coerced(prepared: true)
+    end
+
+    def test_bind_params_to_sql_with_unprepared_statements_coerced
+      @connection.unprepared_statement do
+        assert_bind_params_to_sql_coerced(prepared: false)
+      end
+    end
+
+    private
+
+    def assert_bind_params_to_sql_coerced(prepared:)
+      table = Author.quoted_table_name
+      pk = "#{table}.#{Author.quoted_primary_key}"
+
+      # prepared_statements: true
+      #
+      #   EXEC sp_executesql N'SELECT [authors].* FROM [authors] WHERE [authors].[id] IN (@0, @1, @2) OR [authors].[id] IS NULL)', N'@0 bigint, @1 bigint, @2 bigint', @0 = 1, @1 = 2, @2 = 3
+      #
+      # prepared_statements: false
+      #
+      #   SELECT [authors].* FROM [authors] WHERE ([authors].[id] IN (1, 2, 3) OR [authors].[id] IS NULL)
+      #
+      sql_unprepared = "SELECT #{table}.* FROM #{table} WHERE (#{pk} IN (#{bind_params(1..3)}) OR #{pk} IS NULL)"
+      sql_prepared = "EXEC sp_executesql N'SELECT #{table}.* FROM #{table} WHERE (#{pk} IN (#{bind_params(1..3)}) OR #{pk} IS NULL)', N'@0 bigint, @1 bigint, @2 bigint', @0 = 1, @1 = 2, @2 = 3"
+
+      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 }
+
+      # prepared_statements: true
+      #
+      #   EXEC sp_executesql N'SELECT [authors].* FROM [authors] WHERE [authors].[id] IN (@0, @1, @2)', N'@0 bigint, @1 bigint, @2 bigint', @0 = 1, @1 = 2, @2 = 3
+      #
+      # prepared_statements: false
+      #
+      #   SELECT [authors].* FROM [authors] WHERE [authors].[id] IN (1, 2, 3)
+      #
+      sql_unprepared = "SELECT #{table}.* FROM #{table} WHERE #{pk} IN (#{bind_params(1..3)})"
+      sql_prepared = "EXEC sp_executesql N'SELECT #{table}.* FROM #{table} WHERE #{pk} IN (#{bind_params(1..3)})', N'@0 bigint, @1 bigint, @2 bigint', @0 = 1, @1 = 2, @2 = 3"
+
+      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 }
+    end
   end
 end
 
@@ -256,11 +368,112 @@ class CalculationsTest < ActiveRecord::TestCase
     original_test_offset_is_kept
   end
 
-  # Are decimal, not integer.
+  # The SQL Server `AVG()` function for a list of integers returns an integer (not a decimal).
   coerce_tests! :test_should_return_decimal_average_of_integer_field
   def test_should_return_decimal_average_of_integer_field_coerced
     value = Account.average(:id)
-    assert_equal BigDecimal("3.0").to_s, BigDecimal(value).to_s
+    assert_equal 3, value
+  end
+
+  # In SQL Server the `AVG()` function for a list of integers returns an integer so need to cast values as decimals before averaging.
+  # Match SQL Server limit implementation.
+  coerce_tests! :test_select_avg_with_group_by_as_virtual_attribute_with_sql
+  def test_select_avg_with_group_by_as_virtual_attribute_with_sql_coerced
+    rails_core = companies(:rails_core)
+
+    sql = <<~SQL
+      SELECT firm_id, AVG(CAST(credit_limit AS DECIMAL)) AS avg_credit_limit
+      FROM accounts
+      WHERE firm_id = ?
+      GROUP BY firm_id
+      ORDER BY firm_id
+      OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY
+    SQL
+
+    account = Account.find_by_sql([sql, rails_core]).first
+
+    # id was not selected, so it should be nil
+    # (cannot select id because it wasn't used in the GROUP BY clause)
+    assert_nil account.id
+
+    # firm_id was explicitly selected, so it should be present
+    assert_equal(rails_core, account.firm)
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, account.avg_credit_limit)
+  end
+
+  # In SQL Server the `AVG()` function for a list of integers returns an integer so need to cast values as decimals before averaging.
+  # Order column must be in the GROUP clause.
+  coerce_tests! :test_select_avg_with_group_by_as_virtual_attribute_with_ar
+  def test_select_avg_with_group_by_as_virtual_attribute_with_ar_coerced
+    rails_core = companies(:rails_core)
+
+    account = Account
+                .select(:firm_id, "AVG(CAST(credit_limit AS DECIMAL)) AS avg_credit_limit")
+                .where(firm: rails_core)
+                .group(:firm_id)
+                .order(:firm_id)
+                .take!
+
+    # id was not selected, so it should be nil
+    # (cannot select id because it wasn't used in the GROUP BY clause)
+    assert_nil account.id
+
+    # firm_id was explicitly selected, so it should be present
+    assert_equal(rails_core, account.firm)
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, account.avg_credit_limit)
+  end
+
+  # In SQL Server the `AVG()` function for a list of integers returns an integer so need to cast values as decimals before averaging.
+  # SELECT columns must be in the GROUP clause.
+  # Match SQL Server limit implementation.
+  coerce_tests! :test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_sql
+  def test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_sql_coerced
+    rails_core = companies(:rails_core)
+
+    sql = <<~SQL
+      SELECT companies.*, AVG(CAST(accounts.credit_limit AS DECIMAL)) AS avg_credit_limit
+      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
+      ORDER BY companies.id
+      OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY
+    SQL
+
+    firm = DependentFirm.find_by_sql([sql, rails_core]).first
+
+    # all the DependentFirm attributes should be present
+    assert_equal rails_core, firm
+    assert_equal rails_core.name, firm.name
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, firm.avg_credit_limit)
+  end
+
+
+  # In SQL Server the `AVG()` function for a list of integers returns an integer so need to cast values as decimals before averaging.
+  # SELECT columns must be in the GROUP clause.
+  coerce_tests! :test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_ar
+  def test_select_avg_with_joins_and_group_by_as_virtual_attribute_with_ar_coerced
+    rails_core = companies(:rails_core)
+
+    firm = DependentFirm
+             .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)
+             .take!
+
+    # all the DependentFirm attributes should be present
+    assert_equal rails_core, firm
+    assert_equal rails_core.name, firm.name
+
+    # avg_credit_limit should be present as a virtual attribute
+    assert_equal(52.5, firm.avg_credit_limit)
   end
 
   # Match SQL Server limit implementation
@@ -329,14 +542,18 @@ module ActiveRecord
       coerce_tests! :test_quote_ar_object
       def test_quote_ar_object_coerced
         value = DatetimePrimaryKey.new(id: @time)
-        assert_equal "'02-14-2017 12:34:56.79'", @connection.quote(value)
+        assert_deprecated do
+          assert_equal "'02-14-2017 12:34:56.79'", @connection.quote(value)
+        end
       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_equal "02-14-2017 12:34:56.79", @connection.type_cast(value)
+        assert_deprecated do
+          assert_equal "02-14-2017 12:34:56.79", @connection.type_cast(value)
+        end
       end
     end
   end
@@ -396,39 +613,6 @@ module ActiveRecord
 end
 
 class MigrationTest < ActiveRecord::TestCase
-  # We do not have do the DecimalWithoutScale type.
-  coerce_tests! :test_add_table_with_decimals
-  def test_add_table_with_decimals_coerced
-    Person.connection.drop_table :big_numbers rescue nil
-    assert !BigNumber.table_exists?
-    GiveMeBigNumbers.up
-    BigNumber.reset_column_information
-    assert BigNumber.create(
-      :bank_balance => 1586.43,
-      :big_bank_balance => BigDecimal("1000234000567.95"),
-      :world_population => 6000000000,
-      :my_house_population => 3,
-      :value_of_e => BigDecimal("2.7182818284590452353602875")
-    )
-    b = BigNumber.first
-    assert_not_nil b
-    assert_not_nil b.bank_balance
-    assert_not_nil b.big_bank_balance
-    assert_not_nil b.world_population
-    assert_not_nil b.my_house_population
-    assert_not_nil b.value_of_e
-    assert_kind_of BigDecimal, b.world_population
-    assert_equal "6000000000.0", b.world_population.to_s
-    assert_kind_of Integer, b.my_house_population
-    assert_equal 3, b.my_house_population
-    assert_kind_of BigDecimal, b.bank_balance
-    assert_equal BigDecimal("1586.43"), b.bank_balance
-    assert_kind_of BigDecimal, b.big_bank_balance
-    assert_equal BigDecimal("1000234000567.95"), b.big_bank_balance
-    GiveMeBigNumbers.down
-    assert_raise(ActiveRecord::StatementInvalid) { BigNumber.first }
-  end
-
   # 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
@@ -584,11 +768,6 @@ module ActiveRecord
     end
   end
 
-  class DatabaseTasksDumpSchemaCacheTest < ActiveRecord::TestCase
-    # Skip this test with /tmp/my_schema_cache.yml path on Windows.
-    coerce_tests! :test_dump_schema_cache if RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
-  end
-
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     # We extend `local_database?` so that common VM IPs can be used.
     coerce_tests! :test_ignores_remote_databases, :test_warning_for_remote_databases
@@ -653,7 +832,11 @@ class EagerAssociationTest < ActiveRecord::TestCase
 end
 
 require "models/topic"
+require "models/customer"
+require "models/non_primary_key"
 class FinderTest < ActiveRecord::TestCase
+  fixtures :customers, :topics, :authors
+
   # We have implicit ordering, via FETCH.
   coerce_tests! %r{doesn't have implicit ordering},
                 :test_find_doesnt_have_implicit_ordering
@@ -698,6 +881,87 @@ class FinderTest < ActiveRecord::TestCase
       end
     end
   end
+
+  # 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_equal true, Customer.where(name: "David").include?(customers(:david))
+    end
+  end
+
+  # 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_equal false, Customer.where(name: "David").include?(customers(:mary))
+    end
+  end
+
+  # 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_equal true, Customer.where(name: "David").member?(customers(:david))
+    end
+  end
+
+  # 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_equal false, Customer.where(name: "David").member?(customers(:mary))
+    end
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_implicit_order_column_is_configurable
+  def test_implicit_order_column_is_configurable_coerced
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = "title"
+
+    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) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_implicit_order_set_to_primary_key
+  def test_implicit_order_set_to_primary_key_coerced
+    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) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_implicit_order_for_model_without_primary_key
+  def test_implicit_order_for_model_without_primary_key_coerced
+    old_implicit_order_column = NonPrimaryKey.implicit_order_column
+    NonPrimaryKey.implicit_order_column = "created_at"
+
+    c = NonPrimaryKey.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) {
+      NonPrimaryKey.last
+    }
+  ensure
+    NonPrimaryKey.implicit_order_column = old_implicit_order_column
+  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
 
 module ActiveRecord
@@ -929,7 +1193,14 @@ class RelationTest < ActiveRecord::TestCase
   coerce_tests! :test_reorder_with_first
   def test_reorder_with_first_coerced
     sql_log = capture_sql do
-      assert Post.order(:title).reorder(nil).first
+      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
     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.all?  { |sql| /order by \[posts\]\.\[id\]/i.match?(sql) }, "default ORDER BY ID was not used in the query: #{sql_log}"
@@ -982,6 +1253,31 @@ class RelationTest < ActiveRecord::TestCase
   end
 end
 
+module ActiveRecord
+  class RelationTest < ActiveRecord::TestCase
+    # Skipping this test. SQL Server doesn't support optimizer hint as comments
+    coerce_tests! :test_relation_with_optimizer_hints_filters_sql_comment_delimiters
+
+    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")
+      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
+
 require "models/post"
 class SanitizeTest < ActiveRecord::TestCase
   # Use nvarchar string (N'') in assert
@@ -1225,6 +1521,7 @@ module ActiveRecord
 
       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)
     end
   end
@@ -1233,8 +1530,43 @@ end
 module ActiveRecord
   module ConnectionAdapters
     class SchemaCacheTest < ActiveRecord::TestCase
+      # Tests fail on Windows AppVeyor CI with 'Permission denied' error when renaming file during `File.atomic_write` call.
+      coerce_tests! :test_yaml_dump_and_load, :test_yaml_dump_and_load_with_gzip if RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
+
+      # Ruby 2.5 and 2.6 have issues to marshal Time before 1900. 2012.sql has one column with default value 1753
+      coerce_tests! :test_marshal_dump_and_load_with_gzip, :test_marshal_dump_and_load_via_disk
+
+      # Tests fail on Windows AppVeyor CI with 'Permission denied' error when renaming file during `File.atomic_write` call.
+      unless RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
+        def test_marshal_dump_and_load_with_gzip_coerced
+          with_marshable_time_defaults { original_test_marshal_dump_and_load_with_gzip }
+        end
+        def test_marshal_dump_and_load_via_disk_coerced
+          with_marshable_time_defaults { original_test_marshal_dump_and_load_via_disk }
+        end
+      end
+
       private
 
+      def with_marshable_time_defaults
+        # Detect problems
+        if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.7")
+          column = @connection.columns(:sst_datatypes).find { |c| c.name == "datetime" }
+          current_default = column.default if column.default.is_a?(Time) && column.default.year < 1900
+        end
+
+        # Correct problems
+        if current_default.present?
+          @connection.change_column_default(:sst_datatypes, :datetime, current_default.dup.change(year: 1900))
+        end
+
+        # Run original test
+        yield
+      ensure
+        # Revert changes
+        @connection.change_column_default(:sst_datatypes, :datetime, current_default) if current_default.present?
+      end
+
       # We need to give the full path for this to work.
       def schema_dump_path
         File.join ARTest::SQLServer.root_activerecord, "test/assets/schema_dump_5_1.yml"
@@ -1243,23 +1575,26 @@ module ActiveRecord
   end
 end
 
+require "models/post"
+require "models/comment"
 class UnsafeRawSqlTest < ActiveRecord::TestCase
+  fixtures :posts
+
   # Use LEN() vs length() function.
   coerce_tests! %r{order: always allows Arel}
   test "order: always allows Arel" do
-    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(Arel.sql("len(title)")).pluck(:title) }
-    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(Arel.sql("len(title)")).pluck(:title) }
+    titles = Post.order(Arel.sql("len(title)")).pluck(:title)
 
-    assert_equal ids_depr, ids_disabled
+    assert_not_empty titles
   end
 
   # Use LEN() vs length() function.
   coerce_tests! %r{pluck: always allows Arel}
   test "pluck: always allows Arel" do
-    values_depr     = with_unsafe_raw_sql_deprecated { Post.includes(:comments).pluck(:title, Arel.sql("len(title)")) }
-    values_disabled = with_unsafe_raw_sql_disabled   { Post.includes(:comments).pluck(:title, Arel.sql("len(title)")) }
+    excepted_values = Post.includes(:comments).pluck(:title).map { |title| [title, title.size] }
+    values = Post.includes(:comments).pluck(:title, Arel.sql("len(title)"))
 
-    assert_equal values_depr, values_disabled
+    assert_equal excepted_values, values
   end
 
   # Use LEN() vs length() function.
@@ -1267,11 +1602,73 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
   test "order: allows valid Array arguments" do
     ids_expected = Post.order(Arel.sql("author_id, len(title)")).pluck(:id)
 
-    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(["author_id", "len(title)"]).pluck(:id) }
-    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(["author_id", "len(title)"]).pluck(:id) }
+    ids = Post.order(["author_id", "len(title)"]).pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string column names that are quoted" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids = Post.order("[id]").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string column names that are quoted with table" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids = Post.order("[posts].[id]").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string column names that are quoted with table and user" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids = Post.order("[dbo].[posts].[id]").pluck(:id)
 
-    assert_equal ids_expected, ids_depr
-    assert_equal ids_expected, ids_disabled
+    assert_equal ids_expected, ids
+  end
+
+  test "order: allows string column names that are quoted with table, user and database" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids = Post.order("[activerecord_unittest].[dbo].[posts].[id]").pluck(:id)
+
+    assert_equal ids_expected, ids
+  end
+
+  test "pluck: allows string column name that are quoted" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("[title]")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows string column name that are quoted with table" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("[posts].[title]")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows string column name that are quoted with table and user" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("[dbo].[posts].[title]")
+
+    assert_equal titles_expected, titles
+  end
+
+  test "pluck: allows string column name that are quoted with table, user and database" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles = Post.pluck("[activerecord_unittest].[dbo].[posts].[title]")
+
+    assert_equal titles_expected, titles
   end
 end
 
@@ -1313,6 +1710,25 @@ class RelationMergingTest < ActiveRecord::TestCase
     relation = Post.all.merge(Post.order([Arel.sql("title LIKE ?"), "%suffix"]))
     assert_equal ["title LIKE N'%suffix'"], relation.order_values
   end
+
+  # Same as original but change first regexp to match sp_executesql binding syntax
+  coerce_tests! :test_merge_doesnt_duplicate_same_clauses
+  def test_merge_doesnt_duplicate_same_clauses_coerced
+    david, mary, bob = authors(:david, :mary, :bob)
+
+    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
+      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_equal [david], only_david.merge(only_david)
+    end
+  end
 end
 
 module ActiveRecord
@@ -1333,6 +1749,7 @@ class EnumTest < ActiveRecord::TestCase
 
     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)
   end
 
@@ -1343,6 +1760,7 @@ class EnumTest < ActiveRecord::TestCase
 
     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)
   end
 
@@ -1353,6 +1771,7 @@ class EnumTest < ActiveRecord::TestCase
 
     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)
   end
 
@@ -1363,6 +1782,7 @@ class EnumTest < ActiveRecord::TestCase
 
     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)
   end
 end
@@ -1400,6 +1820,8 @@ end
 
 require "models/citation"
 class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
+  fixtures :citations
+
   # Original Rails test fails with SQL Server error message "The query processor ran out of internal resources and
   # could not produce a query plan". This error goes away if you change database compatibility level to 110 (SQL 2012)
   # (see https://www.mssqltips.com/sqlservertip/5279/sql-server-error-query-processor-ran-out-of-internal-resources-and-could-not-produce-a-query-plan/).
@@ -1407,14 +1829,14 @@ class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
   # unprepared statement is used if the number of values exceeds the adapter's `bind_params_length`. The coerced test
   # still does this as there will be 32,768 remaining citation records in the database and the `bind_params_length` of
   # adapter is 2,098.
-  coerce_tests! :test_eager_loading_too_may_ids
-  def test_eager_loading_too_may_ids_coerced
+  coerce_tests! :test_eager_loading_too_many_ids
+  def test_eager_loading_too_many_ids_coerced
     # Remove excess records.
     Citation.limit(32768).order(id: :desc).delete_all
 
     # Perform test
     citation_count = Citation.count
-    assert_sql(/WHERE \(\[citations\]\.\[id\] IN \(0, 1/) do
+    assert_sql(/WHERE \[citations\]\.\[id\] IN \(0, 1/) do
       assert_equal citation_count, Citation.eager_load(:citations).offset(0).size
     end
   end
@@ -1426,6 +1848,14 @@ class LogSubscriberTest < ActiveRecord::TestCase
   def test_vebose_query_logs_coerced
     original_test_vebose_query_logs
   end
+
+  # Bindings logged slightly differently.
+  coerce_tests! :test_where_in_binds_logging_include_attribute_names
+  def test_where_in_binds_logging_include_attribute_names_coerced
+    Developer.where(id: [1, 2, 3, 4, 5]).load
+    wait
+    assert_match(%{@0 = 1, @1 = 2, @2 = 3, @3 = 4, @4 = 5  [["id", nil], ["id", nil], ["id", nil], ["id", nil], ["id", nil]]}, @logger.logged(:debug).last)
+  end
 end
 
 class ActiveRecordSchemaTest < ActiveRecord::TestCase
@@ -1437,22 +1867,125 @@ class ActiveRecordSchemaTest < ActiveRecord::TestCase
   end
 end
 
-module ActiveRecord
-  module ConnectionAdapters
-    class ReaperTest < ActiveRecord::TestCase
-      # Coerce can be removed if Rails version > 6.0.3
-      coerce_tests! :test_connection_pool_starts_reaper_in_fork unless Process.respond_to?(:fork)
+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 FixturesTest < ActiveRecord::TestCase
-  # Skip test on Windows. Skip can be removed when Rails PR https://github.com/rails/rails/pull/39234 has been merged.
-  coerce_tests! :test_binary_in_fixtures if RbConfig::CONFIG["host_os"] =~ /mswin|mingw/
+class MarshalSerializationTest < ActiveRecord::TestCase
+  private
+
+  def marshal_fixture_path(file_name)
+    File.expand_path(
+      "support/marshal_compatibility_fixtures/#{ActiveRecord::Base.connection.adapter_name}/#{file_name}.dump",
+      ARTest::SQLServer.test_root_sqlserver
+    )
+  end
 end
 
-class ReloadModelsTest < ActiveRecord::TestCase
-  # Skip test on Windows. The number of arguements 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/
+class NestedThroughAssociationsTest < ActiveRecord::TestCase
+  # Same as original but replace order with "order(:id)" to ensure that assert_includes_and_joins_equal doesn't raise
+  # "A column has been specified more than once in the order by list"
+  # Example: original test generate queries like "ORDER BY authors.id, [authors].[id]". We don't support duplicate columns in the order list
+  coerce_tests! :test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload_via_joins, :test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload_via_joins
+  def test_has_many_through_has_many_with_has_many_through_habtm_source_reflection_preload_via_joins_coerced
+    # preload table schemas
+    Author.joins(:category_post_comments).first
+
+    assert_includes_and_joins_equal(
+      Author.where("comments.id" => comments(:does_it_hurt).id).order(:id),
+      [authors(:david), authors(:mary)], :category_post_comments
+    )
+  end
+
+  def test_has_many_through_has_and_belongs_to_many_with_has_many_source_reflection_preload_via_joins_coerced
+    # preload table schemas
+    Category.joins(:post_comments).first
+
+    assert_includes_and_joins_equal(
+      Category.where("comments.id" => comments(:more_greetings).id).order(:id),
+      [categories(:general), categories(:technology)], :post_comments
+    )
+  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
+    end
+  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
+    end
+  end
+end
+
+class MigratorTest < 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
+
+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