activerecord-sqlserver-adapter 8.0.10 → 8.1.0

data/test/cases/coerced_tests.rb

@@ -2,7 +2,22 @@
 
 require "cases/helper_sqlserver"
 
+require "models/author"
+require "models/book"
+require "models/car"
+require "models/citation"
+require "models/comment"
+require "models/computer"
+require "models/customer"
+require "models/dashboard"
+require "models/developer"
 require "models/event"
+require "models/non_primary_key"
+require "models/post"
+require "models/tag"
+require "models/task"
+require "models/topic"
+
 class UniquenessValidationTest < ActiveRecord::TestCase
   # So sp_executesql swallows this exception. Run without prepared to see it.
   coerce_tests! :test_validate_uniqueness_with_limit
@@ -62,7 +77,6 @@ class UniquenessValidationWithIndexTest < ActiveRecord::TestCase
   end
 end
 
-require "models/event"
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
     # Legacy binds are not supported.
@@ -174,21 +188,20 @@ module ActiveRecord
   end
 end
 
-require "models/topic"
 class AttributeMethodsTest < ActiveRecord::TestCase
   # Use IFF for boolean statement in SELECT
   coerce_tests! %r{typecast attribute from select to false}
   def test_typecast_attribute_from_select_to_false_coerced
-    Topic.create(:title => "Budget")
-    topic = Topic.all.merge!(:select => "topics.*, IIF (1 = 2, 1, 0) as is_test").first
+    Topic.create(title: "Budget")
+    topic = Topic.all.merge!(select: "topics.*, IIF (1 = 2, 1, 0) as is_test").first
     assert_not_predicate topic, :is_test?
   end
 
   # Use IFF for boolean statement in SELECT
   coerce_tests! %r{typecast attribute from select to true}
   def test_typecast_attribute_from_select_to_true_coerced
-    Topic.create(:title => "Budget")
-    topic = Topic.all.merge!(:select => "topics.*, IIF (1 = 1, 1, 0) as is_test").first
+    Topic.create(title: "Budget")
+    topic = Topic.all.merge!(select: "topics.*, IIF (1 = 1, 1, 0) as is_test").first
     assert_predicate topic, :is_test?
   end
 end
@@ -248,7 +261,7 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
   def test_belongs_to_coerced
     client = Client.find(3)
     first_firm = companies(:first_firm)
-    assert_queries_and_values_match(/FETCH NEXT @3 ROWS ONLY/, ['Firm', 'Agency', 1, 1]) do
+    assert_queries_and_values_match(/FETCH NEXT @3 ROWS ONLY/, ["Firm", "Agency", 1, 1]) do
       assert_equal first_firm, client.firm
       assert_equal first_firm.name, client.firm.name
     end
@@ -283,7 +296,7 @@ module ActiveRecord
 
       original_test_payload_row_count_on_select_all
     ensure
-      Book.where(author_id: nil, name: 'row count book 1').delete_all
+      Book.where(author_id: nil, name: "row count book 1").delete_all
       Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
     end
 
@@ -294,7 +307,7 @@ module ActiveRecord
 
       original_test_payload_row_count_on_pluck
     ensure
-      Book.where(author_id: nil, name: 'row count book 2').delete_all
+      Book.where(author_id: nil, name: "row count book 2").delete_all
       Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
     end
 
@@ -305,9 +318,16 @@ module ActiveRecord
 
       original_test_payload_row_count_on_raw_sql
     ensure
-      Book.where(author_id: nil, name: 'row count book 3').delete_all
+      Book.where(author_id: nil, name: "row count book 3").delete_all
       Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
     end
+
+    # Fix randomly failing test. The loading of the model's schema was affecting the test.
+    coerce_tests! :test_payload_affected_rows
+    def test_payload_affected_rows_coerced
+      Book.create!(name: "TEMP RECORD TO RUN SCHEMA QUERIES").destroy!
+      original_test_payload_affected_rows
+    end
   end
 end
 
@@ -377,11 +397,11 @@ class CalculationsTest < ActiveRecord::TestCase
     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!
+      .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)
@@ -421,7 +441,6 @@ class CalculationsTest < ActiveRecord::TestCase
     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
@@ -429,11 +448,11 @@ class CalculationsTest < ActiveRecord::TestCase
     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, :status)
-             .take!
+      .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, :status)
+      .take!
 
     # all the DependentFirm attributes should be present
     assert_equal rails_core, firm
@@ -499,8 +518,8 @@ module ActiveRecord
         five = columns.detect { |c| c.name == "five" }
 
         assert_equal "hello", one.default
