activerecord-sqlserver-adapter 7.1.10 → 7.2.0

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

@@ -4,9 +4,53 @@ module ActiveRecord
   module ConnectionAdapters
     module SQLServer
       module Quoting
+        extend ActiveSupport::Concern
+
         QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
         QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
 
+        module ClassMethods
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # [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+\]))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # [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+COLLATE\s+\w+)?
+                (?:\s+ASC|\s+DESC)?
+                (?:\s+NULLS\s+(?:FIRST|LAST))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= SQLServer::Utils.extract_identifiers(name).quoted
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= SQLServer::Utils.extract_identifiers(name).quoted
+          end
+        end
+
         def fetch_type_metadata(sql_type, sqlserver_options = {})
           cast_type = lookup_cast_type(sql_type)
 
@@ -33,14 +77,6 @@ module ActiveRecord
           SQLServer::Utils.quote_string_single_national(s)
         end
 
-        def quote_column_name(name)
-          QUOTED_COLUMN_NAMES[name] ||= SQLServer::Utils.extract_identifiers(name).quoted
-        end
-
-        def quote_table_name(name)
-          QUOTED_TABLE_NAMES[name] ||= SQLServer::Utils.extract_identifiers(name).quoted
-        end
-
         def quote_default_expression(value, column)
           cast_type = lookup_cast_type(column.sql_type)
           if cast_type.type == :uuid && value.is_a?(String) && value.include?('()')
@@ -76,44 +112,6 @@ module ActiveRecord
           end
         end
 
