activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/test/cases/schema_test_sqlserver.rb

@@ -21,6 +21,7 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
 
     it "have only one identity column" do
       columns = connection.columns("test.sst_schema_identity")
+
       assert_equal 2, columns.size
       assert_equal 1, columns.select { |c| c.is_identity? }.size
     end
@@ -29,6 +30,7 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
       test_columns = connection.columns("test.sst_schema_columns")
       dbo_columns = connection.columns("dbo.sst_schema_columns")
       columns = connection.columns("sst_schema_columns") # This returns table from dbo schema
+
       assert_equal 7, test_columns.size
       assert_equal 2, dbo_columns.size
       assert_equal 2, columns.size
@@ -37,12 +39,73 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
       assert_equal 1, columns.select { |c| c.is_identity? }.size
     end
 
-    it "return correct varchar and nvarchar column limit length when table is in non dbo schema" do
+    it "return correct varchar and nvarchar column limit length when table is in non-dbo schema" do
       columns = connection.columns("test.sst_schema_columns")
+
       assert_equal 255, columns.find { |c| c.name == "name" }.limit
       assert_equal 1000, columns.find { |c| c.name == "description" }.limit
       assert_equal 255, columns.find { |c| c.name == "n_name" }.limit
       assert_equal 1000, columns.find { |c| c.name == "n_description" }.limit
     end
   end
+
+  describe "parsing table name from raw SQL" do
+    describe 'SELECT statements' do
+      it do
+        assert_equal "[sst_schema_columns]", connection.send(:get_raw_table_name, "SELECT [sst_schema_columns].[id] FROM [sst_schema_columns]")
+      end
+
+      it do
+        assert_equal "sst_schema_columns", connection.send(:get_raw_table_name, "SELECT [sst_schema_columns].[id] FROM sst_schema_columns")
+      end
+
+      it do
+        assert_equal "[WITH - SPACES]", connection.send(:get_raw_table_name, "SELECT id FROM [WITH - SPACES]")
+      end
+
+      it do
+        assert_equal "[WITH - SPACES$DOLLAR]", connection.send(:get_raw_table_name, "SELECT id FROM [WITH - SPACES$DOLLAR]")
+      end
+
+      it do
+        assert_nil connection.send(:get_raw_table_name, nil)
+      end
+    end
+
+    describe 'INSERT statements' do
+      it do
+        assert_equal "[dashboards]", connection.send(:get_raw_table_name, "INSERT INTO [dashboards] DEFAULT VALUES; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident")
+      end
+
+      it do
+        assert_equal "lock_without_defaults", connection.send(:get_raw_table_name, "INSERT INTO lock_without_defaults(title) VALUES('title1')")
+      end
+
+      it do
+        assert_equal "json_data_type", connection.send(:get_raw_table_name, "insert into json_data_type (payload) VALUES ('null')")
+      end
+
+      it do
+        assert_equal "[auto_increments]", connection.send(:get_raw_table_name, "INSERT INTO [auto_increments] OUTPUT INSERTED.[id] DEFAULT VALUES")
+      end
+
+      it do
+        assert_equal "[WITH - SPACES]", connection.send(:get_raw_table_name, "EXEC sp_executesql N'INSERT INTO [WITH - SPACES] ([external_id]) OUTPUT INSERTED.[id] VALUES (@0)', N'@0 bigint', @0 = 10")
+      end
+
+      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
+
+    describe 'CREATE VIEW statements' do
+      it do
+        assert_equal "test_table_as", connection.send(:get_raw_table_name, "CREATE VIEW test_views ( test_table_a_id, test_table_b_id ) AS SELECT test_table_as.id as test_table_a_id, test_table_bs.id as test_table_b_id FROM (test_table_as with(nolock) LEFT JOIN test_table_bs with(nolock) ON (test_table_as.id = test_table_bs.test_table_a_id))")
+      end
+    end
+  end
 end

data/test/cases/showplan_test_sqlserver.rb

@@ -8,32 +8,32 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
 
   describe "Unprepare previously prepared SQL" do
     it "from simple statement" do
-      plan = Car.where(id: 1).explain
+      plan = Car.where(id: 1).explain.inspect
       _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id] = 1"
       _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
     end
 
     it "from multiline statement" do
-      plan = Car.where("\n id = 1 \n").explain
+      plan = Car.where("\n id = 1 \n").explain.inspect
       _(plan).must_include "SELECT [cars].* FROM [cars] WHERE (\n id = 1 \n)"
       _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
     end
 
     it "from prepared statement" do