-        assert_equal true, connection.lookup_cast_type_from_column(two).deserialize(two.default)
-        assert_equal false, connection.lookup_cast_type_from_column(three).deserialize(three.default)
+        assert_equal true, two.fetch_cast_type(connection).deserialize(two.default)
+        assert_equal false, three.fetch_cast_type(connection).deserialize(three.default)
         assert_equal 1, four.default
         assert_equal "hello", five.default
       end
@@ -569,7 +588,7 @@ module ActiveRecord
       # Our defaults are real 70000 integers vs '70000' strings.
       coerce_tests! :test_rename_column_preserves_default_value_not_null
       def test_rename_column_preserves_default_value_not_null_coerced
-        add_column "test_models", "salary", :integer, :default => 70000
+        add_column "test_models", "salary", :integer, default: 70000
         default_before = connection.columns("test_models").find { |c| c.name == "salary" }.default
         assert_equal 70000, default_before
         rename_column "test_models", "salary", "annual_salary"
@@ -583,8 +602,8 @@ module ActiveRecord
       coerce_tests! :test_remove_column_with_multi_column_index
       def test_remove_column_with_multi_column_index_coerced
         add_column "test_models", :hat_size, :integer
-        add_column "test_models", :hat_style, :string, :limit => 100
-        add_index "test_models", ["hat_style", "hat_size"], :unique => true
+        add_column "test_models", :hat_style, :string, limit: 100
+        add_index "test_models", ["hat_style", "hat_size"], unique: true
         assert_equal 1, connection.indexes("test_models").size
         remove_column("test_models", "hat_size")
         assert_equal [], connection.indexes("test_models").map(&:name)
@@ -611,14 +630,20 @@ class MigrationTest < ActiveRecord::TestCase
   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 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 version
+        101
+      end
+
       def migrate(x)
         add_column "people", "last_name", :binary, if_not_exists: true
       end
@@ -647,7 +672,10 @@ module ActiveRecord
         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 version
+            100
+          end
+
           def migrate(x)
             create_table @@long_table_name
           end
@@ -658,7 +686,11 @@ module ActiveRecord
         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
+        begin
+          connection.drop_table(long_table_name)
+        rescue
+          nil
+        end
       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).
@@ -669,7 +701,10 @@ module ActiveRecord
 
         migration = Class.new(ActiveRecord::Migration[7.0]) {
           @@long_table_name = long_table_name
-          def version; 100 end
+          def version
+            100
+          end
+
           def migrate(x)
             rename_table :more_testings, @@long_table_name
           end
@@ -680,14 +715,22 @@ module ActiveRecord
         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
+        begin
+          connection.drop_table(:more_testings)
+        rescue
+          nil
+        end
+        begin
+          connection.drop_table(long_table_name[0...-1])
+        rescue
+          nil
+        end
       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)
+        long_index_name = "a" * (connection.index_name_length + 1)
 
         migration = Class.new(ActiveRecord::Migration[7.0]) {
           @@long_index_name = long_index_name
@@ -700,13 +743,13 @@ module ActiveRecord
         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)
+        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)
+        long_index_name = "a" * (connection.index_name_length + 1)
 
         migration = Class.new(ActiveRecord::Migration[7.0]) {
           @@long_index_name = long_index_name
@@ -723,9 +766,41 @@ module ActiveRecord
         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)
+        assert_match(/Index name '#{long_index_name}' on table 'more_testings' is too long/i, error.message)
+      ensure
+        begin
+          connection.drop_table :more_testings
+        rescue
+          nil
+        end
+      end
+
+      # Foreign key count is the same as PostgreSQL/SQLite.
+      coerce_tests! :test_remove_foreign_key_on_8_0
+      def test_remove_foreign_key_on_8_0_coerced
+        connection.create_table(:sub_testings) do |t|
+          t.references :testing, foreign_key: true, type: :bigint
+          t.references :experiment, foreign_key: {to_table: :testings}, type: :bigint
+        end
+
+        migration = Class.new(ActiveRecord::Migration[8.0]) do
+          def up
+            change_table(:sub_testings) do |t|
+              t.remove_foreign_key :testings
+              t.remove_foreign_key :testings, column: :experiment_id
+            end
+          end
+        end
+
+        assert_raise(StandardError, match: /Table 'sub_testings' has no foreign key for testings$/) {
+          ActiveRecord::Migrator.new(:up, [migration], @schema_migration, @internal_metadata).migrate
+        }
+
+        foreign_keys = @connection.foreign_keys("sub_testings")
+        assert_equal 2, foreign_keys.size
       ensure
