activerecord-sqlserver-adapter 7.2.7 → 8.0.0

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?("(-)")
@@ -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)
@@ -484,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
@@ -502,88 +497,103 @@ 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
-          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?
+            col
           end
+
+          columns
         end
 
-        def column_definitions_sql(database, identifier)
-          database = "TEMPDB" if identifier.temporary_table?
-          schema_name = "schema_name()"
+        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
+
+          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
 
-          if prepared_statements
-            object_name = "@0"
-            schema_name = "@1" if identifier.schema.present?
+        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
-            object_name = quote(identifier.object)
-            schema_name = quote(identifier.schema) if identifier.schema.present?
+            ci['type']
           end
+        end
 
-          object_id_arg = identifier.schema.present? ? "CONCAT('.',#{schema_name},'.',#{object_name})" : "CONCAT('..',#{object_name})"
-          object_id_arg = "CONCAT('#{database}',#{object_id_arg})"
+        def column_definitions_sql(database, identifier)
+          object_name = prepared_statements ? "@0" : quote(identifier.object)
+          schema_name = if identifier.schema.blank?
+                          "schema_name()"
+                        else
+                          prepared_statements ? "@1" : quote(identifier.schema)
+                        end
 
           %{
             SELECT
@@ -638,7 +648,7 @@ module ActiveRecord
               AND k.unique_index_id = ic.index_id
               AND c.column_id = ic.column_id
             WHERE
-              o.Object_ID = Object_ID(#{object_id_arg})
+              o.name = #{object_name}
               AND s.name = #{schema_name}
             ORDER BY
               c.column_id
@@ -660,7 +670,7 @@ module ActiveRecord
         end
 
         def remove_default_constraint(table_name, column_name)
-          # If there are foreign keys in this table, we could still get back a 2D array, so flatten just in case.
+          # If their are foreign keys in this table, we could still get back a 2D array, so flatten just in case.
           execute_procedure(:sp_helpconstraint, table_name, "nomsg").flatten.select do |row|
             row["constraint_type"] == "DEFAULT on column #{column_name}"
           end.each do |row|
@@ -697,7 +707,7 @@ module ActiveRecord
           elsif s.match?(/^\s*UPDATE\s+.*/i)
             s.match(/UPDATE\s+([^\(\s]+)\s*/i)[1]
           else
-            s.match(/FROM[\s|\(]+((\[[^\(\]]+\])|[^\(\s]+)\s*/i)[1]
+            s.match(/FROM\s+((\[[^\(\]]+\])|[^\(\s]+)\s*/i)[1]
           end.strip
         end
 
@@ -713,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
 
@@ -740,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/utils.rb

@@ -81,10 +81,6 @@ module ActiveRecord
             parts.hash
           end
 
-          def temporary_table?
-            object.start_with?("#")
-          end
-
           protected
 
           def parse_raw_name

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/test/cases/adapter_test_sqlserver.rb

@@ -7,17 +7,10 @@ require "models/post"
 require "models/subscriber"
 require "models/minimalistic"
 require "models/college"
-require "models/dog"
-require "models/other_dog"
 
 class AdapterTestSQLServer < ActiveRecord::TestCase
   fixtures :tasks
 
-  let(:arunit_connection)  { Topic.lease_connection }
-  let(:arunit2_connection) { College.lease_connection }
-  let(:arunit_database)    { arunit_connection.pool.db_config.database }
-  let(:arunit2_database)   { arunit2_connection.pool.db_config.database }
-
   let(:basic_insert_sql) { "INSERT INTO [funny_jokes] ([name]) VALUES('Knock knock')" }
   let(:basic_update_sql) { "UPDATE [customers] SET [address_street] = NULL WHERE [id] = 2" }
   let(:basic_select_sql) { "SELECT * FROM [customers] WHERE ([customers].[id] = 1)" }
@@ -57,7 +50,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert Topic.table_exists?, "Topics table name of 'dbo.topics' should return true for exists."
 
       # Test when database and owner included in table name.
-      Topic.table_name = "#{arunit_database}.dbo.topics"
+      db_config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
+      Topic.table_name = "#{db_config.database}.dbo.topics"
       assert Topic.table_exists?, "Topics table name of '[DATABASE].dbo.topics' should return true for exists."
     ensure
       Topic.table_name = "topics"
@@ -65,6 +59,12 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   end
 
   it "test table existence across database schemas" do
+    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
+
     # Assert that connections use different default databases schemas.
     assert_not_equal arunit_database, arunit2_database
 
@@ -200,9 +200,6 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @identity_insert_sql_non_dbo_sp = "EXEC sp_executesql N'INSERT INTO [test].[aliens] ([id],[name]) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Mork'"
       @identity_insert_sql_non_dbo_unquoted_sp = "EXEC sp_executesql N'INSERT INTO test.aliens (id, name) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Mork'"
       @identity_insert_sql_non_dbo_unordered_sp = "EXEC sp_executesql N'INSERT INTO [test].[aliens] ([name],[id]) VALUES (@0, @1)', N'@0 nvarchar(255), @1  int', @0 = N'Mork', @1 = 420"
-
-      @non_identity_insert_sql_cross_database = "INSERT INTO #{arunit2_database}.dbo.dogs SELECT * FROM #{arunit_database}.dbo.dogs"
-      @identity_insert_sql_cross_database = "INSERT INTO #{arunit2_database}.dbo.dogs(id) SELECT id FROM #{arunit_database}.dbo.dogs"
     end
 
     it "return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column" do
@@ -219,32 +216,20 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_sp)
       assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_unquoted_sp)
       assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_unordered_sp)
-
-      assert_equal "[#{arunit2_database}].[dbo].[dogs]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_cross_database)
     end
 
     it "return false to #query_requires_identity_insert? for normal SQL" do
-      [basic_insert_sql, basic_update_sql, basic_select_sql, @non_identity_insert_sql_cross_database].each do |sql|
+      [basic_insert_sql, basic_update_sql, basic_select_sql].each do |sql|
         assert !connection.send(:query_requires_identity_insert?, sql), "SQL was #{sql}"
       end
     end
 
-    it "find identity column" do
+    it "find identity column using #identity_columns" do
       task_id_column = Task.columns_hash["id"]
       assert_equal task_id_column.name, connection.send(:identity_columns, Task.table_name).first.name
       assert_equal task_id_column.sql_type, connection.send(:identity_columns, Task.table_name).first.sql_type
     end
 
-    it "find identity column cross database" do
-      id_column = Dog.columns_hash["id"]
-      assert_equal id_column.name, arunit2_connection.send(:identity_columns, Dog.table_name).first.name
-      assert_equal id_column.sql_type, arunit2_connection.send(:identity_columns, Dog.table_name).first.sql_type
-
-      id_column = OtherDog.columns_hash["id"]
-      assert_equal id_column.name, arunit_connection.send(:identity_columns, OtherDog.table_name).first.name
-      assert_equal id_column.sql_type, arunit_connection.send(:identity_columns, OtherDog.table_name).first.sql_type
-    end
-
     it "return an empty array when calling #identity_columns for a table_name with no identity" do
       _(connection.send(:identity_columns, Subscriber.table_name)).must_equal []
     end
@@ -479,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
@@ -557,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
@@ -596,6 +581,28 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     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
@@ -609,13 +616,4 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert_equal Task.where("starting < ?", DateTime.current).count, 1
     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