activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/Rakefile

@@ -9,6 +9,8 @@ task test: ["test:dblib"]
 task default: [:test]
 
 namespace :test do
+  ENV["ARCONN"] = "sqlserver"
+
   %w(dblib).each do |mode|
     Rake::TestTask.new(mode) do |t|
       t.libs = ARTest::SQLServer.test_load_paths
@@ -17,14 +19,8 @@ namespace :test do
       t.verbose = false
     end
   end
-
-  task "dblib:env" do
-    ENV["ARCONN"] = "dblib"
-  end
 end
 
-task "test:dblib" => "test:dblib:env"
-
 namespace :profile do
   ["dblib"].each do |mode|
     namespace mode.to_sym do

data/VERSION

@@ -1 +1 @@
-6.1.2.1
+7.2.4

data/activerecord-sqlserver-adapter.gemspec

@@ -7,10 +7,10 @@ Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::RUBY
   spec.version       = version
 
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 3.1.0"
 
   spec.license       = "MIT"
-  spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward"]
+  spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward", "Aidan Haran"]
   spec.email         = ["ken@metaskills.net", "will@wbond.net"]
   spec.homepage      = "http://github.com/rails-sqlserver/activerecord-sqlserver-adapter"
   spec.summary       = "ActiveRecord SQL Server Adapter."
@@ -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", "~> 6.1.0"
+  spec.add_dependency "activerecord", "~> 7.2.0"
   spec.add_dependency "tiny_tds"
 end

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: "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-x64"
+    - ruby_version: "30"

data/docker-compose.ci.yml

@@ -1,10 +1,11 @@
 version: "2.2"
 services:
   sqlserver:
-    image: metaskills/mssql-server-linux-rails
+    image: ghcr.io/rails-sqlserver/mssql-server-linux-rails
   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/abstract_adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module AbstractAdapter
+          def sqlserver?
+            false
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::AbstractAdapter
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(mod)
+end

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

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

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

@@ -8,32 +8,14 @@ module ActiveRecord
     module SQLServer
       module CoreExt
         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
-
-              if operation.to_s.downcase == "count"
-                unless distinct_value || distinct_select?(column_name || select_for_count)
-                  relation.distinct!
-                  relation.select_values = [klass.primary_key || table[Arel.star]]
-                end
-              end
-
-              relation.calculate(operation, column_name)
-            else
-              perform_calculation(operation, column_name)
-            end
-          end
 
           private
-
+          
           def build_count_subquery(relation, column_name, distinct)
-            return super unless klass.connection.adapter_name == "SQLServer"
-
-            super(relation.unscope(:order), column_name, distinct)
+            klass.with_connection do |connection|
+              relation = relation.unscope(:order) if connection.sqlserver?
+              super(relation, column_name, distinct)
+            end
           end
         end
       end

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

@@ -8,20 +8,23 @@ module ActiveRecord
           SQLSERVER_STATEMENT_PREFIX = "EXEC sp_executesql "
           SQLSERVER_STATEMENT_REGEXP = /N'(.+)', N'(.+)', (.+)/
 
-          def exec_explain(queries)
-            return super unless connection.adapter_name == "SQLServer"
+          def exec_explain(queries, options = [])
+            with_connection do |connection|
+              return super(queries, options) unless connection.sqlserver?
 
-            unprepared_queries = queries.map do |(sql, binds)|
-              [unprepare_sqlserver_statement(sql, binds), binds]
+              unprepared_queries = queries.map do |(sql, binds)|
+                [unprepare_sqlserver_statement(sql, binds), binds]
+              end
+
+              super(unprepared_queries, options)
             end
-            super(unprepared_queries)
           end
 
           private
 
-          # This is somewhat hacky, but it should reliably reformat our prepared sql statment
+          # This is somewhat hacky, but it should reliably reformat our prepared sql statement
           # which uses sp_executesql to just the first argument, then unquote it. Likewise our
-          # `sp_executesql` method should substitude the @n args with the quoted values.
+          # `sp_executesql` method should substitute the @n args with the quoted values.
           def unprepare_sqlserver_statement(sql, binds)
             return sql unless sql.start_with?(SQLSERVER_STATEMENT_PREFIX)
 

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/kernel/reporting"
+
 ActiveSupport.on_load(:active_record) do
   silence_warnings do
     # Already defined in Rails

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

@@ -10,18 +10,28 @@ module ActiveRecord
         module FinderMethods
           private
 
-          # 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"
+            klass.with_connection do |connection|
+              if connection.sqlserver?
+                _construct_relation_for_exists(conditions)
+              else
+                super
+              end
+            end
+          end
 
+          # Same as original except we order by values in distinct select if present.
+          def _construct_relation_for_exists(conditions)
             conditions = sanitize_forbidden_attributes(conditions)
 
             if distinct_value && offset_value
+              # Start of monkey-patch
               if select_values.present?
                 relation = order(*select_values).limit!(1)
               else
                 relation = except(:order).limit!(1)
               end
+              # End of monkey-patch
             else
               relation = except(:select, :distinct, :order)._select!(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit!(1)
             end

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

@@ -6,20 +6,28 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module CoreExt
-        module Preloader
-          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
-                # because the record is modified but not an owner
-                owner = owners_by_key[convert_key(record[association_key_name])].first
-                association = owner.association(reflection.name)
-                association.set_inverse_instance(record)
-              end.records
+        module LoaderQuery
+          def load_records_for_keys(keys, &block)
+            scope.with_connection do |connection|
+              return super unless connection.sqlserver?
+
+              return [] if keys.empty?
+
+              if association_key_name.is_a?(Array)
+                query_constraints = Hash.new { |hsh, key| hsh[key] = Set.new }
+
+                keys.each_with_object(query_constraints) do |values_set, constraints|
+                  association_key_name.zip(values_set).each do |key_name, value|
+                    constraints[key_name] << value
+                  end
+                end
+
+                scope.where(query_constraints).load(&block)
+              else
+                keys.each_slice(in_clause_length).flat_map do |slice|
+                  scope.where(association_key_name => slice).load(&block).records
+                end
+              end
             end
           end
 
@@ -33,6 +41,6 @@ module ActiveRecord
 end
 
 ActiveSupport.on_load(:active_record) do
-  mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::Preloader
-  ActiveRecord::Associations::Preloader::Association.prepend(mod)
+  mod = ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::LoaderQuery
+  ActiveRecord::Associations::Preloader::Association::LoaderQuery.prepend(mod)
 end

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

@@ -8,45 +8,14 @@ module ActiveRecord
           128
         end
 
-        def column_name_length
-          128
-        end
-        deprecate :column_name_length
-
         def table_name_length
           128
         end
-        deprecate :table_name_length
 
         def index_name_length
           128
         end
 
-        def columns_per_table
-          1024
-        end
-        deprecate :columns_per_table
-
-        def indexes_per_table
-          999
-        end
-        deprecate :indexes_per_table
-
-        def columns_per_multicolumn_index
-          16
-        end
-        deprecate :columns_per_multicolumn_index
-
-        def sql_query_length
-          65_536 * 4_096
-        end
-        deprecate :sql_query_length
-
-        def joins_per_query
-          256
-        end
-        deprecate :joins_per_query
-
         private
 
         # The max number of binds is 2100, but because sp_executesql takes