-        connection.drop_table :more_testings rescue nil
+        connection.drop_table(:sub_testings, if_exists: true)
+        ActiveRecord::Base.clear_cache!
       end
     end
   end
@@ -758,19 +833,26 @@ module ActiveRecord
     def setup
       @sqlserver_tasks =
         Class.new do
-          def create; end
+          def create
+          end
 
-          def drop; end
+          def drop
+          end
 
-          def purge; end
+          def purge
+          end
 
-          def charset; end
+          def charset
+          end
 
-          def collation; end
+          def collation
+          end
 
-          def structure_dump(*); end
+          def structure_dump(*)
+          end
 
-          def structure_load(*); end
+          def structure_load(*)
+          end
         end.new
 
       $stdout, @original_stdout = StringIO.new, $stdout
@@ -791,7 +873,7 @@ module ActiveRecord
 
     def test_sqlserver_create
       with_stubbed_new do
-        assert_called(eval("@sqlserver_tasks"), :create) do
+        assert_called(eval("@sqlserver_tasks", binding, __FILE__, __LINE__), :create) do
           ActiveRecord::Tasks::DatabaseTasks.create "adapter" => :sqlserver
         end
       end
@@ -804,7 +886,7 @@ module ActiveRecord
 
     def test_sqlserver_drop
       with_stubbed_new do
-        assert_called(eval("@sqlserver_tasks"), :drop) do
+        assert_called(eval("@sqlserver_tasks", binding, __FILE__, __LINE__), :drop) do
           ActiveRecord::Tasks::DatabaseTasks.drop "adapter" => :sqlserver
         end
       end
@@ -817,7 +899,7 @@ module ActiveRecord
 
     def test_sqlserver_purge
       with_stubbed_new do
-        assert_called(eval("@sqlserver_tasks"), :purge) do
+        assert_called(eval("@sqlserver_tasks", binding, __FILE__, __LINE__), :purge) do
           ActiveRecord::Tasks::DatabaseTasks.purge "adapter" => :sqlserver
         end
       end
@@ -830,7 +912,7 @@ module ActiveRecord
 
     def test_sqlserver_charset
       with_stubbed_new do
-        assert_called(eval("@sqlserver_tasks"), :charset) do
+        assert_called(eval("@sqlserver_tasks", binding, __FILE__, __LINE__), :charset) do
           ActiveRecord::Tasks::DatabaseTasks.charset "adapter" => :sqlserver
         end
       end
@@ -843,7 +925,7 @@ module ActiveRecord
 
     def test_sqlserver_collation
       with_stubbed_new do
-        assert_called(eval("@sqlserver_tasks"), :collation) do
+        assert_called(eval("@sqlserver_tasks", binding, __FILE__, __LINE__), :collation) do
           ActiveRecord::Tasks::DatabaseTasks.collation "adapter" => :sqlserver
         end
       end
@@ -857,10 +939,10 @@ module ActiveRecord
     def test_sqlserver_structure_dump
       with_stubbed_new do
         assert_called_with(
-          eval("@sqlserver_tasks"), :structure_dump,
+          eval("@sqlserver_tasks", binding, __FILE__, __LINE__), :structure_dump,
           ["awesome-file.sql", nil]
         ) do
-          ActiveRecord::Tasks::DatabaseTasks.structure_dump({ "adapter" => :sqlserver }, "awesome-file.sql")
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump({"adapter" => :sqlserver}, "awesome-file.sql")
         end
       end
     end
@@ -873,11 +955,11 @@ module ActiveRecord
     def test_sqlserver_structure_load
       with_stubbed_new do
         assert_called_with(
-          eval("@sqlserver_tasks"),
+          eval("@sqlserver_tasks", binding, __FILE__, __LINE__),
           :structure_load,
           ["awesome-file.sql", nil]
         ) do
-          ActiveRecord::Tasks::DatabaseTasks.structure_load({ "adapter" => :sqlserver }, "awesome-file.sql")
+          ActiveRecord::Tasks::DatabaseTasks.structure_load({"adapter" => :sqlserver}, "awesome-file.sql")
         end
       end
     end
@@ -910,15 +992,12 @@ class EagerAssociationTest < ActiveRecord::TestCase
   coerce_tests! %r{including association based on sql condition and no database column}
 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
+    :test_find_doesnt_have_implicit_ordering
 
   # Assert SQL Server limit implementation
   coerce_tests! :test_take_and_first_and_last_with_integer_should_use_sql_limit