-        def column_name_matcher
-          COLUMN_NAME
-        end
-
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
-        end
-
-        COLUMN_NAME = /
-          \A
-          (
-            (?:
-              # [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+\]))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        COLUMN_NAME_WITH_ORDER = /
-          \A
-          (
-            (?:
-              # [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+COLLATE\s+\w+)?
-            (?:\s+ASC|\s+DESC)?
-            (?:\s+NULLS\s+(?:FIRST|LAST))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
         def quote(value)
           case value
           when Type::Binary::Data

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

@@ -16,6 +16,8 @@ module ActiveRecord
           internal_execute("ROLLBACK TRANSACTION #{name}", "TRANSACTION")
         end
 
+        # SQL Server does require save-points to be explicitly released.
+        # See https://stackoverflow.com/questions/3101312/sql-server-2008-no-release-savepoint-for-current-transaction
         def release_savepoint(_name)
         end
       end

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

@@ -132,7 +132,7 @@ module ActiveRecord
           schema_cache.clear_data_source_cache!(table_name.to_s)
           schema_cache.clear_data_source_cache!(new_name.to_s)
           execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
-          rename_table_indexes(table_name, new_name)
+          rename_table_indexes(table_name, new_name, **options)
         end
 
         def remove_column(table_name, column_name, type = nil, **options)
@@ -347,16 +347,12 @@ module ActiveRecord
 
         def columns_for_distinct(columns, orders)
           order_columns = orders.reject(&:blank?).map { |s|
-                            s = visitor.compile(s) unless s.is_a?(String)
+                            s = s.to_sql unless s.is_a?(String)
                             s.gsub(/\s+(?:ASC|DESC)\b/i, "")
                              .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
-                            }
-                            .reject(&:blank?)
-                            .reject { |s| columns.include?(s) }
+                          }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
-          order_columns_aliased = order_columns.map.with_index { |column, i| "#{column} AS alias_#{i}" }
-
-          (order_columns_aliased << super).join(", ")
+          (order_columns << super).join(", ")
         end
 
         def update_table_definition(table_name, base)
@@ -685,7 +681,6 @@ 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]

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -29,12 +29,13 @@ require "active_record/connection_adapters/sqlserver/showplan"
 require "active_record/connection_adapters/sqlserver/table_definition"
 require "active_record/connection_adapters/sqlserver/quoting"
 require "active_record/connection_adapters/sqlserver/utils"
-require "active_record/sqlserver_base"
 require "active_record/connection_adapters/sqlserver_column"
 require "active_record/tasks/sqlserver_database_tasks"
 
 module ActiveRecord
   module ConnectionAdapters
+    register "sqlserver", "ActiveRecord::ConnectionAdapters::SQLServerAdapter", "active_record/connection_adapters/sqlserver_adapter"
+
     class SQLServerAdapter < AbstractAdapter
       include SQLServer::Version,
               SQLServer::Quoting,
@@ -324,10 +325,6 @@ module ActiveRecord
         self.class::VERSION
       end
 
-      def inspect
-        "#<#{self.class} version: #{version}, azure: #{sqlserver_azure?.inspect}>"
-      end
-
       def combine_bind_parameters(from_clause: [], join_clause: [], where_clause: [], having_clause: [], limit: nil, offset: nil)
         result = from_clause + join_clause + where_clause + having_clause
         result << offset if offset

data/lib/active_record/tasks/sqlserver_database_tasks.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     class SQLServerDatabaseTasks
       DEFAULT_COLLATION = "SQL_Latin1_General_CP1_CI_AS"
 
-      delegate :connection, :establish_connection, to: ActiveRecord::Base
+      delegate :with_connection, :establish_connection, to: ActiveRecord::Base
 
       def self.using_database_configurations?
         true
@@ -23,8 +23,10 @@ module ActiveRecord
 
       def create(master_established = false)
         establish_master_connection unless master_established
-        connection.create_database configuration.database, configuration_hash.merge(collation: default_collation)
-        establish_connection configuration
+        with_connection do |connection|
+          connection.create_database(configuration.database, configuration_hash.merge(collation: default_collation))
+        end
+        establish_connection(configuration)
       rescue ActiveRecord::StatementInvalid => e
         if /database .* already exists/i === e.message
           raise DatabaseAlreadyExists
@@ -35,15 +37,15 @@ module ActiveRecord
 
       def drop
         establish_master_connection
-        connection.drop_database configuration.database
+        with_connection { |connection| connection.drop_database(configuration.database) }
       end
 
       def charset
-        connection.charset
+        with_connection { |connection| connection.charset }
       end
 
       def collation
-        connection.collation
+        with_connection { |connection| connection.collation }
       end
 
       def purge
@@ -56,34 +58,38 @@ module ActiveRecord
         ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
       end
 
-      def structure_dump(filename, extra_flags)
-        server_arg = "-S #{Shellwords.escape(configuration_hash[:host])}"
-        server_arg += ":#{Shellwords.escape(configuration_hash[:port])}" if configuration_hash[:port]
-        command = [
-          "defncopy-ttds",
-          server_arg,
-          "-D #{Shellwords.escape(configuration_hash[:database])}",
-          "-U #{Shellwords.escape(configuration_hash[:username])}",
-          "-P #{Shellwords.escape(configuration_hash[:password])}",
-          "-o #{Shellwords.escape(filename)}",
-        ]
-        table_args = connection.tables.map { |t| Shellwords.escape(t) }
-        command.concat(table_args)
-        view_args = connection.views.map { |v| Shellwords.escape(v) }
-        command.concat(view_args)
-        raise "Error dumping database" unless Kernel.system(command.join(" "))
-
-        dump = File.read(filename)
-        dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
-        dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
-        dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
-        dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
-        dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
-        File.open(filename, "w") { |file| file.puts dump }
+      def structure_dump(filename, _extra_flags)
+        with_connection do |connection|
+          server_arg = "-S #{Shellwords.escape(configuration_hash[:host])}"
+          server_arg += ":#{Shellwords.escape(configuration_hash[:port])}" if configuration_hash[:port]
+          command = [
+            "defncopy-ttds",
+            server_arg,
+            "-D #{Shellwords.escape(configuration_hash[:database])}",
+            "-U #{Shellwords.escape(configuration_hash[:username])}",
+            "-P #{Shellwords.escape(configuration_hash[:password])}",
+            "-o #{Shellwords.escape(filename)}",
+          ]
+          table_args = connection.tables.map { |t| Shellwords.escape(t) }
+          command.concat(table_args)
+          view_args = connection.views.map { |v| Shellwords.escape(v) }
+          command.concat(view_args)
+          raise "Error dumping database" unless Kernel.system(command.join(" "))
+
+          dump = File.read(filename)
+          dump.gsub!(/^USE .*$\nGO\n/, "")                      # Strip db USE statements
+          dump.gsub!(/^GO\n/, "")                               # Strip db GO statements
+          dump.gsub!(/nvarchar\(8000\)/, "nvarchar(4000)")      # Fix nvarchar(8000) column defs
+          dump.gsub!(/nvarchar\(-1\)/, "nvarchar(max)")         # Fix nvarchar(-1) column defs
+          dump.gsub!(/text\(\d+\)/, "text")                     # Fix text(16) column defs
+          File.open(filename, "w") { |file| file.puts dump }
+        end
       end
 
-      def structure_load(filename, extra_flags)
-        connection.execute File.read(filename)
+      def structure_load(filename, _extra_flags)
+        with_connection do |connection|
+          connection.execute File.read(filename)
+        end
       end
 
       private

data/lib/arel/visitors/sqlserver.rb

@@ -52,6 +52,8 @@ module Arel
       end
 
       def delete_statement_using_join(o, collector)
+        collector.retryable = false
+
         collector << "DELETE "
         visit o.relation.left, collector
         collector << " FROM "
@@ -60,6 +62,8 @@ module Arel
       end
 
       def update_statement_using_join(o, collector)
+        collector.retryable = false
+
         collector << "UPDATE "
         visit o.relation.left, collector
         collect_nodes_for o.values, collector, " SET "
@@ -161,10 +165,12 @@ module Arel
         # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
         table_name =
           begin
-            if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
-              remote_server_table_name(o)
-            else
-              quote_table_name(o.name)
+            o.class.engine.with_connection do |connection|
+              if connection.respond_to?(:sqlserver?) && connection.database_prefix_remote_server?
+                remote_server_table_name(o)
+              else
+                quote_table_name(o.name)
+              end
             end
           rescue Exception
             quote_table_name(o.name)
@@ -233,6 +239,11 @@ module Arel
         collector
       end
 
+      def visit_Arel_Nodes_WithRecursive(o, collector)
+        collector << "WITH "
+        collect_ctes(o.children, collector)
+      end
+
       # SQLServer ToSql/Visitor (Additions)
 
       def visit_Arel_Nodes_SelectStatement_SQLServer_Lock(collector, options = {})
@@ -347,14 +358,16 @@ module Arel
       end
 
       def remote_server_table_name(o)
-        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
-          "#{o.class.engine.connection.database_prefix}#{o.name}"
-        ).quoted
+        o.class.engine.with_connection do |connection|
+          ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+            "#{connection.database_prefix}#{o.name}"
+          ).quoted
+        end
       end
 
