activerecord-sqlserver-adapter 6.0.1 → 6.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a7160737c2d7b0946054cdf6e9fd7c26144cef8f1bc66be90d0b51b7e9ba91f
-  data.tar.gz: 67ef07c9e35bd3f4735bed2303f3c63f58d09e1bacb7203339b365457c03d296
+  metadata.gz: 6a4ddc7c26331060001ac99b3e2ea5c7d30a97204237c48c383b356280a763ac
+  data.tar.gz: c9e1154f442e957e1930fa7cc36addf9b8f465d579d44fcb87fb6a4ffe0426bb
 SHA512:
-  metadata.gz: 599f09313bdd68db576bd7282174f04ac9c7e848b2d84b73857e5da9ca5a76427bd22a63bc717e90cd7293747701bdcbcbbc4159e7309bd5328a8be8baa5a245
-  data.tar.gz: dd54538736ba65dd12ee1ce87aae3da4e324888ca3a9b7a793cae34817451f66ec5b19e0e67882335057e7136f55f1871dad89553f8dfca0824ecdd6c4f34540
+  metadata.gz: fc3e2cbdcd6ef7d2f334a4af20a66e9c1f1a4ec28548dc664e879a94e87aa487a0d68c6468182b3a026f3e05aa0c735ce16c774b8b404cb8f7e140188d8c06f0
+  data.tar.gz: 5f759150e7c204c5de007a320897b71bfe80913ee78d162dcfa891ab840102089f3798a7641ccaa2fe6ef6a56250deed62877f2b7900983f705a21677985c291

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    name: Run test suite
+    runs-on: ubuntu-latest
+
+    env:
+      COMPOSE_FILE: docker-compose.ci.yml
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.7.5
+          - 3.0.3
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Build docker images
+        run: docker-compose build --build-arg TARGET_VERSION=${{ matrix.ruby }}
+
+      - name: Run tests
+        run: docker-compose run ci

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## v6.0.3
+
+#### Fixed
+
+[#1054](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1054) Conditionally apply SQL Server monkey patches to ActiveRecord so that it is safe to use this gem alongside other database adapters (e.g. PostgreSQL) in a multi-database Rails app
+
+## v6.0.2
+
+#### Fixed
+
+- [#858](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/858) Allow table existence to be tested across database schemas.
+
+#### Changed
+
+- [#852](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/852) Updated the column name matchers to accept database and owner names
+
+#### Added
+
+- [#855](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/855) Add helpers to create/change/drop a schema.
+- [#857](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/857) Included WAITFOR as read query type.
+- [#865](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/865) Implemented optimizer hints.
+- [#845](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/845) Add support for lateral using CROSS/OUTER APPLY.
+- [#870](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/870) Added DecimalWithoutScale type
+
 ## v6.0.1
 
 #### Fixed

data/Gemfile

@@ -7,9 +7,10 @@ git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 gemspec
 
 gem "bcrypt"
-gem "pg",      ">= 0.18.0"
+gem "pg", "~> 1.3"
 gem "sqlite3", "~> 1.4"
 gem "tzinfo-data", platforms: [:mingw, :mswin, :x64_mingw, :jruby]
+gem "minitest", ">= 5.15.0", "< 5.16"
 
 if ENV["RAILS_SOURCE"]
   gemspec path: ENV["RAILS_SOURCE"]

data/README.md

@@ -1,6 +1,6 @@
 # ActiveRecord SQL Server Adapter. For SQL Server 2012 And Higher.
 
-* [![TravisCI](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter.svg?branch=master)](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter) - TravisCI
+* [![CI](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/actions/workflows/ci.yml/badge.svg)](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/actions/workflows/ci.yml) - CI
 * [![Build Status](https://ci.appveyor.com/api/projects/status/mtgbx8f57vr7k2qa/branch/master?svg=true)](https://ci.appveyor.com/project/rails-sqlserver/activerecord-sqlserver-adapter/branch/master) - Appveyor
 * [![Gem Version](http://img.shields.io/gem/v/activerecord-sqlserver-adapter.svg)](https://rubygems.org/gems/activerecord-sqlserver-adapter) - Gem Version
 * [![Gitter chat](https://img.shields.io/badge/%E2%8A%AA%20GITTER%20-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat)](https://gitter.im/rails-sqlserver/activerecord-sqlserver-adapter) - Community
@@ -52,6 +52,24 @@ Depending on your user and schema setup, it may be needed to use a table name pr
 ActiveRecord::Base.table_name_prefix = 'dbo.'
 ```
 
+It's also possible to create/change/drop a schema in the migration file as in the example below:
+
+```ruby
+class CreateFooSchema < ActiveRecord::Migration[6.0]
+  def up
+    create_schema('foo')
+
+    # Or you could move a table to a different schema
+
+    change_table_schema('foo', 'dbo.admin')
+  end
+
+  def down
+    drop_schema('foo')
+  end
+end
+```
+
 
 #### Configure Connection & App Name
 

data/RUNNING_UNIT_TESTS.md

@@ -5,7 +5,7 @@ This process is much easier than it has been before!
 
 ## MS SQL SERVER
 
-If you don't have easy access to MS SQL Server, you can set up a Vagrant/VirtualBox virtual machine with MS SQL Server. [Here's how](/https://github.com/rails-sqlserver/activerecord-sqlserver-adapter-dev-box).
+If you don't have easy access to MS SQL Server, you can set up a Vagrant/VirtualBox virtual machine with MS SQL Server. [Here's how](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter-dev-box).
 
 ## TL;DR
 

data/VERSION

@@ -1 +1 @@
-6.0.1
+6.0.3

data/appveyor.yml

@@ -5,10 +5,10 @@ build: off
 matrix:
   fast_finish: true
   allow_failures:
-    - ruby_version: "25"
-    - ruby_version: "26"
-    - ruby_version: "27"
     - ruby_version: "27-x64"
+    - ruby_version: "27"
+    - ruby_version: "30"
+    - ruby_version: "30-x64"
 services:
   - mssql2014
 
@@ -38,9 +38,7 @@ environment:
   CI_AZURE_PASS:
     secure: cSQp8sk4urJYvq0utpsK+r7J+snJ2wpcdp8RdXJfB+w=
   matrix:
-    - ruby_version: "25-x64"
-    - ruby_version: "25"
-    - ruby_version: "26-x64"
-    - ruby_version: "26"
     - ruby_version: "27-x64"
     - ruby_version: "27"
+    - ruby_version: "30"
+    - ruby_version: "30-x64"

data/lib/active_record/connection_adapters/sqlserver/core_ext/attribute_methods.rb

@@ -10,6 +10,8 @@ module ActiveRecord
           private
 
           def attributes_for_update(attribute_names)
+            return super unless self.class.connection.adapter_name == "SQLServer"
+
             super.reject do |name|
               column = self.class.columns_hash[name]
               column && column.respond_to?(:is_identity?) && column.is_identity?

data/lib/active_record/connection_adapters/sqlserver/core_ext/calculations.rb

@@ -10,6 +10,8 @@ module ActiveRecord
         module Calculations
           # Same as original except we don't perform PostgreSQL hack that removes ordering.
           def calculate(operation, column_name)
+            return super unless klass.connection.adapter_name == "SQLServer"
+
             if has_include?(column_name)
               relation = apply_join_dependency
 
@@ -29,6 +31,8 @@ module ActiveRecord
           private
 
           def build_count_subquery(relation, column_name, distinct)
+            return super unless klass.connection.adapter_name == "SQLServer"
+
             super(relation.unscope(:order), column_name, distinct)
           end
 

data/lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb

@@ -9,6 +9,8 @@ module ActiveRecord
           SQLSERVER_STATEMENT_REGEXP = /N'(.+)', N'(.+)', (.+)/
 
           def exec_explain(queries)
+            return super unless connection.adapter_name == "SQLServer"
+
             unprepared_queries = queries.map do |(sql, binds)|
               [unprepare_sqlserver_statement(sql, binds), binds]
             end

data/lib/active_record/connection_adapters/sqlserver/core_ext/finder_methods.rb

@@ -12,6 +12,8 @@ module ActiveRecord
 
           # Same as original except we order by values in distinct select if present.
           def construct_relation_for_exists(conditions)
+            return super unless klass.connection.adapter_name == "SQLServer"
+
             conditions = sanitize_forbidden_attributes(conditions)
 
             if distinct_value && offset_value

data/lib/active_record/connection_adapters/sqlserver/core_ext/preloader.rb

@@ -10,6 +10,8 @@ module ActiveRecord
           private
 
           def records_for(ids)
+            return super unless klass.connection.adapter_name == "SQLServer"
+
             ids.each_slice(in_clause_length).flat_map do |slice|
               scope.where(association_key_name => slice).load do |record|
                 # Processing only the first owner

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module DatabaseStatements
-        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback) # :nodoc:
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :dbcc, :explain, :save, :select, :set, :rollback, :waitfor) # :nodoc:
         private_constant :READ_QUERY
 
         def write_query?(sql) # :nodoc:

data/lib/active_record/connection_adapters/sqlserver/quoting.rb

@@ -83,8 +83,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # [table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
             )
             (?:\s+AS\s+(?:\w+|\[\w+\]))?
           )
@@ -96,8 +96,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # [table_name].[column_name] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+              # [database_name].[database_owner].[table_name].[column_name] | function(one or no argument)
+              ((?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
             )
             (?:\s+ASC|\s+DESC)?
             (?:\s+NULLS\s+(?:FIRST|LAST))?

data/lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -281,14 +281,33 @@ module ActiveRecord
           SQLServer::SchemaDumper.create(self, options)
         end
 
+        def create_schema(schema_name, authorization = nil)
+          sql = "CREATE SCHEMA [#{schema_name}]"
+          sql += " AUTHORIZATION [#{authorization}]" if authorization
+
+          execute sql
+        end
+
+        def change_table_schema(schema_name, table_name)
+          execute "ALTER SCHEMA [#{schema_name}] TRANSFER [#{table_name}]"
+        end
+
+        def drop_schema(schema_name)
+          execute "DROP SCHEMA [#{schema_name}]"
+        end
+
         private
 
         def data_source_sql(name = nil, type: nil)
           scope = quoted_scope name, type: type
-          table_name = lowercase_schema_reflection_sql "TABLE_NAME"
+
+          table_name = lowercase_schema_reflection_sql 'TABLE_NAME'
+          database = scope[:database].present? ? "#{scope[:database]}." : ""
+          table_catalog = scope[:database].present? ? quote(scope[:database]) : "DB_NAME()"
+
           sql = "SELECT #{table_name}"
-          sql += " FROM INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
-          sql += " WHERE TABLE_CATALOG = DB_NAME()"
+          sql += " FROM #{database}INFORMATION_SCHEMA.TABLES WITH (NOLOCK)"
+          sql += " WHERE TABLE_CATALOG = #{table_catalog}"
           sql += " AND TABLE_SCHEMA = #{quote(scope[:schema])}"
           sql += " AND TABLE_NAME = #{quote(scope[:name])}" if scope[:name]
           sql += " AND TABLE_TYPE = #{quote(scope[:type])}" if scope[:type]
@@ -299,6 +318,7 @@ module ActiveRecord
         def quoted_scope(name = nil, type: nil)
           identifier = SQLServer::Utils.extract_identifiers(name)
           {}.tap do |scope|
+            scope[:database] = identifier.database if identifier.database
             scope[:schema] = identifier.schema || "dbo"
             scope[:name] = identifier.object if identifier.object
             scope[:type] = type if type

data/lib/active_record/connection_adapters/sqlserver/type/decimal_without_scale.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module Type
+        class DecimalWithoutScale < ActiveRecord::Type::DecimalWithoutScale
+          def sqlserver_type
+            "decimal".yield_self do |type|
+              type += "(#{precision.to_i},0)" if precision
+              type
+            end
+          end
+
+          def type_cast_for_schema(value)
+            value.is_a?(BigDecimal) ? value.to_s : value.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlserver/type.rb

@@ -11,6 +11,7 @@ require "active_record/connection_adapters/sqlserver/type/small_integer"
 require "active_record/connection_adapters/sqlserver/type/tiny_integer"
 require "active_record/connection_adapters/sqlserver/type/boolean"
 require "active_record/connection_adapters/sqlserver/type/decimal"
+require "active_record/connection_adapters/sqlserver/type/decimal_without_scale"
 require "active_record/connection_adapters/sqlserver/type/money"
 require "active_record/connection_adapters/sqlserver/type/small_money"
 # Approximate Numerics

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -152,6 +152,10 @@ module ActiveRecord
         true
       end
 
+      def supports_optimizer_hints?
+        true
+      end
+
       def supports_lazy_transactions?
         true
       end
@@ -296,6 +300,7 @@ module ActiveRecord
 
       def initialize_type_map(m = type_map)
         m.register_type              %r{.*}, SQLServer::Type::UnicodeString.new
+
         # Exact Numerics
         register_class_with_limit m, "bigint(8)",         SQLServer::Type::BigInteger
         m.alias_type                 "bigint",            "bigint(8)"
@@ -308,16 +313,22 @@ module ActiveRecord
         m.alias_type                 "tinyint",           "tinyint(1)"
         m.register_type              "bit",               SQLServer::Type::Boolean.new
         m.register_type              %r{\Adecimal}i do |sql_type|
-          scale = extract_scale(sql_type)
+          scale     = extract_scale(sql_type)
           precision = extract_precision(sql_type)
-          SQLServer::Type::Decimal.new precision: precision, scale: scale
+          if scale == 0
+            SQLServer::Type::DecimalWithoutScale.new(precision: precision)
+          else
+            SQLServer::Type::Decimal.new(precision: precision, scale: scale)
+          end
         end
         m.alias_type                 %r{\Anumeric}i,      "decimal"
         m.register_type              "money",             SQLServer::Type::Money.new
         m.register_type              "smallmoney",        SQLServer::Type::SmallMoney.new
+
         # Approximate Numerics
         m.register_type              "float",             SQLServer::Type::Float.new
         m.register_type              "real",              SQLServer::Type::Real.new
+
         # Date and Time
         m.register_type              "date",              SQLServer::Type::Date.new
         m.register_type              %r{\Adatetime} do |sql_type|
@@ -337,11 +348,13 @@ module ActiveRecord
           precision = extract_precision(sql_type) || DEFAULT_TIME_PRECISION
           SQLServer::Type::Time.new precision: precision
         end
+
         # Character Strings
         register_class_with_limit m, %r{\Achar}i,         SQLServer::Type::Char
         register_class_with_limit m, %r{\Avarchar}i,      SQLServer::Type::Varchar
         m.register_type              "varchar(max)",      SQLServer::Type::VarcharMax.new
         m.register_type              "text",              SQLServer::Type::Text.new
+
         # Unicode Character Strings
         register_class_with_limit m, %r{\Anchar}i,        SQLServer::Type::UnicodeChar
         register_class_with_limit m, %r{\Anvarchar}i,     SQLServer::Type::UnicodeVarchar
@@ -349,10 +362,12 @@ module ActiveRecord
         m.register_type              "nvarchar(max)",     SQLServer::Type::UnicodeVarcharMax.new
         m.register_type              "nvarchar(max)",     SQLServer::Type::UnicodeVarcharMax.new
         m.register_type              "ntext",             SQLServer::Type::UnicodeText.new
+
         # Binary Strings
         register_class_with_limit m, %r{\Abinary}i,       SQLServer::Type::Binary
         register_class_with_limit m, %r{\Avarbinary}i,    SQLServer::Type::Varbinary
         m.register_type              "varbinary(max)",    SQLServer::Type::VarbinaryMax.new
+
         # Other Data Types
         m.register_type              "uniqueidentifier",  SQLServer::Type::Uuid.new
         m.register_type              "timestamp",         SQLServer::Type::Timestamp.new

data/lib/arel/visitors/sqlserver.rb

@@ -80,6 +80,16 @@ module Arel
         @select_statement = nil
       end
 
+      def visit_Arel_Nodes_SelectCore(o, collector)
+        collector = super
+        maybe_visit o.optimizer_hints, collector
+      end
+
+      def visit_Arel_Nodes_OptimizerHints(o, collector)
+        hints = o.expr.map { |v| sanitize_as_option_clause(v) }.join(", ")
+        collector << "OPTION (#{hints})"
+      end
+
       def visit_Arel_Table o, collector
         # Apparently, o.engine.connection can actually be a different adapter
         # than sqlserver. Can be removed if fixed in ActiveRecord. See:
@@ -115,23 +125,33 @@ module Arel
       end
 
       def visit_Arel_Nodes_InnerJoin o, collector
-        collector << "INNER JOIN "
-        collector = visit o.left, collector
-        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        if o.right
-          collector << " "
-          visit(o.right, collector)
+        if o.left.is_a?(Arel::Nodes::As) && o.left.left.is_a?(Arel::Nodes::Lateral)
+          collector << "CROSS "
+          visit o.left, collector
         else
-          collector
+          collector << "INNER JOIN "
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+          if o.right
+            collector << " "
+            visit(o.right, collector)
+          else
+            collector
+          end
         end
       end
 
       def visit_Arel_Nodes_OuterJoin o, collector
-        collector << "LEFT OUTER JOIN "
-        collector = visit o.left, collector
-        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        collector << " "
-        visit o.right, collector
+        if o.left.is_a?(Arel::Nodes::As) && o.left.left.is_a?(Arel::Nodes::Lateral)
+          collector << "OUTER "
+          visit o.left, collector
+        else
+          collector << "LEFT OUTER JOIN "
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+          collector << " "
+          visit o.right, collector
+        end
       end
 
       def collect_in_clause(left, right, collector)
@@ -144,6 +164,10 @@ module Arel
         super
       end
 
+      def collect_optimizer_hints(o, collector)
+        collector
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
@@ -174,6 +198,18 @@ module Arel
         collector
       end
 
+      def visit_Arel_Nodes_Lateral o, collector
+        collector << "APPLY"
+        collector << " "
+        if o.expr.is_a?(Arel::Nodes::SelectStatement)
+          collector << "("
+          visit(o.expr, collector)
+          collector << ")"
+        else
+          visit(o.expr, collector)
+        end
+      end
+
       # SQLServer Helpers
 
       def node_value(node)
@@ -247,6 +283,10 @@ module Arel
 
         node.orders = [] unless node.offset || node.limit
       end
+
+      def sanitize_as_option_clause(value)
+        value.gsub(%r{OPTION \s* \( (.+) \)}xi, "\\1")
+      end
     end
   end
 end

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,48 @@ 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.
+      Topic.table_name = "#{ActiveRecord::Base.configurations["arunit"]['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.spec.config[:database]
+    arunit2_database = arunit2_connection.pool.spec.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")

data/test/cases/coerced_tests.rb

@@ -396,39 +396,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
@@ -982,6 +949,21 @@ 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
+  end
+end
+
 require "models/post"
 class SanitizeTest < ActiveRecord::TestCase
   # Use nvarchar string (N'') in assert
@@ -1106,7 +1088,8 @@ class YamlSerializationTest < ActiveRecord::TestCase
   coerce_tests! :test_types_of_virtual_columns_are_not_changed_on_round_trip
   def test_types_of_virtual_columns_are_not_changed_on_round_trip_coerced
     author = Author.select("authors.*, 5 as posts_count").first
-    dumped = YAML.load(YAML.dump(author))
+    dumped_author = YAML.dump(author)
+    dumped = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(dumped_author) : YAML.load(dumped_author)
     assert_equal 5, author.posts_count
     assert_equal 5, dumped.posts_count
   end
@@ -1225,6 +1208,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
@@ -1243,7 +1227,11 @@ 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
@@ -1273,6 +1261,86 @@ class UnsafeRawSqlTest < ActiveRecord::TestCase
     assert_equal ids_expected, ids_depr
     assert_equal ids_expected, ids_disabled
   end
+
+  test "order: allows string column names that are quoted" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "order: allows string column names that are quoted with table" do
+    ids_expected = Post.order(Arel.sql("id")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order("[posts].[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[posts].[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  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_depr     = with_unsafe_raw_sql_deprecated { Post.order("[dbo].[posts].[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[dbo].[posts].[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  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_depr     = with_unsafe_raw_sql_deprecated { Post.order("[activerecord_unittest].[dbo].[posts].[id]").pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order("[activerecord_unittest].[dbo].[posts].[id]").pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  test "pluck: allows string column name that are quoted" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows string column name that are quoted with table" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[posts].[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[posts].[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows string column name that are quoted with table and user" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[dbo].[posts].[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[dbo].[posts].[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
+
+  test "pluck: allows string column name that are quoted with table, user and database" do
+    titles_expected = Post.pluck(Arel.sql("title"))
+
+    titles_depr     = with_unsafe_raw_sql_deprecated { Post.pluck("[activerecord_unittest].[dbo].[posts].[title]") }
+    titles_disabled = with_unsafe_raw_sql_disabled   { Post.pluck("[activerecord_unittest].[dbo].[posts].[title]") }
+
+    assert_equal titles_expected, titles_depr
+    assert_equal titles_expected, titles_disabled
+  end
 end
 
 class ReservedWordTest < ActiveRecord::TestCase
@@ -1333,6 +1401,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 +1412,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 +1423,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 +1434,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
@@ -1456,3 +1528,76 @@ class ReloadModelsTest < ActiveRecord::TestCase
   # `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// \* \* \*/}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 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

data/test/cases/column_test_sqlserver.rb

@@ -157,13 +157,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       _(col.default).must_equal            BigDecimal("191")
       _(obj.numeric_18_0).must_equal       BigDecimal("191")
       _(col.default_function).must_be_nil
+
       type = connection.lookup_cast_type_from_column(col)
-      _(type).must_be_instance_of Type::Decimal
+      _(type).must_be_instance_of Type::DecimalWithoutScale
       _(type.limit).must_be_nil
       _(type.precision).must_equal         18
-      _(type.scale).must_equal             0
+      _(type.scale).must_be_nil
+
       obj.numeric_18_0 = "192.1"
       _(obj.numeric_18_0).must_equal BigDecimal("192")
+
       obj.save!
       _(obj.reload.numeric_18_0).must_equal BigDecimal("192")
     end

data/test/cases/lateral_test_sqlserver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/post"
+require "models/author"
+
+class LateralTestSQLServer < ActiveRecord::TestCase
+  fixtures :posts, :authors
+
+  it 'uses OUTER APPLY for OUTER JOIN LATERAL' do
+    post = Arel::Table.new(:posts)
+    author = Arel::Table.new(:authors)
+    subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
+
+    one = Arel::Nodes::Quoted.new(1)
+    eq = Arel::Nodes::Equality.new(one, one)
+
+    sql = author.project(Arel.star).where(author[:name].matches("David")).outer_join(subselect.lateral.as("bar")).on(eq).to_sql
+    results = ActiveRecord::Base.connection.exec_query sql
+    assert_equal sql, "SELECT * FROM [authors] OUTER APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
+    assert_equal results.length, 1
+  end
+
+  it 'uses CROSS APPLY for INNER JOIN LATERAL' do
+    post = Arel::Table.new(:posts)
+    author = Arel::Table.new(:authors)
+    subselect = post.project(Arel.star).take(1).where(post[:author_id].eq(author[:id])).where(post[:id].eq(42))
+
+    sql = author.project(Arel.star).where(author[:name].matches("David")).join(subselect.lateral.as("bar")).to_sql
+    results = ActiveRecord::Base.connection.exec_query sql
+
+    assert_equal sql, "SELECT * FROM [authors] CROSS APPLY (SELECT * FROM [posts] WHERE [posts].[author_id] = [authors].[id] AND [posts].[id] = 42 ORDER BY [posts].[id] ASC OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY) AS bar WHERE [authors].[name] LIKE N'David'"
+    assert_equal results.length, 0
+  end
+end

data/test/cases/migration_test_sqlserver.rb

@@ -64,4 +64,48 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
     end
   end
+
+  describe "#create_schema" do
+    it "creates a new schema" do
+      connection.create_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+    end
+
+    it "creates a new schema with an owner" do
+      connection.create_schema("some schema", :guest)
+
+      schemas = connection.exec_query("select name, principal_id from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema", "principal_id" => 2 }
+    end
+  end
+
+  describe "#change_table_schema" do
+    before { connection.create_schema("foo") }
+
+    it "transfer the given table to the given schema" do
+      connection.change_table_schema("foo", "orders")
+
+      assert connection.data_source_exists?("foo.orders")
+    end
+  end
+
+  describe "#drop_schema" do
+    before { connection.create_schema("some schema") }
+
+    it "drops a schema" do
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+
+      connection.drop_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      refute_includes schemas, { "name" => "some schema" }
+    end
+  end
 end

data/test/cases/optimizer_hints_test_sqlserver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/company"
+
+class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
+  fixtures :companies
+
+  it "apply optimizations" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("HASH GROUP")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Hash Match | Aggregate  |"
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
+      companies = Company.optimizer_hints("ORDER GROUP")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Stream Aggregate | Aggregate  |"
+    end
+  end
+
+  it "apply multiple optimizations" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
+      companies = Company.optimizer_hints("HASH GROUP", "FAST 1")
+      companies = companies.distinct.select("firm_id")
+      assert_includes companies.explain, "| Hash Match | Flow Distinct |"
+    end
+  end
+
+  it "support subqueries" do
+    assert_sql(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
+      companies = Company.optimizer_hints("MAXDOP 2")
+      companies = companies.select(:id).where(firm_id: [0, 1]).limit(3)
+      assert_equal 3, companies.count
+    end
+  end
+
+  it "sanitize values" do
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("OPTION (HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("OPTION(HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
+      companies = Company.optimizer_hints("OPTION(TABLE HINT ([companies], INDEX(1)))")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+
+    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+      companies = Company.optimizer_hints("Option(HASH GROUP)")
+      companies = companies.distinct.select("firm_id")
+      companies.to_a
+    end
+  end
+
+  it "skip optimization after unscope" do
+    assert_sql("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
+      companies = Company.optimizer_hints("HASH GROUP")
+      companies = companies.distinct.select("firm_id")
+      companies.unscope(:optimizer_hints).load
+    end
+  end
+end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -16,7 +16,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :tinyint,           type: "integer",      limit: 1,             precision: nil,   scale: nil,  default: 42
     assert_line :bit,               type: "boolean",      limit: nil,           precision: nil,   scale: nil,  default: true
     assert_line :decimal_9_2,       type: "decimal",      limit: nil,           precision: 9,     scale: 2,    default: 12345.01
-    assert_line :numeric_18_0,      type: "decimal",      limit: nil,           precision: 18,    scale: 0,    default: 191.0
+    assert_line :numeric_18_0,      type: "decimal",      limit: nil,           precision: 18,    scale: nil,  default: 191
     assert_line :numeric_36_2,      type: "decimal",      limit: nil,           precision: 36,    scale: 2,    default: 12345678901234567890.01
     assert_line :money,             type: "money",        limit: nil,           precision: 19,    scale: 4,    default: 4.2
     assert_line :smallmoney,        type: "smallmoney",   limit: nil,           precision: 10,    scale: 4,    default: 4.2
@@ -75,7 +75,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :integer_col,     type: "integer",      limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :bigint_col,      type: "bigint",       limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :boolean_col,     type: "boolean",      limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :decimal_col,     type: "decimal",      limit: nil,          precision: 18,   scale: 0,   default: nil
+    assert_line :decimal_col,     type: "decimal",      limit: nil,          precision: 18,   scale: nil, default: nil
     assert_line :float_col,       type: "float",        limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :string_col,      type: "string",       limit: nil,          precision: nil,  scale: nil, default: nil
     assert_line :text_col,        type: "text",         limit: nil,          precision: nil,  scale: nil, default: nil
@@ -166,13 +166,15 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   def assert_line(column_name, options = {})
     line = line(column_name)
-    assert line, "Count not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+    assert line, "Could not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+
     [:type, :limit, :precision, :scale, :collation, :default].each do |key|
       next unless options.key?(key)
 
       actual   = key == :type ? line.send(:type_method) : line.send(key)
       expected = options[key]
       message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
+
       if expected.nil?
         _(actual).must_be_nil message
       elsif expected.is_a?(Array)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version
-  version: 6.0.1
+  version: 6.0.3
 platform: ruby
 authors:
 - Ken Collins
@@ -14,7 +14,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2023-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -54,9 +54,9 @@ extra_rdoc_files: []
 files:
 - ".editorconfig"
 - ".github/issue_template.md"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Dockerfile.ci
@@ -104,6 +104,7 @@ files:
 - lib/active_record/connection_adapters/sqlserver/type/datetime2.rb
 - lib/active_record/connection_adapters/sqlserver/type/datetimeoffset.rb
 - lib/active_record/connection_adapters/sqlserver/type/decimal.rb
+- lib/active_record/connection_adapters/sqlserver/type/decimal_without_scale.rb
 - lib/active_record/connection_adapters/sqlserver/type/float.rb
 - lib/active_record/connection_adapters/sqlserver/type/integer.rb
 - lib/active_record/connection_adapters/sqlserver/type/json.rb
@@ -154,7 +155,9 @@ files:
 - test/cases/in_clause_test_sqlserver.rb
 - test/cases/index_test_sqlserver.rb
 - test/cases/json_test_sqlserver.rb
+- test/cases/lateral_test_sqlserver.rb
 - test/cases/migration_test_sqlserver.rb
+- test/cases/optimizer_hints_test_sqlserver.rb
 - test/cases/order_test_sqlserver.rb
 - test/cases/pessimistic_locking_test_sqlserver.rb
 - test/cases/rake_test_sqlserver.rb
@@ -214,8 +217,8 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues
-  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v6.0.1/CHANGELOG.md
-  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v6.0.1
+  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v6.0.3/CHANGELOG.md
+  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v6.0.3
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -231,7 +234,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.4.7
 signing_key:
 specification_version: 4
 summary: ActiveRecord SQL Server Adapter.
@@ -253,7 +256,9 @@ test_files:
 - test/cases/in_clause_test_sqlserver.rb
 - test/cases/index_test_sqlserver.rb
 - test/cases/json_test_sqlserver.rb
+- test/cases/lateral_test_sqlserver.rb
 - test/cases/migration_test_sqlserver.rb
+- test/cases/optimizer_hints_test_sqlserver.rb
 - test/cases/order_test_sqlserver.rb
 - test/cases/pessimistic_locking_test_sqlserver.rb
 - test/cases/rake_test_sqlserver.rb

data/.travis.yml

@@ -1,23 +0,0 @@
-sudo: required
-cache: bundler
-services:
-  - docker
-env:
-  global:
-    - COMPOSE_FILE: docker-compose.ci.yml
-before_install:
-  - sudo rm /usr/local/bin/docker-compose
-  - sudo curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
-  - sudo chmod +x /usr/local/bin/docker-compose
-install:
-  - docker-compose build --build-arg TARGET_VERSION=$TARGET_VERSION
-script:
-  - docker-compose run ci
-matrix:
-  include:
-    - name: 2.5.8
-      env: TARGET_VERSION=2.5.8
-    - name: 2.6.6
-      env: TARGET_VERSION=2.6.6
-    - name: 2.7.1
-      env: TARGET_VERSION=2.7.1