-      plan = Car.where(name: ",").limit(1).explain
+      plan = Car.where(name: ",").limit(1).explain.inspect
       _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[name]"
       _(plan).must_include "TOP EXPRESSION", "make sure we do not showplan the sp_executesql"
       _(plan).must_include "Clustered Index Scan", "make sure we do not showplan the sp_executesql"
     end
 
     it "from array condition using index" do
-      plan = Car.where(id: [1, 2]).explain
+      plan = Car.where(id: [1, 2]).explain.inspect
       _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id] IN (1, 2)"
       _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
     end
 
     it "from array condition" do
-      plan = Car.where(name: ["honda", "zyke"]).explain
+      plan = Car.where(name: ["honda", "zyke"]).explain.inspect
       _(plan).must_include " SELECT [cars].* FROM [cars] WHERE [cars].[name] IN (N'honda', N'zyke')"
       _(plan).must_include "Clustered Index Scan", "make sure we do not showplan the sp_executesql"
     end
@@ -42,7 +42,7 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
   describe "With SHOWPLAN_TEXT option" do
     it "use simple table printer" do
       with_showplan_option("SHOWPLAN_TEXT") do
-        plan = Car.where(id: 1).explain
+        plan = Car.where(id: 1).explain.inspect
         _(plan).must_include "SELECT [cars].* FROM [cars] WHERE [cars].[id]"
         _(plan).must_include "Clustered Index Seek", "make sure we do not showplan the sp_executesql"
       end
@@ -52,7 +52,7 @@ class ShowplanTestSQLServer < ActiveRecord::TestCase
   describe "With SHOWPLAN_XML option" do
     it "show formatted xml" do
       with_showplan_option("SHOWPLAN_XML") do
-        plan = Car.where(id: 1).explain
+        plan = Car.where(id: 1).explain.inspect
         _(plan).must_include "ShowPlanXML"
       end
     end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -6,8 +6,12 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
   after { SSTestEdgeSchema.delete_all }
 
   it "handle dollar symbols" do
-    SSTestDollarTableName.create!
-    SSTestDollarTableName.limit(20).offset(1)
+    assert_difference("SSTestDollarTableName.count", 1) do
+      SSTestDollarTableName.create!
+    end
+    assert_nothing_raised do
+      SSTestDollarTableName.limit(20).offset(1)
+    end
   end
 
   it "models can use tinyint pk tables" do
@@ -93,7 +97,7 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   it "use primary key for row table order in pagination sql" do
     sql = /ORDER BY \[sst_natural_pk_data\]\.\[legacy_id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY/
-    assert_sql(sql) { SSTestNaturalPkData.limit(5).offset(5).load }
+    assert_queries_match(sql) { SSTestNaturalPkData.limit(5).offset(5).load }
   end
 
   # Special quoted column
@@ -112,16 +116,16 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
       end
     end
     # Using ActiveRecord's quoted_id feature for objects.
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: value.new).first }
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: value.new).first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: value.new).first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: value.new).first }
     # Using our custom char type data.
     type = ActiveRecord::Type::SQLServer::Char
     data = ActiveRecord::Type::SQLServer::Data
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: data.new("T", type.new)).first }
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: data.new("T", type.new)).first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: data.new("T", type.new)).first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: data.new("T", type.new)).first }
     # Taking care of everything.
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: "T").first }
-    assert_sql(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: "T").first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(char_col: "T").first }
+    assert_queries_match(/@0 = 'T'/) { SSTestDatatypeMigration.where(varchar_col: "T").first }
   end
 
   it "can update and hence properly quoted non-national char/varchar columns" do
@@ -159,15 +163,15 @@ class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
 
   it "returns a new id via connection newid_function" do
     acceptable_uuid = ActiveRecord::ConnectionAdapters::SQLServer::Type::Uuid::ACCEPTABLE_UUID
-    db_uuid = ActiveRecord::Base.connection.newid_function
+    db_uuid = ActiveRecord::Base.lease_connection.newid_function
     _(db_uuid).must_match(acceptable_uuid)
   end
 
   # with similar table definition in two schemas
 
   it "returns the correct primary columns" do
-    connection = ActiveRecord::Base.connection
-    assert_equal "field_1", connection.columns("test.sst_schema_test_mulitple_schema").detect(&:is_primary?).name
-    assert_equal "field_2", connection.columns("test2.sst_schema_test_mulitple_schema").detect(&:is_primary?).name
+    connection = ActiveRecord::Base.lease_connection
+    assert_equal "field_1", connection.columns("test.sst_schema_test_multiple_schema").detect(&:is_primary?).name
+    assert_equal "field_2", connection.columns("test2.sst_schema_test_multiple_schema").detect(&:is_primary?).name
   end
 end

