activerecord-sqlserver-adapter 7.2.1 → 8.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73bbb76f7c1a620edbaf0aa6e69c5a8fcb9ba2f7c7c14716bb2663f776b8cb0d
-  data.tar.gz: a6d9ac56dbcddd486bd0111da5db2e2d0cc6c2bbc3519041a73fffa5cfc3fddb
+  metadata.gz: 926f65915d98bb3c271370883fa89891fc575b5c6801cd8c235386c078d34bf5
+  data.tar.gz: 0a932a9d5edf0d3932e3f0ba44328ed77a033a1223f05699e8f4caa79116ac56
 SHA512:
-  metadata.gz: 921bd35d9de85b363190dee9b001373fbae60b0c1e99755ff4b172c9f51510d7353b49fb39d636b4acc015755067846bfed6ca4f984eb75d91def007679154da
-  data.tar.gz: 384e76d966178e7c8bdc4f84cc03e3739bcfec1291fd42e57d8eb4804b7df37e4311f94ee659efa4d6b76a82ae833f8cd741f66bb667abf7a1e0c2f182107be9
+  metadata.gz: ee45540a8d2ae57dc69a35048f4ccfbf01bcfc91e177e57405b19ccb8a3279eef7b752c22dee20c4171c8bb4e2cb0fcaadb99cd6c25d139fd2ef53577a5cb23a
+  data.tar.gz: 9184a7041e5de445103bcd47832352614897865f0ef49e83067b553786d089be73eb73c34dfaf3f102e02804ee7d8d40803d5582430ebfeecbe95f568b0b7cb7

data/.github/workflows/ci.yml

@@ -1,6 +1,12 @@
 name: CI
 
-on: [push, pull_request]
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+  schedule:
+    - cron: '0 4 * * 1'
 
 jobs:
   test:
@@ -14,9 +20,8 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
-          - 3.1.6
-          - 3.2.4
-          - 3.3.2
+          - 3.3.4
+          - 3.2.5
 
     steps:
       - name: Checkout code

data/CHANGELOG.md