@@ -986,8 +1065,8 @@ class FinderTest < ActiveRecord::TestCase
   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
+  coerce_tests! :test_implicit_order_column_is_configurable_with_a_single_value
+  def test_implicit_order_column_is_configurable_with_a_single_value_coerced
     old_implicit_order_column = Topic.implicit_order_column
     Topic.implicit_order_column = "title"
 
@@ -1002,6 +1081,32 @@ class FinderTest < ActiveRecord::TestCase
     Topic.implicit_order_column = old_implicit_order_column
   end
 
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_implicit_order_column_is_configurable_with_multiple_values
+  def test_implicit_order_column_is_configurable_with_multiple_values_coerced
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = ["title", "author_name"]
+
+    assert_queries_and_values_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.title"))} DESC, #{Regexp.escape(quote_table_name("topics.author_name"))} DESC, #{Regexp.escape(quote_table_name("topics.id"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY/i, [1]) {
+      Topic.last
+    }
+  ensure
+    Topic.implicit_order_column = old_implicit_order_column
+  end
+
+  # Check for `FETCH NEXT x ROWS` rather then `LIMIT`.
+  coerce_tests! :test_ordering_does_not_append_primary_keys_or_query_constraints_if_passed_an_implicit_order_column_array_ending_in_nil
+  def test_ordering_does_not_append_primary_keys_or_query_constraints_if_passed_an_implicit_order_column_array_ending_in_nil_coerced
+    old_implicit_order_column = Topic.implicit_order_column
+    Topic.implicit_order_column = ["author_name", nil]
+
+    assert_queries_and_values_match(/ORDER BY #{Regexp.escape(quote_table_name("topics.author_name"))} DESC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY/i, [1]) {
+      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
@@ -1186,8 +1291,6 @@ class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
   coerce_tests! :test_does_not_override_select
 end
 
-require "models/developer"
-require "models/computer"
 class NestedRelationScopingTest < ActiveRecord::TestCase
   # Assert SQL Server limit implementation
   coerce_tests! :test_merge_options
@@ -1203,7 +1306,6 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
   end
 end
 
-require "models/topic"
 class PersistenceTest < ActiveRecord::TestCase
   # Rails test required updating a identity column.
   coerce_tests! :test_update_columns_changing_id
@@ -1230,20 +1332,26 @@ class PersistenceTest < ActiveRecord::TestCase
   coerce_tests! :test_model_with_no_auto_populated_fields_still_returns_primary_key_after_insert
 end
 
-require "models/author"
 class UpdateAllTest < ActiveRecord::TestCase
-  # Rails test required updating a identity column.
+  # Regular expression slightly different.
   coerce_tests! :test_update_all_doesnt_ignore_order
   def test_update_all_doesnt_ignore_order_coerced
-    david, mary = authors(:david), authors(:mary)
-    _(david.id).must_equal 1
-    _(mary.id).must_equal 2
-    _(david.name).wont_equal mary.name
-    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")
+    assert_equal authors(:david).id + 1, authors(:mary).id # make sure there is going to be a duplicate PK error
+    test_update_with_order_succeeds = lambda do |order|
+      Author.order(order).update_all("id = id + 1")
+    rescue ActiveRecord::ActiveRecordError
+      false
+    end
+
+    if test_update_with_order_succeeds.call("id DESC")
+      # test that this wasn't a fluke and using an incorrect order results in an exception
+      assert_not test_update_with_order_succeeds.call("id ASC")
+    else
+      # test that we're failing because the current Arel's engine doesn't support UPDATE ORDER BY queries is using subselects instead
+      assert_queries_match(/\AUPDATE .+ \(SELECT .* ORDER BY id DESC.*\)/i) do
+        test_update_with_order_succeeds.call("id DESC")
+      end
     end
-    _(david.reload.name).must_equal "David"
-    _(mary.reload.name).must_equal "Test"
   end
 
   # SELECT columns must be in the GROUP clause.
@@ -1256,7 +1364,7 @@ class UpdateAllTest < ActiveRecord::TestCase
 
     assert_operator posts.length, :>, 0
     assert posts.all? { |post| post.comments.length >= minimum_comments_count }
-    assert posts.all? { |post| "ig" == post.title }
+    assert posts.all? { |post| post.title == "ig" }
 
     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
@@ -1281,7 +1389,6 @@ class DeleteAllTest < ActiveRecord::TestCase
   end
 end
 
-require "models/topic"
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
     # Same as original test except string has `N` prefix to indicate unicode string.
@@ -1293,7 +1400,7 @@ module ActiveRecord
     # Same as original test except string has `N` prefix to indicate unicode string.
     coerce_tests! :test_registering_new_handlers_for_association
     def test_registering_new_handlers_for_association_coerced
-      assert_match %r{#{Regexp.escape(topic_title)} ~ N'rails'}i, Reply.joins(:topic).where(topics: { title: /rails/ }).to_sql
+      assert_match %r{#{Regexp.escape(topic_title)} ~ N'rails'}i, Reply.joins(:topic).where(topics: {title: /rails/}).to_sql
     end
 
     # Same as original test except string has `N` prefix to indicate unicode string.
@@ -1312,7 +1419,6 @@ module ActiveRecord
   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
@@ -1323,7 +1429,6 @@ class QueryCacheTest < ActiveRecord::TestCase
   end
 end
 
-require "models/post"
 class RelationTest < ActiveRecord::TestCase
   # Use LEN() instead of LENGTH() function.
   coerce_tests! :test_reverse_order_with_function
@@ -1351,7 +1456,7 @@ class RelationTest < ActiveRecord::TestCase
       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.all?  { |sql| /order by \[posts\]\.\[id\]/i.match?(sql) }, "default ORDER BY ID was not 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.
@@ -1363,7 +1468,7 @@ class RelationTest < ActiveRecord::TestCase
     end
     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}"
+    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 are not doing order duplicate removal anymore.
@@ -1377,7 +1482,7 @@ class RelationTest < ActiveRecord::TestCase
   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)
+      .having(id: post.id).where(title: post.title).group(:id).select(:id)
 
     assert_equal [post], having_then_where
   end
@@ -1458,10 +1563,15 @@ module ActiveRecord
       query = Post.optimizer_hints("OMGHINT").merge(Post.optimizer_hints("OMGHINT")).to_sql
       assert_equal expected, query
     end
+
+    # Order column must be in the GROUP clause. However, with implicit ordering we can't test this when selecting non-aggregate expression column.
+    coerce_tests! %r{no queries when using pick with non-aggregate expression and empty IN}
+
+    # Order column must be in the GROUP clause. However, with implicit ordering we can't test this when selecting aggregate expression column.
+    coerce_tests! %r{runs queries when using pick with aggregate expression despite empty IN}
   end
 end
 
-require "models/post"
 class SanitizeTest < ActiveRecord::TestCase
   # Use nvarchar string (N'') in assert
   coerce_tests! :test_sanitize_sql_like_example_use_case
@@ -1495,14 +1605,14 @@ 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 }
+  coerce_tests! :test_dump_schema_versions_outputs_lexically_reverse_ordered_versions_regardless_of_database_order
+  def test_dump_schema_versions_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
+    schema_info = ActiveRecord::Base.lease_connection.dump_schema_versions
     expected = <<~STR
       INSERT INTO #{ActiveRecord::Base.lease_connection.quote_table_name("schema_migrations")} (version) VALUES
       (N'20100301010101'),