data/test/cases/transaction_test_sqlserver.rb

@@ -42,6 +42,9 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
     after_level = connection.user_options_isolation_level
     _(in_level).must_match %r{serializable}i
     _(after_level).must_match %r{read committed}i
+  ensure
+    # Reset all connections. Otherwise, the next test may fail with error 'DBPROCESS is dead or not enabled'. Not sure why.
+    ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
   end
 
   it "can use an isolation level and reverts back to starting isolation level under exceptions" do
@@ -50,20 +53,16 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
       Ship.transaction(isolation: :serializable) { Ship.create! }
     }).must_raise(ActiveRecord::RecordInvalid)
     _(connection.user_options_isolation_level).must_match %r{read committed}i
+  ensure
+    # Reset all connections. Otherwise, the next test may fail with error 'DBPROCESS is dead or not enabled'. Not sure why.
+    ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
   end
 
   describe "when READ_COMMITTED_SNAPSHOT is set" do
-    before do
+    it "should use READ COMMITTED as an isolation level" do
       connection.execute "ALTER DATABASE [#{connection.current_database}] SET ALLOW_SNAPSHOT_ISOLATION ON"
       connection.execute "ALTER DATABASE [#{connection.current_database}] SET READ_COMMITTED_SNAPSHOT ON WITH ROLLBACK IMMEDIATE"
-    end
-
-    after do
-      connection.execute "ALTER DATABASE [#{connection.current_database}] SET ALLOW_SNAPSHOT_ISOLATION OFF"
-      connection.execute "ALTER DATABASE [#{connection.current_database}] SET READ_COMMITTED_SNAPSHOT OFF WITH ROLLBACK IMMEDIATE"
-    end
 
-    it "should use READ COMMITTED as an isolation level" do
       _(connection.user_options_isolation_level).must_match "read committed snapshot"
 
       Ship.transaction(isolation: :serializable) do
@@ -74,6 +73,12 @@ class TransactionTestSQLServer < ActiveRecord::TestCase
       # "READ COMMITTED", and that no exception was raised (it's reported back
       # by SQL Server as "read committed snapshot").
       _(connection.user_options_isolation_level).must_match "read committed snapshot"
+    ensure
+      connection.execute "ALTER DATABASE [#{connection.current_database}] SET ALLOW_SNAPSHOT_ISOLATION OFF"
+      connection.execute "ALTER DATABASE [#{connection.current_database}] SET READ_COMMITTED_SNAPSHOT OFF WITH ROLLBACK IMMEDIATE"
+
+      # Reset all connections. Otherwise, the next test may fail with error 'DBPROCESS is dead or not enabled'. Not sure why.
+      ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
     end
   end
 

data/test/cases/trigger_test_sqlserver.rb

@@ -28,4 +28,24 @@ class SQLServerTriggerTest < ActiveRecord::TestCase
     _(obj.id).must_be :present?
     _(obj.id.to_s).must_equal SSTestTriggerHistory.first.id_source
   end
+
+  it "can insert into a table with composite pk with output inserted - with a true setting for table name" do
+    exclude_output_inserted_table_names["sst_table_with_composite_pk_trigger"] = true
+    assert SSTestTriggerHistory.all.empty?
+    obj = SSTestTriggerCompositePk.create! pk_col_one: 123, pk_col_two: 42, event_name: "test trigger"
+    _(obj.event_name).must_equal "test trigger"
+    _(obj.pk_col_one).must_equal 123
+    _(obj.pk_col_two).must_equal 42
+    _(obj.pk_col_one.to_s).must_equal SSTestTriggerHistory.first.id_source
+  end
+
+  it "can insert into a table with composite pk with different data type with output inserted - with a hash setting for table name" do
+    exclude_output_inserted_table_names["sst_table_with_composite_pk_trigger_with_different_data_type"] = { pk_col_one: "uniqueidentifier", pk_col_two: "int" }
+    assert SSTestTriggerHistory.all.empty?
+    obj = SSTestTriggerCompositePkWithDefferentDataType.create! pk_col_two: 123, event_name: "test trigger"
+    _(obj.event_name).must_equal "test trigger"
+    _(obj.pk_col_one).must_be :present?
+    _(obj.pk_col_two).must_equal 123
+    _(obj.pk_col_one.to_s).must_equal SSTestTriggerHistory.first.id_source
+  end
 end