-      # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer
+      # Need to remove ordering from sub-queries unless TOP/OFFSET also used. Otherwise, SQLServer
       # returns error "The ORDER BY clause is invalid in views, inline functions, derived tables,
-      # subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
+      # sub-queries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."
       def remove_invalid_ordering_from_select_statement(node)
         return unless Arel::Nodes::SelectStatement === node
 

data/test/cases/active_schema_test_sqlserver.rb

@@ -16,38 +16,38 @@ class ActiveSchemaTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'default index' do
-      assert_sql('CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+      assert_queries_match('CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
         connection.add_index :schema_test_table, "foo"
       end
     end
 
     it 'unique index' do
-      assert_sql('CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+      assert_queries_match('CREATE UNIQUE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
         connection.add_index :schema_test_table, "foo", unique: true
       end
     end
 
     it 'where condition on index' do
-      assert_sql("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo]) WHERE state = 'active'") do
+      assert_queries_match("CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo]) WHERE state = 'active'") do
         connection.add_index :schema_test_table, "foo", where: "state = 'active'"
       end
     end
 
     it 'if index does not exist' do
-      assert_sql("IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = 'index_schema_test_table_on_foo') " \
+      assert_queries_match("IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = 'index_schema_test_table_on_foo') " \
                  "CREATE INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])") do
         connection.add_index :schema_test_table, "foo", if_not_exists: true
       end
     end
 
     it 'clustered index' do
-      assert_sql('CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+      assert_queries_match('CREATE CLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
         connection.add_index :schema_test_table, "foo", type: :clustered
       end
     end
 
     it 'nonclustered index' do
-      assert_sql('CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
+      assert_queries_match('CREATE NONCLUSTERED INDEX [index_schema_test_table_on_foo] ON [schema_test_table] ([foo])') do
         connection.add_index :schema_test_table, "foo", type: :nonclustered
       end
     end

data/test/cases/adapter_test_sqlserver.rb

@@ -18,8 +18,6 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   it "has basic and non-sensitive information in the adapters inspect method" do
     string = connection.inspect
     _(string).must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
-    _(string).must_match %r{version\: \d.\d}
-    _(string).must_match %r{azure: (true|false)}
     _(string).wont_match %r{host}
     _(string).wont_match %r{password}
     _(string).wont_match %r{username}
@@ -31,7 +29,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   end
 
   it "raises invalid statement error for bad SQL" do
-    assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.update("UPDATE XXX") }
+    assert_raise(ActiveRecord::StatementInvalid) { Topic.lease_connection.update("UPDATE XXX") }
   end
 
   it "is has our adapter_name" do
@@ -61,8 +59,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   end
 
   it "test table existence across database schemas" do
-    arunit_connection = Topic.connection
-    arunit2_connection = College.connection
+    arunit_connection = Topic.lease_connection
+    arunit2_connection = College.lease_connection
 
     arunit_database = arunit_connection.pool.db_config.database
     arunit2_database = arunit2_connection.pool.db_config.database
@@ -102,8 +100,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     assert_raise ActiveRecord::NoDatabaseError do
       db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
       configuration = db_config.configuration_hash.merge(database: "nonexistent_activerecord_unittest")
-
-      connection = ActiveRecord::Base.sqlserver_connection configuration
+      connection = ActiveRecord::ConnectionAdapters::SQLServerAdapter.new(configuration)
       connection.exec_query("SELECT 1")
     end
   end
@@ -285,23 +282,25 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it "NOT ALLOW by default the deletion of a referenced parent" do
-      SSTestHasPk.connection.disable_referential_integrity {}
+      SSTestHasPk.lease_connection.disable_referential_integrity {}
       assert_raise(ActiveRecord::StatementInvalid) { @parent.destroy }
     end
 
     it "ALLOW deletion of referenced parent using #disable_referential_integrity block" do
-      SSTestHasPk.connection.disable_referential_integrity { @parent.destroy }
+      assert_difference("SSTestHasPk.count", -1) do
+        SSTestHasPk.lease_connection.disable_referential_integrity { @parent.destroy }
+      end
     end
 
     it "again NOT ALLOW deletion of referenced parent after #disable_referential_integrity block" do
       assert_raise(ActiveRecord::StatementInvalid) do
-        SSTestHasPk.connection.disable_referential_integrity {}
+        SSTestHasPk.lease_connection.disable_referential_integrity {}
         @parent.destroy
       end
     end
 
     it "not disable referential integrity for the same table twice" do
-      tables = SSTestHasPk.connection.tables_with_referential_integrity
+      tables = SSTestHasPk.lease_connection.tables_with_referential_integrity
       assert_equal tables.size, tables.uniq.size
     end
   end
@@ -396,7 +395,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
     it "allows connection#view_information to work across databases when using qualified object names" do
       # College is defined in activerecord_unittest2 database.
-      view_info = College.connection.send(:view_information, "[activerecord_unittest].[dbo].[sst_customers_view]")
+      view_info = College.lease_connection.send(:view_information, "[activerecord_unittest].[dbo].[sst_customers_view]")
       assert_equal("sst_customers_view", view_info["TABLE_NAME"])
       assert_match(/CREATE VIEW sst_customers_view/, view_info["VIEW_DEFINITION"])
     end
@@ -407,8 +406,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it "allow the connection#view_table_name method to return true table_name for the view for other connections" do
-      assert_equal "customers", College.connection.send(:view_table_name, "[activerecord_unittest].[dbo].[sst_customers_view]")
-      assert_equal "topics", College.connection.send(:view_table_name, "topics"), "No view here, the same table name should come back."
+      assert_equal "customers", College.lease_connection.send(:view_table_name, "[activerecord_unittest].[dbo].[sst_customers_view]")
+      assert_equal "topics", College.lease_connection.send(:view_table_name, "topics"), "No view here, the same table name should come back."
     end
     # With same column names
 
@@ -434,7 +433,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it "respond true to data_source_exists?" do
-      assert SSTestCustomersView.connection.data_source_exists?(SSTestCustomersView.table_name)
+      assert SSTestCustomersView.lease_connection.data_source_exists?(SSTestCustomersView.table_name)
     end
 
     # With aliased column names
@@ -462,7 +461,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it "respond true to data_source_exists?" do
-      assert SSTestStringDefaultsView.connection.data_source_exists?(SSTestStringDefaultsView.table_name)
+      assert SSTestStringDefaultsView.lease_connection.data_source_exists?(SSTestStringDefaultsView.table_name)
     end
 
     # That have more than 4000 chars for their defintion
@@ -508,7 +507,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
   describe "block writes to a database" do
     def setup
-      @conn = ActiveRecord::Base.connection
+      @conn = ActiveRecord::Base.lease_connection
     end
 
     def test_errors_when_an_insert_query_is_called_while_preventing_writes
@@ -557,7 +556,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
     it 'records can be inserted using SQL' do
       assert_difference("Alien.count", 2) do
-        Alien.connection.exec_insert("insert into [test].[aliens] (id, name) VALUES(1, 'Trisolarans'), (2, 'Xenomorph')")
+        Alien.lease_connection.exec_insert("insert into [test].[aliens] (id, name) VALUES(1, 'Trisolarans'), (2, 'Xenomorph')")
       end
     end
   end
@@ -581,13 +580,4 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       end
     end
   end
-
-  describe "distinct select query" do
-    it "generated SQL does not contain unnecessary alias projection" do
-      sqls = capture_sql do
-        Post.includes(:comments).joins(:comments).first
-      end
-      assert_no_match(/AS alias_0/, sqls.first)
-    end
-  end
 end