@@ -1527,7 +1637,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
   # Fall through false positive with no filter.
   coerce_tests! :test_schema_dumps_partial_indices
   def test_schema_dumps_partial_indices_coerced
-    index_definition = standard_dump.split(/\n/).grep(/t.index.*company_partial_index/).first.strip
+    index_definition = standard_dump.split("\n").grep(/t.index.*company_partial_index/).first.strip
     assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "([rating]>(10))"', index_definition
   end
 
@@ -1544,7 +1654,7 @@ class SchemaDumperTest < ActiveRecord::TestCase
   # 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
+    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
@@ -1564,14 +1674,14 @@ class SchemaDumperDefaultsCoerceTest < ActiveRecord::TestCase
   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.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.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()" }
+      t.text :text_with_default, default: "John' Doe"
+      t.text :uuid, default: -> { "newid()" }
     end
   end
 
@@ -1588,7 +1698,6 @@ class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
   coerce_tests! %r{inspect on Model class does not raise}
 end
 
-require "models/topic"
 class TransactionTest < ActiveRecord::TestCase
   # SQL Server does not have query for release_savepoint.
   coerce_tests! :test_releasing_named_savepoints
@@ -1634,7 +1743,7 @@ class TransactionTest < ActiveRecord::TestCase
       /DELETE/i,
       /^SAVE TRANSACTION/i,
       /DELETE/i,
-      /COMMIT/i,
+      /COMMIT/i
     ]
 
     assert_equal expected_queries.size, actual_queries.size
@@ -1670,7 +1779,7 @@ class TransactionTest < ActiveRecord::TestCase
       /^SAVE TRANSACTION/i,
       /DELETE/i,
       /DELETE/i,