data/test/cases/utils_test_sqlserver.rb

@@ -77,7 +77,7 @@ class UtilsTestSQLServer < ActiveRecord::TestCase
       _(extract_identifiers(" ").object).must_be_nil
     end
 
-    it "has a #quoted that returns a fully quoted name with all identifiers as orginially passed in" do
+    it "has a #quoted that returns a fully quoted name with all identifiers as originally passed in" do
       _(extract_identifiers("object").quoted).must_equal "[object]"
       _(extract_identifiers("server.database..object").quoted).must_equal "[server].[database]..[object]"
       _(extract_identifiers("[server]...[object]").quoted).must_equal "[server]...[object]"
@@ -92,7 +92,7 @@ class UtilsTestSQLServer < ActiveRecord::TestCase
       _(extract_identifiers("[obj.name].[foo]").quoted).must_equal "[obj.name].[foo]"
     end
 
-    it "should indicate if a name is fully qualitified" do
+    it "should indicate if a name is fully qualified" do
       _(extract_identifiers("object").fully_qualified?).must_equal false
       _(extract_identifiers("schema.object").fully_qualified?).must_equal false
       _(extract_identifiers("database.schema.object").fully_qualified?).must_equal false

data/test/cases/uuid_test_sqlserver.rb

@@ -43,4 +43,12 @@ class SQLServerUuidTest < ActiveRecord::TestCase
     obj = with_use_output_inserted_disabled { SSTestUuid.create!(name: "😢") }
     _(obj.id).must_be :nil?
   end
+
+  it "can add column with proc as default" do
+    table_name = SSTestUuid.table_name
+    connection.add_column table_name, :thingy, :uuid, null: false, default: -> { "NEWSEQUENTIALID()" }
+    SSTestUuid.reset_column_information
+    column = SSTestUuid.columns_hash["thingy"]
+    _(column.default_function).must_equal "newsequentialid()"
+  end
 end

data/test/cases/view_test_sqlserver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class ViewTestSQLServer < ActiveRecord::TestCase
+  let(:connection) { ActiveRecord::Base.lease_connection }
+
+  describe 'view with default values' do
+    before do
+      connection.drop_table :view_casing_table rescue nil
+      connection.create_table :view_casing_table, force: true do |t|
+        t.boolean :Default_Falsey,      null: false, default: false
+        t.boolean :Default_Truthy,      null: false, default: true
+        t.string  :default_string_null, null: true,  default: nil
+        t.string  :default_string,      null: false, default: "abc"
+      end
+
+      connection.execute("DROP VIEW IF EXISTS view_casing_table_view;")
+      connection.execute <<-SQL
+        CREATE VIEW view_casing_table_view AS
+              SELECT id AS id,
+                     default_falsey      AS falsey,
+                     default_truthy      AS truthy,
+                     default_string_null AS s_null,
+                     default_string      AS s
+              FROM view_casing_table
+      SQL
+    end
+
+    it "default values are correct when column casing used in tables and views are different" do
+      klass = Class.new(ActiveRecord::Base) do
+        self.table_name = "view_casing_table_view"
+      end
+
+      obj = klass.new
+      assert_equal false, obj.falsey
+      assert_equal true, obj.truthy
+      assert_equal "abc", obj.s
+      assert_nil   obj.s_null
+      assert_equal 0, klass.count
+
+      obj.save!
+      assert_equal false, obj.falsey
+      assert_equal true, obj.truthy
+      assert_equal "abc", obj.s
+      assert_nil   obj.s_null
+      assert_equal 1, klass.count
+    end
+  end
+
+  describe 'identity insert' do
+    it "identity insert works with views" do
+      assert_difference("SSTestCustomersView.count", 1) do
+        SSTestCustomersView.create!(id: 5, name: "Bob")
+      end
+    end
+  end
+end

data/test/config.yml

@@ -1,7 +1,6 @@
 
 default_connection_info: &default_connection_info
   adapter: sqlserver
-  mode: <%= ENV['ARCONN'] || 'dblib' %>
   host: <%= ENV['ACTIVERECORD_UNITTEST_HOST'] || 'localhost' %>
   port: <%= ENV['ACTIVERECORD_UNITTEST_PORT'] %>
   database: activerecord_unittest
@@ -12,7 +11,7 @@ default_connection_info: &default_connection_info
 
 connections:
 