@@ -1,19 +1,12 @@
-## v7.2.1
-
-#### Fixed
-
-- [#1231](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1231) Enable identity insert on view's base table
-
-## v7.2.0
-
-#### Added
-
-- [#1178](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1178) Support encrypting binary columns
+## v8.0.0
 
 #### Changed
 
-- [#1153](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1153) Only support Ruby v3.1+
-- [#1196](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1196) Use default inspect for database adapter
+- [#1216](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1216) Refactor adapter interface to match abstract adapter
+- [#1225](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1225) Drop support to Ruby 3.1
+
+#### Fixed
 
+- [#1215](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1215) Fix mismatched foreign key errors
 
-Please check [7-1-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/7-1-stable/CHANGELOG.md) for previous changes.
+Please check [7-2-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/7-2-stable/CHANGELOG.md) for previous changes.

data/Dockerfile.ci

@@ -9,6 +9,6 @@ WORKDIR $WORKDIR
 
 COPY . $WORKDIR
 
-RUN RAILS_BRANCH=7-2-stable bundle install --jobs `expr $(cat /proc/cpuinfo | grep -c "cpu cores") - 1` --retry 3
+RUN bundle install --jobs `expr $(cat /proc/cpuinfo | grep -c "cpu cores") - 1` --retry 3
 
 CMD ["sh"]

data/Gemfile

@@ -18,6 +18,8 @@ if ENV["RAILS_SOURCE"]
   gemspec path: ENV["RAILS_SOURCE"]
 elsif ENV["RAILS_BRANCH"]
   gem "rails", github: "rails/rails", branch: ENV["RAILS_BRANCH"]
+elsif ENV["RAILS_COMMIT"]
+  gem "rails", github: "rails/rails", ref: ENV["RAILS_COMMIT"]
 else
   # Need to get rails source because the gem doesn't include tests
   version = ENV["RAILS_VERSION"] || begin

data/README.md

@@ -1,4 +1,4 @@
-# ActiveRecord SQL Server Adapter. For SQL Server 2012 And Higher.
+# ActiveRecord SQL Server Adapter
 
 * [![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
 * [![Gem Version](http://img.shields.io/gem/v/activerecord-sqlserver-adapter.svg)](https://rubygems.org/gems/activerecord-sqlserver-adapter) - Gem Version
@@ -8,15 +8,18 @@
 
 The SQL Server adapter for ActiveRecord using SQL Server 2012 or higher.
 
-Interested in older versions? We follow a rational versioning policy that tracks Rails. That means that our 7.x version
-of the adapter is only for the latest 7.x version of Rails. If you need the adapter for SQL Server 2008 or 2005, you
-are still in the right spot. Just install the latest 3.2.x to 4.1.x version of the adapter that matches your Rails
-version. We also have stable branches for each major/minor release of ActiveRecord. For older versions, please check
-their stable branches.
+We follow a rational versioning policy that tracks Rails. That means that our 7.x version of the adapter is only
+for the latest 7.x version of Rails. We also have stable branches for each major/minor release of ActiveRecord.
+
+We support the versions of the adapter that are in the Rails [Bug Fixes](https://rubyonrails.org/maintenance)
+maintenance group.
+
+See [Rubygems](https://rubygems.org/gems/activerecord-sqlserver-adapter/versions) for the latest version of the adapter for each Rails release.
 
 | Adapter Version | Rails Version | Support        | Branch                                                                                          |
 |-----------------|---------------|----------------|-------------------------------------------------------------------------------------------------|
-| `7.2.x`        | `7.2.x`       | Active | [main](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/main)             |
+| `8.0.0`         | `8.0.x`       | Active | [main](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/main)             |
+| `7.2.x`         | `7.2.x`       | Active         | [7-2-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/7-2-stable) |
 | `7.1.x`         | `7.1.x`       | Active         | [7-1-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/7-1-stable) |
 | `7.0.x`         | `7.0.x`       | Ended         | [7-0-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/7-0-stable) |
 | `6.1.x`         | `6.1.x`       | Ended         | [6-1-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/6-1-stable) |
@@ -26,7 +29,6 @@ their stable branches.
 | `4.2.x`         | `4.2.x`       | Ended          | [4-2-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/4-2-stable) |
 | `4.1.x`         | `4.1.x`       | Ended          | [4-1-stable](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/4-1-stable) |
 
-See [Rubygems](https://rubygems.org/gems/activerecord-sqlserver-adapter/versions) for the latest version of the adapter for each Rails release.
 
 #### Native Data Type Support
 
@@ -103,16 +105,14 @@ configuration then implement the `configure_connection` method in an initializer
 example we are setting the `TEXTSIZE` to 64 megabytes.
 
 ```ruby
-module ActiveRecord
-  module ConnectionAdapters
-    class SQLServerAdapter < AbstractAdapter
-      def configure_connection
-        super
-        @raw_connection.execute("SET TEXTSIZE #{64.megabytes}").do
-      end
+ActiveRecord::ConnectionAdapters::SQLServerAdapter.prepend(
+  Module.new do
+    def configure_connection
+      super
+      @raw_connection.execute("SET TEXTSIZE #{64.megabytes}").do
     end
   end
-end
+)
 ```
 
 #### Configure Application Name
@@ -262,7 +262,6 @@ Many many people have contributed. If you do not see your name here and it shoul
 
 You can see an up-to-date list of contributors here: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter/contributors
 
-
 ## License
 
 ActiveRecord SQL Server Adapter is released under the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-7.2.1
+8.0.0

data/activerecord-sqlserver-adapter.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::RUBY
   spec.version       = version
 
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.license       = "MIT"
   spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward", "Aidan Haran"]
@@ -27,6 +27,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", "~> 7.2.0"
+  spec.add_dependency "activerecord", "~> 8.0.0"
   spec.add_dependency "tiny_tds"
 end

data/docker-compose.ci.yml

@@ -5,7 +5,6 @@ services:
   ci:
     environment:
       - ACTIVERECORD_UNITTEST_HOST=sqlserver
-      - RAILS_BRANCH=7-2-stable
     build:
       context: .
       dockerfile: Dockerfile.ci

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

@@ -11,7 +11,7 @@ module ActiveRecord
           private
 
           def construct_relation_for_exists(conditions)
-            klass.with_connection do |connection|
+            model.with_connection do |connection|
               if connection.sqlserver?
                 _construct_relation_for_exists(conditions)
               else

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

@@ -13,50 +13,42 @@ module ActiveRecord
           !READ_QUERY.match?(sql.b)
         end
 
-        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-          log(sql, name, async: async) do |notification_payload|
-            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
-              result = if id_insert_table_name = query_requires_identity_insert?(sql)
-                         with_identity_insert_enabled(id_insert_table_name, conn) { internal_raw_execute(sql, conn, perform_do: true) }
-                       else
-                         internal_raw_execute(sql, conn, perform_do: true)
-                       end
-              verified!
-              notification_payload[:row_count] = result
-              result
-            end
+        def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
+          result = if id_insert_table_name = query_requires_identity_insert?(sql)
+                     # If the table name is a view, we need to get the base table name for enabling identity insert.
+                     id_insert_table_name = view_table_name(id_insert_table_name) if view_exists?(id_insert_table_name)
+
+                     with_identity_insert_enabled(id_insert_table_name, raw_connection) do
+                       internal_exec_sql_query(sql, raw_connection)
+                     end
+                   else
+                     internal_exec_sql_query(sql, raw_connection)
+                   end
+
+          verified!
+          notification_payload[:row_count] = result.count
+          result
+        end
+
+        def cast_result(raw_result)
+          if raw_result.columns.empty?
+            ActiveRecord::Result.empty
+          else
+            ActiveRecord::Result.new(raw_result.columns, raw_result.rows)
           end
         end
 
-        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false)
-          sql = transform_query(sql)
-
-          check_if_write_query(sql)
-          mark_transaction_written_if_write(sql)
+        def affected_rows(raw_result)
+          raw_result.first['AffectedRows']
+        end
 
-          unless without_prepared_statement?(binds)
+        def raw_execute(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
+          unless binds.nil? || binds.empty?
             types, params = sp_executesql_types_and_parameters(binds)
             sql = sp_executesql_sql(sql, types, params, name)
           end
 
-          log(sql, name, binds, async: async) do |notification_payload|
-            with_raw_connection do |conn|
-              result = if id_insert_table_name = query_requires_identity_insert?(sql)
-                         # If the table name is a view, we need to get the base table name for enabling identity insert.
-                         id_insert_table_name = view_table_name(id_insert_table_name) if view_exists?(id_insert_table_name)
-
-                         with_identity_insert_enabled(id_insert_table_name, conn) do
-                           internal_exec_sql_query(sql, conn)
-                         end
-                       else
-                         internal_exec_sql_query(sql, conn)
-                       end
-
-              verified!
-              notification_payload[:row_count] = result.count
-              result
-            end
-          end
+          super
         end
 
         def internal_exec_sql_query(sql, conn)
@@ -66,14 +58,14 @@ module ActiveRecord
           finish_statement_handle(handle)
         end
 
-        def exec_delete(sql, name, binds)
+        def exec_delete(sql, name = nil, binds = [])
           sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
-          super(sql, name, binds).rows.first.first
+          super(sql, name, binds)
         end
 
-        def exec_update(sql, name, binds)
+        def exec_update(sql, name = nil, binds = [])
           sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
-          super(sql, name, binds).rows.first.first
+          super(sql, name, binds)
         end
 
         def begin_db_transaction
@@ -156,7 +148,7 @@ module ActiveRecord
             returning_sql = if returning.is_a?(String)
                               returning
                             else
-                              returning.map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
+                              Array(returning).map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
                             end
             sql << " OUTPUT #{returning_sql}"
           end
@@ -332,14 +324,17 @@ module ActiveRecord
 
         def sp_executesql_sql_type(attr)
           if attr.respond_to?(:type)
-            return attr.type.sqlserver_type if attr.type.respond_to?(:sqlserver_type)
+            type = attr.type.is_a?(ActiveRecord::Normalization::NormalizedValueType) ? attr.type.cast_type : attr.type
+            type = type.subtype if type.serialized?
+
+            return type.sqlserver_type if type.respond_to?(:sqlserver_type)
 
-            if attr.type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType) && attr.type.instance_variable_get(:@cast_type).respond_to?(:sqlserver_type)
-              return attr.type.instance_variable_get(:@cast_type).sqlserver_type
+            if type.is_a?(ActiveRecord::Encryption::EncryptedAttributeType) && type.instance_variable_get(:@cast_type).respond_to?(:sqlserver_type)
+              return type.instance_variable_get(:@cast_type).sqlserver_type
             end
           end
 
-          value = basic_attribute_type?(attr) ? attr : attr.value_for_database
+          value = active_model_attribute?(attr) ? attr.value_for_database : attr
 
           if value.is_a?(Numeric)
             value > 2_147_483_647 ? "bigint".freeze : "int".freeze
@@ -349,7 +344,7 @@ module ActiveRecord
         end
 
         def sp_executesql_sql_param(attr)
-          return quote(attr) if basic_attribute_type?(attr)
+          return quote(attr) unless active_model_attribute?(attr)
 
           case value = attr.value_for_database
           when Type::Binary::Data, ActiveRecord::Type::SQLServer::Data
@@ -359,14 +354,8 @@ module ActiveRecord
           end
         end
 
-        def basic_attribute_type?(type)
-          type.is_a?(Symbol) ||
-            type.is_a?(String) ||
-            type.is_a?(Numeric) ||
-            type.is_a?(Time) ||
-            type.is_a?(TrueClass) ||
-            type.is_a?(FalseClass) ||
-            type.is_a?(NilClass)
+        def active_model_attribute?(type)
+          type.is_a?(::ActiveModel::Attribute)
         end
 
         def sp_executesql_sql(sql, types, params, name)
@@ -381,6 +370,7 @@ module ActiveRecord
             sql = "EXEC sp_executesql #{quote(sql)}"
             sql += ", #{types}, #{params}" unless params.empty?
           end
+
           sql.freeze
         end
 
@@ -458,10 +448,9 @@ module ActiveRecord
         # TinyTDS returns false instead of raising an exception if connection fails.
         # Getting around this by raising an exception ourselves while PR
         # https://github.com/rails-sqlserver/tiny_tds/pull/469 is not released.
-        def internal_raw_execute(sql, conn, perform_do: false)
-          result = conn.execute(sql).tap do |_result|
-            raise TinyTds::Error, "failed to execute statement" if _result.is_a?(FalseClass)
-          end
+        def internal_raw_execute(sql, raw_connection, perform_do: false)
+          result = raw_connection.execute(sql)
+          raise TinyTds::Error, "failed to execute statement" if result.is_a?(FalseClass)
 
           perform_do ? result.do : result
         end

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

@@ -14,22 +14,24 @@ module ActiveRecord
           res
         end
 
-        def drop_table(table_name, **options)
-          # Mimic CASCADE option as best we can.
-          if options[:force] == :cascade
-            execute_procedure(:sp_fkeys, pktable_name: table_name).each do |fkdata|
-              fktable = fkdata["FKTABLE_NAME"]
-              fkcolmn = fkdata["FKCOLUMN_NAME"]
-              pktable = fkdata["PKTABLE_NAME"]
-              pkcolmn = fkdata["PKCOLUMN_NAME"]
-              remove_foreign_key fktable, name: fkdata["FK_NAME"]
-              execute "DELETE FROM #{quote_table_name(fktable)} WHERE #{quote_column_name(fkcolmn)} IN ( SELECT #{quote_column_name(pkcolmn)} FROM #{quote_table_name(pktable)} )"
+        def drop_table(*table_names, **options)
+          table_names.each do |table_name|
+            # Mimic CASCADE option as best we can.
+            if options[:force] == :cascade
+              execute_procedure(:sp_fkeys, pktable_name: table_name).each do |fkdata|
+                fktable = fkdata["FKTABLE_NAME"]
+                fkcolmn = fkdata["FKCOLUMN_NAME"]
+                pktable = fkdata["PKTABLE_NAME"]
+                pkcolmn = fkdata["PKCOLUMN_NAME"]
+                remove_foreign_key fktable, name: fkdata["FK_NAME"]
+                execute "DELETE FROM #{quote_table_name(fktable)} WHERE #{quote_column_name(fkcolmn)} IN ( SELECT #{quote_column_name(pkcolmn)} FROM #{quote_table_name(pktable)} )"
+              end
+            end
+            if options[:if_exists] && version_year < 2016
+              execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}", "SCHEMA"
+            else
+              super
             end
-          end
-          if options[:if_exists] && version_year < 2016
-            execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = #{quote(table_name)}) DROP TABLE #{quote_table_name(table_name)}", "SCHEMA"
-          else
-            super
           end
         end
 
@@ -37,18 +39,16 @@ module ActiveRecord
           data = select("EXEC sp_helpindex #{quote(table_name)}", "SCHEMA") rescue []
 
           data.reduce([]) do |indexes, index|
-            index = index.with_indifferent_access
-
-            if index[:index_description].match?(/primary key/)
+            if index['index_description'].match?(/primary key/)
               indexes
             else
-              name    = index[:index_name]
-              unique  = index[:index_description].match?(/unique/)
+              name    = index['index_name']
+              unique  = index['index_description'].match?(/unique/)
               where   = select_value("SELECT [filter_definition] FROM sys.indexes WHERE name = #{quote(name)}", "SCHEMA")
               orders  = {}
               columns = []
 
-              index[:index_keys].split(",").each do |column|
+              index['index_keys'].split(",").each do |column|
                 column.strip!
 
                 if column.end_with?("(-)")
@@ -291,7 +291,7 @@ module ActiveRecord
         end
 
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
-          type_limitable = %w(string integer float char nchar varchar nvarchar).include?(type.to_s)
+          type_limitable = %w(string integer float char nchar varchar nvarchar binary_basic).include?(type.to_s)
           limit = nil unless type_limitable
 
           case type.to_s
@@ -480,16 +480,15 @@ module ActiveRecord
         end
 
         def column_definitions(table_name)
-          identifier  = database_prefix_identifier(table_name)
-          database    = identifier.fully_qualified_database_quoted
-          view_exists = view_exists?(table_name)
-          view_tblnm  = view_table_name(table_name) if view_exists
+          identifier      = database_prefix_identifier(table_name)
+          database        = identifier.fully_qualified_database_quoted
+          view_exists     = view_exists?(table_name)
 
           if view_exists
             sql = <<~SQL
               SELECT LOWER(c.COLUMN_NAME) AS [name], c.COLUMN_DEFAULT AS [default]
               FROM #{database}.INFORMATION_SCHEMA.COLUMNS c
-              WHERE c.TABLE_NAME = #{quote(view_tblnm)}
+              WHERE c.TABLE_NAME = #{quote(view_table_name(table_name))}
             SQL
             results = internal_exec_query(sql, "SCHEMA")
             default_functions = results.each.with_object({}) { |row, out| out[row["name"]] = row["default"] }.compact
@@ -498,71 +497,93 @@ module ActiveRecord
           sql = column_definitions_sql(database, identifier)
 
           binds = []
-          nv128 = SQLServer::Type::UnicodeVarchar.new limit: 128
+          nv128 = SQLServer::Type::UnicodeVarchar.new(limit: 128)
           binds << Relation::QueryAttribute.new("TABLE_NAME", identifier.object, nv128)
           binds << Relation::QueryAttribute.new("TABLE_SCHEMA", identifier.schema, nv128) unless identifier.schema.blank?
+
           results = internal_exec_query(sql, "SCHEMA", binds)
+          raise ActiveRecord::StatementInvalid, "Table '#{table_name}' doesn't exist" if results.empty?
 
           columns = results.map do |ci|
-            ci = ci.symbolize_keys
-            ci[:_type] = ci[:type]
-            ci[:table_name] = view_tblnm || table_name
-            ci[:type] = case ci[:type]
-                        when /^bit|image|text|ntext|datetime$/
-                          ci[:type]
-                        when /^datetime2|datetimeoffset$/i
-                          "#{ci[:type]}(#{ci[:datetime_precision]})"
-                        when /^time$/i
-                          "#{ci[:type]}(#{ci[:datetime_precision]})"
-                        when /^numeric|decimal$/i
-                          "#{ci[:type]}(#{ci[:numeric_precision]},#{ci[:numeric_scale]})"
-                        when /^float|real$/i
-                          "#{ci[:type]}"
-                        when /^char|nchar|varchar|nvarchar|binary|varbinary|bigint|int|smallint$/
-                          ci[:length].to_i == -1 ? "#{ci[:type]}(max)" : "#{ci[:type]}(#{ci[:length]})"
-                        else
-                          ci[:type]
-                        end
-            ci[:default_value],
-            ci[:default_function] = begin
-              default = ci[:default_value]
-              if default.nil? && view_exists
-                view_column = views_real_column_name(table_name, ci[:name]).downcase
-                default = default_functions[view_column] if view_column.present?
-              end
-              case default
-              when nil
-                [nil, nil]
-              when /\A\((\w+\(\))\)\Z/
-                default_function = Regexp.last_match[1]
-                [nil, default_function]
-              when /\A\(N'(.*)'\)\Z/m
-                string_literal = SQLServer::Utils.unquote_string(Regexp.last_match[1])
-                [string_literal, nil]
-              when /CREATE DEFAULT/mi
-                [nil, nil]
-              else
-                type = case ci[:type]
-                       when /smallint|int|bigint/ then ci[:_type]
-                       else ci[:type]
-                       end
-                value = default.match(/\A\((.*)\)\Z/m)[1]
-                value = select_value("SELECT CAST(#{value} AS #{type}) AS value", "SCHEMA")
-                [value, nil]
-              end
+            col = {
+              name:               ci["name"],
+              numeric_scale:      ci["numeric_scale"],
+              numeric_precision:  ci["numeric_precision"],
+              datetime_precision: ci["datetime_precision"],
+              collation:          ci["collation"],
+              ordinal_position:   ci["ordinal_position"],
+              length:             ci["length"]
+            }
+
+            col[:table_name] = view_exists ? view_table_name(table_name) : table_name
+            col[:type] = column_type(ci: ci)
+            col[:default_value], col[:default_function] = default_value_and_function(default: ci['default_value'],
+                                                                                     name: ci['name'],
+                                                                                     type: col[:type],
+                                                                                     original_type: ci['type'],
+                                                                                     view_exists: view_exists,
+                                                                                     table_name: table_name,
+                                                                                     default_functions: default_functions)
+
+            col[:null] = ci['is_nullable'].to_i == 1
+            col[:is_primary] = ci['is_primary'].to_i == 1
+
+            if [true, false].include?(ci['is_identity'])
+              col[:is_identity] = ci['is_identity']
+            else
+              col[:is_identity] = ci['is_identity'].to_i == 1
             end
-            ci[:null] = ci[:is_nullable].to_i == 1
-            ci.delete(:is_nullable)
-            ci[:is_primary] = ci[:is_primary].to_i == 1
-            ci[:is_identity] = ci[:is_identity].to_i == 1 unless [TrueClass, FalseClass].include?(ci[:is_identity].class)
-            ci
+
+            col
+          end
+
+          columns
+        end
+
+        def default_value_and_function(default:, name:, type:, original_type:, view_exists:, table_name:, default_functions:)
+          if default.nil? && view_exists
+            view_column = views_real_column_name(table_name, name).downcase
+            default = default_functions[view_column] if view_column.present?
           end
 
-          # Since Rails 7, it's expected that all adapter raise error when table doesn't exists.
-          # I'm not aware of the possibility of tables without columns on SQL Server (postgres have those).
-          # Raise error if the method return an empty array
-          columns.tap do |result|
-            raise ActiveRecord::StatementInvalid, "Table '#{table_name}' doesn't exist" if result.empty?
+          case default
+          when nil
+            [nil, nil]
+          when /\A\((\w+\(\))\)\Z/
+            default_function = Regexp.last_match[1]
+            [nil, default_function]
+          when /\A\(N'(.*)'\)\Z/m
+            string_literal = SQLServer::Utils.unquote_string(Regexp.last_match[1])
+            [string_literal, nil]
+          when /CREATE DEFAULT/mi
+            [nil, nil]
+          else
+            type = case type
+                   when /smallint|int|bigint/ then original_type
+                   else type
+                   end
+            value = default.match(/\A\((.*)\)\Z/m)[1]
+            value = select_value("SELECT CAST(#{value} AS #{type}) AS value", "SCHEMA")
+            [value, nil]
+          end
+        end
+
+        def column_type(ci:)
+          case ci['type']
+          when /^bit|image|text|ntext|datetime$/
+            ci['type']
+          when /^datetime2|datetimeoffset$/i
+            "#{ci['type']}(#{ci['datetime_precision']})"
+          when /^time$/i
+            "#{ci['type']}(#{ci['datetime_precision']})"
+          when /^numeric|decimal$/i
+            "#{ci['type']}(#{ci['numeric_precision']},#{ci['numeric_scale']})"
+          when /^float|real$/i
+            "#{ci['type']}"
+          when /^char|nchar|varchar|nvarchar|binary|varbinary|bigint|int|smallint$/
+            ci['length'].to_i == -1 ? "#{ci['type']}(max)" : "#{ci['type']}(#{ci['length']})"
+          else
+            ci['type']
           end
         end
 
@@ -681,6 +702,7 @@ module ActiveRecord
             s.split(/INSERT INTO/i)[1]
               .split(/OUTPUT INSERTED/i)[0]
               .split(/(DEFAULT)?\s+VALUES/i)[0]
+              .split(/\bSELECT\b(?![^\[]*\])/i)[0]
               .match(/\s*([^(]*)/i)[0]
           elsif s.match?(/^\s*UPDATE\s+.*/i)
             s.match(/UPDATE\s+([^\(\s]+)\s*/i)[1]
@@ -701,25 +723,26 @@ module ActiveRecord
 
         def view_table_name(table_name)
           view_info = view_information(table_name)
-          view_info ? get_table_name(view_info["VIEW_DEFINITION"]) : table_name
+          view_info.present? ? get_table_name(view_info["VIEW_DEFINITION"]) : table_name
         end
 
         def view_information(table_name)
           @view_information ||= {}
+
           @view_information[table_name] ||= begin
             identifier = SQLServer::Utils.extract_identifiers(table_name)
             information_query_table = identifier.database.present? ? "[#{identifier.database}].[INFORMATION_SCHEMA].[VIEWS]" :  "[INFORMATION_SCHEMA].[VIEWS]"
-            view_info = select_one "SELECT * FROM #{information_query_table} WITH (NOLOCK) WHERE TABLE_NAME = #{quote(identifier.object)}", "SCHEMA"
-
-            if view_info
-              view_info = view_info.with_indifferent_access
-              if view_info[:VIEW_DEFINITION].blank? || view_info[:VIEW_DEFINITION].length == 4000
-                view_info[:VIEW_DEFINITION] = begin
-                                                select_values("EXEC sp_helptext #{identifier.object_quoted}", "SCHEMA").join
-                                              rescue
-                                                warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
-                                                nil
-                                              end
+
+            view_info = select_one("SELECT * FROM #{information_query_table} WITH (NOLOCK) WHERE TABLE_NAME = #{quote(identifier.object)}", "SCHEMA").to_h
+
+            if view_info.present?
+              if view_info['VIEW_DEFINITION'].blank? || view_info['VIEW_DEFINITION'].length == 4000
+                view_info['VIEW_DEFINITION'] = begin
+                                                 select_values("EXEC sp_helptext #{identifier.object_quoted}", "SCHEMA").join
+                                               rescue
+                                                 warn "No view definition found, possible permissions problem.\nPlease run GRANT VIEW DEFINITION TO your_user;"
+                                                 nil
+                                               end
               end
             end
 
@@ -728,8 +751,8 @@ module ActiveRecord
         end
 
         def views_real_column_name(table_name, column_name)
-          view_definition = view_information(table_name)[:VIEW_DEFINITION]
-          return column_name unless view_definition
+          view_definition = view_information(table_name)['VIEW_DEFINITION']
+          return column_name if view_definition.blank?
 
           # Remove "CREATE VIEW ... AS SELECT ..." and then match the column name.
           match_data = view_definition.sub(/CREATE\s+VIEW.*AS\s+SELECT\s/, '').match(/([\w-]*)\s+AS\s+#{column_name}\W/im)

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

@@ -16,6 +16,7 @@ module ActiveRecord
           sql = to_sql(arel)
           result = with_showplan_on { internal_exec_query(sql, "EXPLAIN", binds) }
           printer = showplan_printer.new(result)
+
           printer.pp
         end
 

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

@@ -36,9 +36,10 @@ module ActiveRecord
 
           def cast_value(value)
             value = super
-            return if value.blank?
 
-            value = value.change year: 2000, month: 01, day: 01
+            return value unless value.is_a?(::Time)
+
+            value = value.change(year: 2000, month: 01, day: 01)
             apply_seconds_precision(value)
           end
 

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -4,9 +4,7 @@ require "tiny_tds"
 require "base64"
 require "active_record"
 require "arel_sqlserver"
-require "active_record/connection_adapters/abstract_adapter"
 require "active_record/connection_adapters/sqlserver/core_ext/active_record"
-require "active_record/connection_adapters/sqlserver/core_ext/calculations"
 require "active_record/connection_adapters/sqlserver/core_ext/explain"
 require "active_record/connection_adapters/sqlserver/core_ext/explain_subscriber"
 require "active_record/connection_adapters/sqlserver/core_ext/attribute_methods"
@@ -431,36 +429,28 @@ module ActiveRecord
         TYPE_MAP
       end
 
-      def translate_exception(e, message:, sql:, binds:)
+      def translate_exception(exception, message:, sql:, binds:)
         case message
         when /(SQL Server client is not connected)|(failed to execute statement)/i
-          ConnectionNotEstablished.new(message)
+          ConnectionNotEstablished.new(message, connection_pool: @pool)
         when /(cannot insert duplicate key .* with unique index) | (violation of (unique|primary) key constraint)/i
-          RecordNotUnique.new(message, sql: sql, binds: binds)
+          RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /(conflicted with the foreign key constraint) | (The DELETE statement conflicted with the REFERENCE constraint)/i
-          InvalidForeignKey.new(message, sql: sql, binds: binds)
+          InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /has been chosen as the deadlock victim/i
-          DeadlockVictim.new(message, sql: sql, binds: binds)
+          DeadlockVictim.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /database .* does not exist/i
-          NoDatabaseError.new(message)
+          NoDatabaseError.new(message, connection_pool: @pool)
         when /data would be truncated/
-          ValueTooLong.new(message, sql: sql, binds: binds)
+          ValueTooLong.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /connection timed out/
-          StatementTimeout.new(message, sql: sql, binds: binds)
+          StatementTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Column '(.*)' is not the same data type as referencing column '(.*)' in foreign key/
-          pk_id, fk_id = SQLServer::Utils.extract_identifiers($1), SQLServer::Utils.extract_identifiers($2)
-          MismatchedForeignKey.new(
-            self,
-            message: message,
-            table: fk_id.schema,
-            foreign_key: fk_id.object,
-            target_table: pk_id.schema,
-            primary_key: pk_id.object
-          )
+          MismatchedForeignKey.new(message: message, connection_pool: @pool)
         when /Cannot insert the value NULL into column.*does not allow nulls/
-          NotNullViolation.new(message, sql: sql, binds: binds)
+          NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Arithmetic overflow error/
-          RangeError.new(message, sql: sql, binds: binds)
+          RangeError.new(message, sql: sql, binds: binds, connection_pool: @pool)
         else
           super
         end

data/lib/arel/visitors/sqlserver.rb

@@ -134,26 +134,24 @@ module Arel
 
       def visit_Arel_Nodes_SelectStatement(o, collector)
         @select_statement = o
+        optimizer_hints = nil
         distinct_One_As_One_Is_So_Not_Fetch o
         if o.with
           collector = visit o.with, collector
           collector << " "
         end
-        collector = o.cores.inject(collector) { |c, x|
-          visit_Arel_Nodes_SelectCore(x, c)
-        }
+        collector = o.cores.inject(collector) do |collect, core|
+          optimizer_hints = core.optimizer_hints if core.optimizer_hints
+          visit_Arel_Nodes_SelectCore(core, collect)
+        end
         collector = visit_Orders_And_Let_Fetch_Happen o, collector
         collector = visit_Make_Fetch_Happen o, collector
+        collector = maybe_visit optimizer_hints, collector
         collector
       ensure
         @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})"

data/test/cases/adapter_test_sqlserver.rb

@@ -464,13 +464,13 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert SSTestStringDefaultsView.lease_connection.data_source_exists?(SSTestStringDefaultsView.table_name)
     end
 
-    # That have more than 4000 chars for their defintion
+    # That have more than 4000 chars for their definition
 
-    it "cope with null returned for the defintion" do
+    it "cope with null returned for the definition" do
       assert_nothing_raised() { SSTestStringDefaultsBigView.columns }
     end
 
-    it "using alternate view defintion still be able to find real default" do
+    it "using alternate view definition still be able to find real default" do
       assert_equal "null", SSTestStringDefaultsBigView.new.pretend_null,
                    SSTestStringDefaultsBigView.columns_hash["pretend_null"].inspect
     end
@@ -542,7 +542,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @conn.execute("INSERT INTO [subscribers] ([nick]) VALUES ('aido')")
 
       ActiveRecord::Base.while_preventing_writes do
-        assert_equal 1, @conn.execute("SELECT * FROM [subscribers] WHERE [subscribers].[nick] = 'aido'")
+        assert_equal 1, @conn.execute("SELECT * FROM [subscribers] WHERE [subscribers].[nick] = 'aido'").count
       end
     end
   end
@@ -580,4 +580,40 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       end
     end
   end
+
+  describe "mismatched foreign keys error" do
+    def setup
+      @conn = ActiveRecord::Base.lease_connection
+    end
+
+    it 'raises an error when the foreign key is mismatched' do
+     error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+        @conn.add_reference :engines, :old_car
+        @conn.add_foreign_key :engines, :old_cars
+      end
+
+      assert_match(
+        %r/Column 'old_cars\.id' is not the same data type as referencing column 'engines\.old_car_id' in foreign key '.*'/,
+        error.message
+      )
+      assert_not_nil error.cause
+      assert_equal @conn.pool, error.connection_pool
+    ensure
+      @conn.execute("ALTER TABLE engines DROP COLUMN old_car_id") rescue nil
+    end
+  end
+
+  describe "placeholder conditions" do
+    it 'using time placeholder' do
+      assert_equal Task.where("starting < ?", Time.now).count, 1
+    end
+
+    it 'using date placeholder' do
+      assert_equal Task.where("starting < ?", Date.today).count, 1
+    end
+
+    it 'using date-time placeholder' do
+      assert_equal Task.where("starting < ?", DateTime.current).count, 1
+    end
+  end
 end

data/test/cases/coerced_tests.rb

@@ -520,6 +520,9 @@ class CalculationsTest < ActiveRecord::TestCase
 
   # SELECT columns must be in the GROUP clause. Since since `ids` only selects the primary key you cannot perform this query in SQL Server.
   coerce_tests! :test_ids_with_includes_and_non_primary_key_order
+
+  # To limit the results in SQL Server we use `FETCH NEXT @0 ROWS ONLY` instead of `LIMIT @0`. To use `FETCH NEXT` an order must be provided.
+  coerce_tests! :test_no_order_by_when_counting_all
 end
 
 module ActiveRecord
@@ -1337,6 +1340,20 @@ module ActiveRecord
     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
     end
+
+    # Same as original test except string has `N` prefix to indicate unicode string.
+    coerce_tests! :test_registering_new_handlers_for_joins
+    def test_registering_new_handlers_for_joins_coerced
+      Reply.belongs_to :regexp_topic, -> { where(title: /rails/) }, class_name: "Topic", foreign_key: "parent_id"
+
+      assert_match %r{#{Regexp.escape(quote_table_name("regexp_topic.title"))} ~ N'rails'}i, Reply.joins(:regexp_topic).references(Arel.sql("regexp_topic")).to_sql
+    end
+
+    private
+
+    def topic_title
+      Topic.lease_connection.quote_table_name("topics.title")
+    end
   end
 end
 
@@ -2168,17 +2185,6 @@ class EnumTest < ActiveRecord::TestCase
     Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
   end
 
-  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
-  coerce_tests! %r{declare multiple enums at a time}
-  test "declare multiple enums at a time coerced" do
-    Book.lease_connection.remove_index(:books, column: [:author_id, :name])
-
-    send(:'original_declare multiple enums at a time')
-  ensure
-    Book.where(author_id: nil, name: nil).delete_all
-    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
-  end
-
   # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
   coerce_tests! %r{serializable\? with large number label}
   test "serializable? with large number label coerced" do
@@ -2250,14 +2256,6 @@ class LogSubscriberTest < ActiveRecord::TestCase
   def test_verbose_query_logs_coerced
     original_test_verbose_query_logs
   end
-
-  # Bindings logged slightly differently.
-  coerce_tests! :test_where_in_binds_logging_include_attribute_names
-  def test_where_in_binds_logging_include_attribute_names_coerced
-    Developer.where(id: [1, 2, 3, 4, 5]).load
-    wait
-    assert_match(%{@0 = 1, @1 = 2, @2 = 3, @3 = 4, @4 = 5  [["id", nil], ["id", nil], ["id", nil], ["id", nil], ["id", nil]]}, @logger.logged(:debug).last)
-  end
 end
 
 class ReloadModelsTest < ActiveRecord::TestCase
@@ -2419,7 +2417,9 @@ class QueryLogsTest < ActiveRecord::TestCase
   # SQL requires double single-quotes.
   coerce_tests! :test_sql_commenter_format
   def test_sql_commenter_format_coerced
-    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+    ActiveRecord::QueryLogs.tags = [:application]
+
     assert_queries_match(%r{/\*application=''active_record''\*/}) do
       Dashboard.first
     end
@@ -2428,7 +2428,7 @@ class QueryLogsTest < ActiveRecord::TestCase
   # SQL requires double single-quotes.
   coerce_tests! :test_sqlcommenter_format_value
   def test_sqlcommenter_format_value_coerced
-    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
 
     ActiveRecord::QueryLogs.tags = [
       :application,
@@ -2443,7 +2443,7 @@ class QueryLogsTest < ActiveRecord::TestCase
   # SQL requires double single-quotes.
   coerce_tests! :test_sqlcommenter_format_value_string_coercible
   def test_sqlcommenter_format_value_string_coercible_coerced
-    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
 
     ActiveRecord::QueryLogs.tags = [
       :application,
@@ -2458,7 +2458,7 @@ class QueryLogsTest < ActiveRecord::TestCase
   # SQL requires double single-quotes.
   coerce_tests! :test_sqlcommenter_format_allows_string_keys
   def test_sqlcommenter_format_allows_string_keys_coerced
-    ActiveRecord::QueryLogs.update_formatter(:sqlcommenter)
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
 
     ActiveRecord::QueryLogs.tags = [
       :application,
@@ -2493,6 +2493,17 @@ class InsertAllTest < ActiveRecord::TestCase
     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.
+  coerce_tests! :test_insert_with_type_casting_and_serialize_is_consistent
+  def test_insert_with_type_casting_and_serialize_is_consistent_coerced
+    connection.remove_index(:books, column: [:author_id, :name])
+
+    original_test_insert_with_type_casting_and_serialize_is_consistent
+  ensure
+    Book.where(author_id: nil, name: '["Array"]').delete_all
+    Book.lease_connection.add_index(:books, [:author_id, :name], unique: true)
+  end
 end
 
 module ActiveRecord
@@ -2655,6 +2666,28 @@ module ActiveRecord
   end
 end
 
+module ActiveRecord
+  module ConnectionAdapters
+    class RegistrationIsolatedTest < ActiveRecord::TestCase
+      # SQL Server was not included in the list of available adapters in the error message.
+      coerce_tests! %r{resolve raises if the adapter is using the pre 7.2 adapter registration API}
+      def resolve_raises_if_the_adapter_is_using_the_pre_7_2_adapter_registration_API
+        exception = assert_raises(ActiveRecord::AdapterNotFound) do
+          ActiveRecord::ConnectionAdapters.resolve("fake_legacy")
+        end
+
+        assert_equal(
+          "Database configuration specifies nonexistent 'ridiculous' adapter. Available adapters are: abstract, fake, mysql2, postgresql, sqlite3, sqlserver, trilogy. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile if it's not in the list of available adapters.",
+          exception.message
+        )
+      ensure
+        ActiveRecord::ConnectionAdapters.instance_variable_get(:@adapters).delete("fake_legacy")
+      end
+    end
+  end
+end
+
+
 module ActiveRecord
   class TableMetadataTest < ActiveSupport::TestCase
     # Adapter returns an object that is subclass of what is expected in the original test.

data/test/cases/optimizer_hints_test_sqlserver.rb

@@ -36,6 +36,14 @@ class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
     end
   end
 
+  it "support order" do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ ORDER .+ OPTION .+\z}) do
+      companies = Company.optimizer_hints("LABEL='FindCompanies'")
+      companies = companies.order(:id)
+      companies.to_a
+    end
+  end
+
   it "sanitize values" do
     assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("OPTION (HASH GROUP)")

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -93,39 +93,41 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     assert_line :binary_col,                 type: "binary"
 
     # Our type methods.
-    _(columns["real_col"].sql_type).must_equal          "real"
-    _(columns["money_col"].sql_type).must_equal         "money"
-    _(columns["smalldatetime_col"].sql_type).must_equal "smalldatetime"
-    _(columns["datetime2_col"].sql_type).must_equal     "datetime2(7)"
-    _(columns["datetimeoffset"].sql_type).must_equal    "datetimeoffset(7)"
-    _(columns["smallmoney_col"].sql_type).must_equal    "smallmoney"
-    _(columns["char_col"].sql_type).must_equal          "char(1)"
-    _(columns["varchar_col"].sql_type).must_equal       "varchar(8000)"
-    _(columns["text_basic_col"].sql_type).must_equal    "text"
-    _(columns["nchar_col"].sql_type).must_equal         "nchar(1)"
-    _(columns["ntext_col"].sql_type).must_equal         "ntext"
-    _(columns["binary_basic_col"].sql_type).must_equal  "binary(1)"
-    _(columns["varbinary_col"].sql_type).must_equal     "varbinary(8000)"
-    _(columns["uuid_col"].sql_type).must_equal          "uniqueidentifier"
-    _(columns["sstimestamp_col"].sql_type).must_equal   "timestamp"
-    _(columns["json_col"].sql_type).must_equal          "nvarchar(max)"
-
-    assert_line :real_col,          type: "real"
-    assert_line :money_col,         type: "money",                      precision: 19,  scale: 4
-    assert_line :smalldatetime_col, type: "smalldatetime"
-    assert_line :datetime2_col,     type: "datetime",                   precision: 7
-    assert_line :datetimeoffset,    type: "datetimeoffset",             precision: 7
-    assert_line :smallmoney_col,    type: "smallmoney",                 precision: 10,  scale: 4
-    assert_line :char_col,          type: "char",           limit: 1
-    assert_line :varchar_col,       type: "varchar"
-    assert_line :text_basic_col,    type: "text_basic"
-    assert_line :nchar_col,         type: "nchar",          limit: 1
-    assert_line :ntext_col,         type: "ntext"
-    assert_line :binary_basic_col,  type: "binary_basic",   limit: 1
-    assert_line :varbinary_col,     type: "varbinary"
-    assert_line :uuid_col,          type: "uuid"
-    assert_line :sstimestamp_col,   type: "ss_timestamp",                                           null: false
-    assert_line :json_col,          type: "text"
+    _(columns["real_col"].sql_type).must_equal            "real"
+    _(columns["money_col"].sql_type).must_equal           "money"
+    _(columns["smalldatetime_col"].sql_type).must_equal   "smalldatetime"
+    _(columns["datetime2_col"].sql_type).must_equal       "datetime2(7)"
+    _(columns["datetimeoffset"].sql_type).must_equal      "datetimeoffset(7)"
+    _(columns["smallmoney_col"].sql_type).must_equal      "smallmoney"
+    _(columns["char_col"].sql_type).must_equal            "char(1)"
+    _(columns["varchar_col"].sql_type).must_equal         "varchar(8000)"
+    _(columns["text_basic_col"].sql_type).must_equal      "text"
+    _(columns["nchar_col"].sql_type).must_equal           "nchar(1)"
+    _(columns["ntext_col"].sql_type).must_equal           "ntext"
+    _(columns["binary_basic_col"].sql_type).must_equal    "binary(1)"
+    _(columns["binary_basic_16_col"].sql_type).must_equal "binary(16)"
+    _(columns["varbinary_col"].sql_type).must_equal       "varbinary(8000)"
+    _(columns["uuid_col"].sql_type).must_equal            "uniqueidentifier"
+    _(columns["sstimestamp_col"].sql_type).must_equal     "timestamp"
+    _(columns["json_col"].sql_type).must_equal            "nvarchar(max)"
+
+    assert_line :real_col,            type: "real"
+    assert_line :money_col,           type: "money",                      precision: 19,  scale: 4
+    assert_line :smalldatetime_col,   type: "smalldatetime"
+    assert_line :datetime2_col,       type: "datetime",                   precision: 7
+    assert_line :datetimeoffset,      type: "datetimeoffset",             precision: 7
+    assert_line :smallmoney_col,      type: "smallmoney",                 precision: 10,  scale: 4
+    assert_line :char_col,            type: "char",           limit: 1
+    assert_line :varchar_col,         type: "varchar"
+    assert_line :text_basic_col,      type: "text_basic"
+    assert_line :nchar_col,           type: "nchar",          limit: 1
+    assert_line :ntext_col,           type: "ntext"
+    assert_line :binary_basic_col,    type: "binary_basic",   limit: 1
+    assert_line :binary_basic_16_col, type: "binary_basic",   limit: 16
+    assert_line :varbinary_col,       type: "varbinary"
+    assert_line :uuid_col,            type: "uuid"
+    assert_line :sstimestamp_col,     type: "ss_timestamp",                                           null: false
+    assert_line :json_col,            type: "text"
   end
 
   it "dump column collation" do

data/test/cases/schema_test_sqlserver.rb

@@ -96,6 +96,10 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
       it do
         assert_equal "[test].[aliens]", connection.send(:get_raw_table_name, "EXEC sp_executesql N'INSERT INTO [test].[aliens] ([name]) OUTPUT INSERTED.[id] VALUES (@0)', N'@0 varchar(255)', @0 = 'Trisolarans'")
       end
+
+      it do
+        assert_equal "[with].[select notation]", connection.send(:get_raw_table_name, "INSERT INTO [with].[select notation] SELECT * FROM [table_name]")
+      end
     end
   end
 end

data/test/schema/sqlserver_specific_schema.rb

@@ -33,6 +33,7 @@ ActiveRecord::Schema.define do
     t.nchar          :nchar_col
     t.ntext          :ntext_col
     t.binary_basic   :binary_basic_col
+    t.binary_basic   :binary_basic_16_col, limit: 16
     t.varbinary      :varbinary_col
     t.uuid           :uuid_col
     t.ss_timestamp   :sstimestamp_col

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version
-  version: 7.2.1
+  version: 8.0.0
 platform: ruby
 authors:
 - Ken Collins
@@ -15,7 +15,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -23,14 +23,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 8.0.0
 - !ruby/object:Gem::Dependency
   name: tiny_tds
   requirement: !ruby/object:Gem::Requirement
@@ -79,7 +79,6 @@ files:
 - lib/active_record/connection_adapters/sqlserver/core_ext/abstract_adapter.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/active_record.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/attribute_methods.rb
-- lib/active_record/connection_adapters/sqlserver/core_ext/calculations.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/explain_subscriber.rb
 - lib/active_record/connection_adapters/sqlserver/core_ext/finder_methods.rb
@@ -239,8 +238,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/v7.2.1/CHANGELOG.md
-  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v7.2.1
+  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v8.0.0/CHANGELOG.md
+  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v8.0.0
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -249,14 +248,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: ActiveRecord SQL Server Adapter.

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record/relation"
-require "active_record/version"
-
-module ActiveRecord
-  module ConnectionAdapters
-    module SQLServer
-      module CoreExt
-        module Calculations
-
-          private
-          
-          def build_count_subquery(relation, column_name, distinct)
-            klass.with_connection do |connection|
-              relation = relation.unscope(:order) if connection.sqlserver?
-              super(relation, column_name, distinct)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ActiveSupport.on_load(:active_record) do
-  mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Calculations
-  ActiveRecord::Relation.include(mod)
-end