-      /COMMIT/i,
+      /COMMIT/i
     ]
 
     assert_equal expected_queries.size, actual_queries.size
@@ -1680,7 +1789,6 @@ class TransactionTest < ActiveRecord::TestCase
   end
 end
 
-require "models/tag"
 class TransactionIsolationTest < ActiveRecord::TestCase
   # SQL Server will lock the table for counts even when both
   # connections are `READ COMMITTED`. So we bypass with `READPAST`.
@@ -1698,9 +1806,27 @@ class TransactionIsolationTest < ActiveRecord::TestCase
 
   # I really need some help understanding this one.
   coerce_tests! %r{repeatable read}
+
+  private
+
+  # Need to handle the resetting of the isolation level in the adapter by `SQLServerRealTransaction#commit` for each
+  # connection pool. After the resetting events have been removed we can assert the number of expected isolation level
+  # events. This workaround assumes that the `count` also matches the number of connection pools used in the test.
+  # Note: MySQL & PostgreSQL do not reset the connection and SQLite does support transaction isolation.
+  undef_method :assert_begin_isolation_level_event
+  def assert_begin_isolation_level_event(events, isolation: "READ COMMITTED", count: 1)
+    isolation_events = events.select { |event| event.match(/SET TRANSACTION ISOLATION LEVEL/) }
+
+    count.times do
+      index_of_reset_starting_isolation_level_event = isolation_events.index("SET TRANSACTION ISOLATION LEVEL READ COMMITTED")
+      assert index_of_reset_starting_isolation_level_event.present?
+      isolation_events.delete_at(index_of_reset_starting_isolation_level_event)
+    end
+
+    assert_equal count, isolation_events.count { |event| event.match(/SET TRANSACTION ISOLATION LEVEL #{isolation}/) }
+  end
 end
 
-require "models/book"
 class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
   # We have a few view tables. use includes vs equality.
   coerce_tests! :test_views
@@ -1724,7 +1850,6 @@ class ViewWithoutPrimaryKeyTest < ActiveRecord::TestCase
   end
 end
 
-require "models/author"
 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
@@ -1773,7 +1898,7 @@ class TimePrecisionTest < ActiveRecord::TestCase
   coerce_tests! :test_time_precision_is_truncated_on_assignment
   def test_time_precision_is_truncated_on_assignment_coerced
     @connection.create_table(:foos, force: true)
-    @connection.add_column :foos, :start,  :time, precision: 0
+    @connection.add_column :foos, :start, :time, precision: 0
     @connection.add_column :foos, :finish, :time, precision: 6
 
     time = ::Time.now.change(nsec: 123456789)
@@ -1809,8 +1934,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.
@@ -1839,7 +1964,6 @@ module ActiveRecord
   end
 end
 
-require "models/book"
 module ActiveRecord
   class StatementCacheTest < ActiveRecord::TestCase
     # Getting random failures.
@@ -1852,7 +1976,7 @@ module ActiveRecord
 
       original_test_statement_cache_values_differ
     ensure
-      Book.where(author_id: nil, name: 'my book').delete_all
+      Book.where(author_id: nil, name: "my book").delete_all
       Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
     end
   end
@@ -1862,53 +1986,38 @@ 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 }
+      coerce_tests! :test_yaml_dump_and_load, :test_yaml_dump_and_load_with_gzip if /mswin|mingw/.match?(RbConfig::CONFIG["host_os"])
+
+      # Cast type in SQL Server is :varchar rather than Unicode :string.
+      coerce_tests! :test_yaml_load_8_0_dump_without_cast_type_still_get_the_right_one
+      def test_yaml_load_8_0_dump_without_cast_type_still_get_the_right_one
+        cache = load_bound_reflection(schema_dump_8_0_path)
+
+        assert_no_queries do
+          columns = cache.columns_hash("courses")
+          assert_equal 3, columns.size
+          cast_type = columns["name"].fetch_cast_type(@connection)
+          assert_not_nil cast_type, "expected cast_type to be present"
+          assert_equal :varchar, cast_type.type
         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?
+      # We need to give the full paths for this to work.
+      undef_method :schema_dump_5_1_path
+      def schema_dump_5_1_path
+        File.join(ARTest::SQLServer.root_activerecord, "test/assets/schema_dump_5_1.yml")
       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")
+      undef_method :schema_dump_8_0_path
+      def schema_dump_8_0_path
+        File.join(ARTest::SQLServer.root_activerecord, "test/assets/schema_dump_8_0.yml")
       end
     end
   end
 end
 
-require "models/post"
-require "models/comment"
 class UnsafeRawSqlTest < ActiveRecord::TestCase
   fixtures :posts
 
@@ -2029,9 +2138,9 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
   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_expected = Post.order(Arel.sql(%(author_id, title COLLATE #{collation_name} DESC))).pluck(:id)
 
-    ids = Post.order(["author_id", %Q'title COLLATE #{collation_name} DESC']).pluck(:id)
+    ids = Post.order(["author_id", %(title COLLATE #{collation_name} DESC)]).pluck(:id)
 
     assert_equal ids_expected, ids
   end
@@ -2105,14 +2214,13 @@ module ActiveRecord
   end
 end
 
-require "models/book"
 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.lease_connection.remove_index(:books, column: [:author_id, :name])
 
-    send(:'original_enums are distinct per class')
+    send(:"original_enums are distinct per class")
   ensure
     Book.where(author_id: nil, name: nil).delete_all
     Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
@@ -2123,7 +2231,7 @@ class EnumTest < ActiveRecord::TestCase
   test "creating new objects with enum scopes coerced" do
     Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
-    send(:'original_creating new objects with enum scopes')
+    send(:"original_creating new objects with enum scopes")
   ensure
     Book.where(author_id: nil, name: nil).delete_all
     Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
@@ -2134,7 +2242,7 @@ class EnumTest < ActiveRecord::TestCase
   test "enums are inheritable coerced" do
     Book.lease_connection.remove_index(:books, column: [:author_id, :name])
 
-    send(:'original_enums are inheritable')
+    send(:"original_enums are inheritable")
   ensure
     Book.where(author_id: nil, name: nil).delete_all
     Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
@@ -2145,14 +2253,13 @@ class EnumTest < ActiveRecord::TestCase
   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')
+    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
 
-require "models/citation"
 class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
   fixtures :citations
 
@@ -2187,7 +2294,7 @@ 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/
+  coerce_tests! :test_has_one_with_reload if /mswin|mingw/.match?(RbConfig::CONFIG["host_os"])
 end
 
 class MarshalSerializationTest < ActiveRecord::TestCase
@@ -2283,15 +2390,14 @@ 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/
+  coerce_tests! :test_migrator_db_has_no_schema_migrations_table if /mswin|mingw/.match?(RbConfig::CONFIG["host_os"])
 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/
+  coerce_tests! :test_migrator_db_has_no_schema_migrations_table if /mswin|mingw/.match?(RbConfig::CONFIG["host_os"])
 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
@@ -2338,12 +2444,11 @@ class FieldOrderedValuesTest < ActiveRecord::TestCase
   end
 end
 
-require "models/dashboard"
 class QueryLogsTest < ActiveRecord::TestCase
   # 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 ]
+    ActiveRecord::QueryLogs.tags = [:application]
     assert_raises ActiveRecord::StatementInvalid do
       ActiveRecord::Base.lease_connection.execute "select 1 as '\xFF'"
     end
@@ -2356,8 +2461,8 @@ class InsertAllTest < ActiveRecord::TestCase
   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")
+    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
 
   # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
@@ -2397,7 +2502,7 @@ module ActiveRecord
       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
+        default_keys.concat([":is_identity", ":as", ":stored"]) # SQL Server additional valid keys
 
         "Unknown key: :#{key}. Valid keys are: #{default_keys.join(", ")}"
       end
@@ -2405,11 +2510,11 @@ module ActiveRecord
   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|
@@ -2432,7 +2537,7 @@ end
 
 module ActiveRecord
   module ConnectionAdapters
-    class ConnectionHandlersShardingDbTest  < ActiveRecord::TestCase
+    class ConnectionHandlersShardingDbTest < ActiveRecord::TestCase
       # Tests are not about a specific adapter.
       coerce_all_tests!
     end
@@ -2556,7 +2661,6 @@ module ActiveRecord
   end
 end
 
-
 module ActiveRecord
   class TableMetadataTest < ActiveSupport::TestCase
     # Adapter returns an object that is subclass of what is expected in the original test.
@@ -2623,7 +2727,7 @@ module ActiveRecord
       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"),
+          Company.joins("JOIN top_companies_and_children ON companies.firm_id = top_companies_and_children.id")
         ]
       ).from("top_companies_and_children AS companies")
 
@@ -2633,3 +2737,103 @@ module ActiveRecord
   end
 end
 
+module ActiveRecord
+  class AdapterConnectionTest < ActiveRecord::TestCase
+    # Original method only handled the core adapters.
+    undef_method :raw_transaction_open?
+    def raw_transaction_open?(connection)
+      transaction_count = connection.instance_variable_get(:@raw_connection).execute("SELECT @@TRANCOUNT AS TRANSACTION_COUNT").first["TRANSACTION_COUNT"]
+      transaction_count > 0
+    rescue
+      false
+    end
+  end
+end
+
+class EachTest < ActiveRecord::TestCase
+  # Match SQL Server limit implementation.
+  coerce_tests! :test_in_batches_executes_range_queries_when_unconstrained
+  def test_in_batches_executes_range_queries_when_unconstrained_coerced
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC OFFSET @\S ROWS FETCH NEXT @\S ROWS ONLY/i, count: 6) do
+      assert_queries_match(/ORDER BY #{quoted_posts_id} ASC OFFSET 0 ROWS FETCH NEXT @\S ROWS ONLY/i, count: 1) do
+        Post.in_batches(of: 2).to_a
+      end
+    end
+
+    assert_queries_match(/WHERE #{quoted_posts_id} > .+ AND #{quoted_posts_id} <= .+/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  # Match SQL Server limit implementation.
+  coerce_tests! :test_in_batches_executes_in_queries_when_unconstrained_and_opted_out_of_ranges
+  def test_in_batches_executes_in_queries_when_unconstrained_and_opted_out_of_ranges_coerced
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC OFFSET 0 ROWS FETCH NEXT @\S ROWS ONLY/i, count: 6) do
+      Post.in_batches(of: 2, use_ranges: false).to_a
+    end
+
+    assert_queries_match(/#{quoted_posts_id} IN \(.+\)/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  # Match SQL Server limit implementation.
+  coerce_tests! :test_in_batches_executes_in_queries_when_constrained
+  def test_in_batches_executes_in_queries_when_constrained_coerced
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC OFFSET 0 ROWS FETCH NEXT @\S ROWS ONLY/i, count: 3) do
+      Post.where("id < ?", 5).in_batches(of: 2).to_a
+    end
+
+    assert_queries_match(/#{quoted_posts_id} IN \(.+\)/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  # Match SQL Server limit implementation.
+  coerce_tests! :test_in_batches_executes_range_queries_when_constrained_and_opted_in_into_ranges
+  def test_in_batches_executes_range_queries_when_constrained_and_opted_in_into_ranges_coerced
+    quoted_posts_id = Regexp.escape(quote_table_name("posts.id"))
+
+    relations = assert_queries_match(/ORDER BY #{quoted_posts_id} ASC OFFSET @\S ROWS FETCH NEXT @\S ROWS ONLY/i, count: 3) do
+      assert_queries_match(/ORDER BY #{quoted_posts_id} ASC OFFSET 0 ROWS FETCH NEXT @\S ROWS ONLY/i, count: 1) do
+        Post.where("id < ?", 5).in_batches(of: 2, use_ranges: true).to_a
+      end
+    end
+
+    assert_queries_match(/#{quoted_posts_id} > .+ AND #{quoted_posts_id} <= .+/i) do
+      relations.each { |relation| assert_kind_of Post, relation.first }
+    end
+  end
+
+  # Match SQL Server SQL format.
+  coerce_tests! :test_in_batches_should_unscope_cursor_after_pluck
+  def test_in_batches_should_unscope_cursor_after_pluck_coerced
+    all_ids = Post.limit(2).pluck(:id)
+    found_ids = []
+    # only a single clause on id (i.e. not 'id IN (?,?) AND id = ?', but only 'id = ?')
+    assert_queries_match(/WHERE #{Regexp.escape(quote_table_name("posts.id"))} = \S+ ORDER BY/) do
+      Post.where(id: all_ids).in_batches(of: 1) do |relation|
+        found_ids << relation.pick(:id)
+      end
+    end
+    assert_equal all_ids.sort, found_ids
+  end
+
+  # Match SQL Server SQL format.
+  coerce_tests! :test_in_batches_loaded_should_unscope_cursor_after_pluck
+  def test_in_batches_loaded_should_unscope_cursor_after_pluck_coerced
+    all_ids = Post.limit(2).pluck(:id)
+    # only a single clause on id (i.e. not 'id IN (?,?) AND id = ?', but only 'id = ?')
+    assert_queries_match(/WHERE #{Regexp.escape(quote_table_name("posts.id"))} = \S+;/) do
+      Post.where(id: all_ids).in_batches(of: 1, load: true) do |relation|
+        relation.delete_all
+      end
+    end
+  end
+end