-  dblib:
+  sqlserver:
     arunit:
       <<: *default_connection_info
       appname: SQLServerAdptrUnit

data/test/migrations/transaction_table/1_table_will_never_be_created.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class TableWillNeverBeCreated < ActiveRecord::Migration
+class TableWillNeverBeCreated < ActiveRecord::Migration[5.2]
   def self.up
     create_table(:sqlserver_trans_table1) {}
     create_table(:sqlserver_trans_table2) { raise("HELL") }

data/test/models/sqlserver/alien.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Alien < ActiveRecord::Base
+  self.table_name = "test.aliens"
+end

data/test/models/sqlserver/table_with_spaces.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TableWithSpaces < ActiveRecord::Base
+  self.table_name = "A Table With Spaces"
+end

data/test/models/sqlserver/trigger.rb

@@ -7,3 +7,11 @@ end
 class SSTestTriggerUuid < ActiveRecord::Base
   self.table_name = "sst_table_with_uuid_trigger"
 end
+
+class SSTestTriggerCompositePk < ActiveRecord::Base
+  self.table_name = "sst_table_with_composite_pk_trigger"
+end
+
+class SSTestTriggerCompositePkWithDefferentDataType < ActiveRecord::Base
+  self.table_name = "sst_table_with_composite_pk_trigger_with_different_data_type"
+end

data/test/schema/sqlserver_specific_schema.rb

@@ -14,8 +14,9 @@ ActiveRecord::Schema.define do
     t.float     :float_col
     t.string    :string_col
     t.text      :text_col
-    t.datetime  :datetime_col
-    t.timestamp :timestamp_col
+    t.datetime  :datetime_nil_precision_col, precision: nil
+    t.datetime  :datetime_col  # Precision defaults to 6
+    t.timestamp :timestamp_col # Precision defaults to 6
     t.time      :time_col
     t.date      :date_col
     t.binary    :binary_col
@@ -32,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
@@ -150,6 +152,10 @@ ActiveRecord::Schema.define do
     SELECT GETUTCDATE() utcdate
   SQL
 
+  create_table 'A Table With Spaces', force: true do |t|
+    t.string :name
+  end
+
   # Constraints
 
   create_table(:sst_has_fks, force: true) do |t|
@@ -231,6 +237,40 @@ ActiveRecord::Schema.define do
     SELECT id AS id_source, event_name FROM INSERTED
   SQL
 
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_table_with_composite_pk_trigger') DROP TABLE sst_table_with_composite_pk_trigger"
+  execute <<-SQL
+    CREATE TABLE sst_table_with_composite_pk_trigger(
+      pk_col_one int NOT NULL,
+      pk_col_two int NOT NULL,
+      event_name nvarchar(255),
+      CONSTRAINT PK_sst_table_with_composite_pk_trigger PRIMARY KEY (pk_col_one, pk_col_two)
+    )
+  SQL
+  execute <<-SQL
+    CREATE TRIGGER sst_table_with_composite_pk_trigger_t ON sst_table_with_composite_pk_trigger
+    FOR INSERT
+    AS
+    INSERT INTO sst_table_with_trigger_history (id_source, event_name)
+    SELECT pk_col_one AS id_source, event_name FROM INSERTED
+  SQL
+
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_table_with_composite_pk_trigger_with_different_data_type') DROP TABLE sst_table_with_composite_pk_trigger_with_different_data_type"
+  execute <<-SQL
+    CREATE TABLE sst_table_with_composite_pk_trigger_with_different_data_type(
+      pk_col_one uniqueidentifier DEFAULT NEWID(),
+      pk_col_two int NOT NULL,
+      event_name nvarchar(255),
+      CONSTRAINT PK_sst_table_with_composite_pk_trigger_with_different_data_type PRIMARY KEY (pk_col_one, pk_col_two)
+    )
+  SQL
+  execute <<-SQL
+    CREATE TRIGGER sst_table_with_composite_pk_trigger_with_different_data_type_t ON sst_table_with_composite_pk_trigger_with_different_data_type
+    FOR INSERT
+    AS
+    INSERT INTO sst_table_with_trigger_history (id_source, event_name)
+    SELECT pk_col_one AS id_source, event_name FROM INSERTED
+  SQL
+
   # Another schema.
 
   create_table :sst_schema_columns, force: true do |t|
@@ -269,17 +309,17 @@ ActiveRecord::Schema.define do
     )
   NATURALPKTABLESQLINOTHERSCHEMA
 
-  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_mulitple_schema' and TABLE_SCHEMA = 'test') DROP TABLE test.sst_schema_test_mulitple_schema"
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_multiple_schema' and TABLE_SCHEMA = 'test') DROP TABLE test.sst_schema_test_multiple_schema"
   execute <<-SCHEMATESTMULTIPLESCHEMA
-    CREATE TABLE test.sst_schema_test_mulitple_schema(
+    CREATE TABLE test.sst_schema_test_multiple_schema(
       field_1 int NOT NULL PRIMARY KEY,
       field_2 int,
     )
   SCHEMATESTMULTIPLESCHEMA
   execute "IF NOT EXISTS(SELECT * FROM sys.schemas WHERE name = 'test2') EXEC sp_executesql N'CREATE SCHEMA test2'"
-  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_mulitple_schema' and TABLE_SCHEMA = 'test2') DROP TABLE test2.sst_schema_test_mulitple_schema"
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'sst_schema_test_multiple_schema' and TABLE_SCHEMA = 'test2') DROP TABLE test2.sst_schema_test_multiple_schema"
   execute <<-SCHEMATESTMULTIPLESCHEMA
-    CREATE TABLE test2.sst_schema_test_mulitple_schema(
+    CREATE TABLE test2.sst_schema_test_multiple_schema(
       field_1 int,
       field_2 int NOT NULL PRIMARY KEY,
     )
@@ -312,4 +352,12 @@ ActiveRecord::Schema.define do
       CONSTRAINT PK_sst_composite_with_identity PRIMARY KEY (pk_col_one, pk_col_two)
     );
   COMPOSITE_WITH_IDENTITY
+
+  execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'aliens' and TABLE_SCHEMA = 'test') DROP TABLE test.aliens"
+  execute <<-TABLE_IN_OTHER_SCHEMA_USED_BY_MODEL
+    CREATE TABLE test.aliens(
+      id int IDENTITY NOT NULL primary key,
+      name varchar(255)
+    )
+  TABLE_IN_OTHER_SCHEMA_USED_BY_MODEL
 end

data/test/support/coerceable_test_sqlserver.rb

@@ -13,7 +13,7 @@ module ARTest
       module ClassMethods
         def coerce_tests!(*methods)
           methods.each do |method|
-            self.coerced_tests.push(method)
+            coerced_tests.push(method)
             coerced_test_warning(method)
           end
         end
@@ -24,7 +24,7 @@ module ARTest
 
             undef_method(method)
           end
-          STDOUT.puts "🙉 🙈 🙊  Undefined all tests: #{self.name}"
+          STDOUT.puts "🙉 🙈 🙊  Undefined all tests: #{name}"
         end
 
         private
@@ -43,9 +43,9 @@ module ARTest
                      end
 
             if result.blank?
-              STDOUT.puts "🐳  Unfound coerced test: #{self.name}##{m}"
+              STDOUT.puts "🐳  Unfound coerced test: #{name}##{m}"
             else
-              STDOUT.puts "🐵  Undefined coerced test: #{self.name}##{m}"
+              STDOUT.puts "🐵  Undefined coerced test: #{name}##{m}"
             end
           end
         end

data/test/support/connection_reflection.rb

@@ -8,20 +8,14 @@ module ARTest
       included { extend ConnectionReflection }
 
       def connection
-        ActiveRecord::Base.connection
+        ActiveRecord::Base.lease_connection
       end
 
       def connection_options
-        connection.instance_variable_get :@connection_options
+        connection.instance_variable_get :@connection_parameters
       end
 
-      def connection_dblib?
-        connection_options[:mode] == :dblib
-      end
-
-      def connection_dblib_73?
-        return false unless connection_dblib?
-
+      def connection_tds_73
         rc = connection.raw_connection
         rc.respond_to?(:tds_73?) && rc.tds_73?
       end

data/test/support/core_ext/query_cache.rb

@@ -22,7 +22,13 @@ module SqlIgnoredCache
   # compromising cache outside tests.
   def cache_sql(sql, name, binds)
     result = super
-    @query_cache.delete_if { |k, v| k =~ Regexp.union(IGNORED_SQL) }
+
+    @query_cache.instance_variable_get(:@map).delete_if do |cache_key, _v|
+      # Query cache key generated by `sql` or `[sql, binds]`, so need to retrieve `sql` for both cases.
+      cache_key_sql = Array(cache_key).first
+      Regexp.union(IGNORED_SQL).match?(cache_key_sql)
+    end
+
     result
   end
 end