activerecord-sqlserver-adapter 6.1.2.1 → 7.2.4

data/test/cases/optimizer_hints_test_sqlserver.rb

@@ -7,55 +7,64 @@ class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
   fixtures :companies
 
   it "apply optimizations" do
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("HASH GROUP")
       companies = companies.distinct.select("firm_id")
-      assert_includes companies.explain, "| Hash Match | Aggregate  |"
+      assert_includes companies.explain.inspect, "| Hash Match | Aggregate  |"
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(ORDER GROUP\)\z}) do
       companies = Company.optimizer_hints("ORDER GROUP")
       companies = companies.distinct.select("firm_id")
-      assert_includes companies.explain, "| Stream Aggregate | Aggregate  |"
+      assert_includes companies.explain.inspect, "| Stream Aggregate | Aggregate  |"
     end
   end
 
   it "apply multiple optimizations" do
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP, FAST 1\)\z}) do
       companies = Company.optimizer_hints("HASH GROUP", "FAST 1")
       companies = companies.distinct.select("firm_id")
-      assert_includes companies.explain, "| Hash Match | Flow Distinct |"
+      assert_includes companies.explain.inspect, "| Hash Match | Flow Distinct |"
     end
   end
 
   it "support subqueries" do
-    assert_sql(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
+    assert_queries_match(%r{.*'SELECT COUNT\(count_column\) FROM \(SELECT .*\) subquery_for_count OPTION \(MAXDOP 2\)'.*}) do
       companies = Company.optimizer_hints("MAXDOP 2")
       companies = companies.select(:id).where(firm_id: [0, 1]).limit(3)
       assert_equal 3, companies.count
     end
   end
 
+
+  it "support order" do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ ORDER .+ OPTION .+\z}) do
+      companies = Company.optimizer_hints("LABEL='FindCompanies'")
+      companies = companies.order(:id)
+      companies.to_a
+    end
+  end
+
   it "sanitize values" do
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("OPTION (HASH GROUP)")
       companies = companies.distinct.select("firm_id")
       companies.to_a
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("OPTION(HASH GROUP)")
       companies = companies.distinct.select("firm_id")
       companies.to_a
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(TABLE HINT \(\[companies\], INDEX\(1\)\)\)\z}) do
       companies = Company.optimizer_hints("OPTION(TABLE HINT ([companies], INDEX(1)))")
       companies = companies.distinct.select("firm_id")
       companies.to_a
     end
 
-    assert_sql(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
+    assert_queries_match(%r{\ASELECT .+ FROM .+ OPTION \(HASH GROUP\)\z}) do
       companies = Company.optimizer_hints("Option(HASH GROUP)")
       companies = companies.distinct.select("firm_id")
       companies.to_a
@@ -63,7 +72,7 @@ class OptimizerHitsTestSQLServer < ActiveRecord::TestCase
   end
 
   it "skip optimization after unscope" do
-    assert_sql("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
+    assert_queries_match("SELECT DISTINCT [companies].[firm_id] FROM [companies]") do
       companies = Company.optimizer_hints("HASH GROUP")
       companies = companies.distinct.select("firm_id")
       companies.unscope(:optimizer_hints).load

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -13,7 +13,7 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
   end
 
   it "uses with updlock by default" do
-    assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
+    assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\)| do
       _(Person.lock(true).to_a).must_equal Person.all.to_a
     end
   end
@@ -47,32 +47,32 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     end
 
     it "can add a custom lock directive" do
-      assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
+      assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
         Person.lock("WITH(HOLDLOCK, ROWLOCK)").load
       end
     end
 
     describe "joining tables" do
       it "joined tables use updlock by default" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) INNER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).joins(:readers).load
         end
       end
 
       it "joined tables can use custom lock directive" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) INNER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock("WITH(NOLOCK)").joins(:readers).load
         end
       end
 
       it "left joined tables use updlock by default" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock(true).left_joins(:readers).load
         end
       end
 
       it "left joined tables can use custom lock directive" do
-        assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
+        assert_queries_match %r|SELECT \[people\]\.\* FROM \[people\] WITH\(NOLOCK\) LEFT OUTER JOIN \[readers\] WITH\(NOLOCK\)\s+ON \[readers\]\.\[person_id\] = \[people\]\.\[id\]| do
           Person.lock("WITH(NOLOCK)").left_joins(:readers).load
         end
       end
@@ -88,7 +88,8 @@ class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
     it "copes with eager loading un-locked paginated" do
       eager_ids_sql = /SELECT\s+DISTINCT \[people\].\[id\] FROM \[people\] WITH\(UPDLOCK\) LEFT OUTER JOIN \[readers\] WITH\(UPDLOCK\)\s+ON \[readers\].\[person_id\] = \[people\].\[id\]\s+ORDER BY \[people\].\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY/
       loader_sql = /SELECT.*FROM \[people\] WITH\(UPDLOCK\).*WHERE \[people\]\.\[id\] IN/
-      assert_sql(eager_ids_sql, loader_sql) do
+
+      assert_queries_match(/#{eager_ids_sql}|#{loader_sql}/, count: 2) do
         people = Person.lock(true).limit(5).offset(10).includes(:readers).references(:readers).to_a
         _(people[0].first_name).must_equal "Thing_10"
         _(people[1].first_name).must_equal "Thing_11"

data/test/cases/primary_keys_test_sqlserver.rb

@@ -12,7 +12,7 @@ class PrimaryKeyUuidTypeTest < ActiveRecord::TestCase
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
     @connection.create_table(:barcodes, primary_key: "code", id: :uuid, force: true)
   end
 
@@ -50,7 +50,7 @@ class PrimaryKeyIntegerTest < ActiveRecord::TestCase
   end
 
   setup do
-    @connection = ActiveRecord::Base.connection
+    @connection = ActiveRecord::Base.lease_connection
   end
 
   teardown do

data/test/cases/rake_test_sqlserver.rb

@@ -138,18 +138,22 @@ class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
 
   it "dumps structure and accounts for defncopy oddities" do
     skip "debug defncopy on windows later" if host_windows?
+
     quietly { db_tasks.structure_dump configuration, filename }
+
     _(filedata).wont_match %r{\AUSE.*\z}
     _(filedata).wont_match %r{\AGO.*\z}
-    _(filedata).must_match %r{email\s+nvarchar\(4000\)}
-    _(filedata).must_match %r{background1\s+nvarchar\(max\)}
-    _(filedata).must_match %r{background2\s+text\s+}
+    _(filedata).must_match %r{\[email\]\s+nvarchar\(4000\)}
+    _(filedata).must_match %r{\[background1\]\s+nvarchar\(max\)}
+    _(filedata).must_match %r{\[background2\]\s+text\s+}
   end
 
   it "can load dumped structure" do
     skip "debug defncopy on windows later" if host_windows?
+
     quietly { db_tasks.structure_dump configuration, filename }
-    _(filedata).must_match %r{CREATE TABLE dbo\.users}
+
+    _(filedata).must_match %r{CREATE TABLE \[dbo\]\.\[users\]}
     db_tasks.purge(configuration)
     _(connection.tables).wont_include "users"
     db_tasks.load_schema db_config, :sql, filename
@@ -176,7 +180,8 @@ class SQLServerRakeSchemaCacheDumpLoadTest < SQLServerRakeTest
   it "dumps schema cache with SQL Server metadata" do
     quietly { db_tasks.dump_schema_cache connection, filename }
 
-    schema_cache = YAML.load(File.read(filename))
+    filedata = File.read(filename)
+    _schema_cache = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(filedata) : YAML.load(filedata)
 
     col_id, col_name = connection.schema_cache.columns("users")
 

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -1,131 +1,142 @@
 # frozen_string_literal: true
 
 require "cases/helper_sqlserver"
+require "stringio"
 
 class SchemaDumperTestSQLServer < ActiveRecord::TestCase
   before { all_tables }
 
-  let(:all_tables)   { ActiveRecord::Base.connection.tables }
+  let(:all_tables)   { ActiveRecord::Base.lease_connection.tables }
   let(:schema)       { @generated_schema }
 
   it "sst_datatypes" do
     generate_schema_for_table "sst_datatypes"
-    assert_line :bigint,            type: "bigint",       limit: nil,           precision: nil,   scale: nil,  default: 42
-    assert_line :int,               type: "integer",      limit: nil,           precision: nil,   scale: nil,  default: 42
-    assert_line :smallint,          type: "integer",      limit: 2,             precision: nil,   scale: nil,  default: 42
-    assert_line :tinyint,           type: "integer",      limit: 1,             precision: nil,   scale: nil,  default: 42
-    assert_line :bit,               type: "boolean",      limit: nil,           precision: nil,   scale: nil,  default: true
-    assert_line :decimal_9_2,       type: "decimal",      limit: nil,           precision: 9,     scale: 2,    default: 12345.01
-    assert_line :numeric_18_0,      type: "decimal",      limit: nil,           precision: 18,    scale: nil,  default: 191
-    assert_line :numeric_36_2,      type: "decimal",      limit: nil,           precision: 36,    scale: 2,    default: 12345678901234567890.01
-    assert_line :money,             type: "money",        limit: nil,           precision: 19,    scale: 4,    default: 4.2
-    assert_line :smallmoney,        type: "smallmoney",   limit: nil,           precision: 10,    scale: 4,    default: 4.2
+
+    assert_line :bigint,            type: "bigint",                                                     default: 42
+    assert_line :int,               type: "integer",                                                    default: 42
+    assert_line :smallint,          type: "integer",       limit: 2,                                    default: 42
+    assert_line :tinyint,           type: "integer",       limit: 1,                                    default: 42
+    assert_line :bit,               type: "boolean",                                                    default: true
+    assert_line :decimal_9_2,       type: "decimal",                     precision: 9,     scale: 2,    default: 12345.01
+    assert_line :numeric_18_0,      type: "decimal",                     precision: 18,                 default: 191
+    assert_line :numeric_36_2,      type: "decimal",                     precision: 36,    scale: 2,    default: 12345678901234567890.01
+    assert_line :money,             type: "money",                       precision: 19,    scale: 4,    default: 4.2
+    assert_line :smallmoney,        type: "smallmoney",                  precision: 10,    scale: 4,    default: 4.2
     # Approximate Numerics
-    assert_line :float,             type: "float",        limit: nil,           precision: nil,   scale: nil,  default: 123.00000001
-    assert_line :real,              type: "real",         limit: nil,           precision: nil,   scale: nil,  default: 123.45
+    assert_line :float,             type: "float",                                                      default: 123.00000001
+    assert_line :real,              type: "real",                                                       default: 123.45
     # Date and Time
-    assert_line :date,              type: "date",         limit: nil,           precision: nil,   scale: nil,  default: "01-01-0001"
-    assert_line :datetime,          type: "datetime",     limit: nil,           precision: nil,   scale: nil,  default: "01-01-1753 00:00:00.123"
-    if connection_dblib_73?
-      assert_line :datetime2_7,       type: "datetime",     limit: nil,           precision: 7,     scale: nil,  default: "12-31-9999 23:59:59.9999999"
-      assert_line :datetime2_3,       type: "datetime",     limit: nil,           precision: 3,     scale: nil,  default: nil
-      assert_line :datetime2_1,       type: "datetime",     limit: nil,           precision: 1,     scale: nil,  default: nil
+    assert_line :date,              type: "date",                                                       default: "01-01-0001"
+    assert_line :datetime,          type: "datetime",                    precision: nil,                default: "01-01-1753 00:00:00.123"
+    if connection_tds_73
+      assert_line :datetime2_7,     type: "datetime",                    precision: 7,                  default: "12-31-9999 23:59:59.9999999"
+      assert_line :datetime2_3,     type: "datetime",                    precision: 3
+      assert_line :datetime2_1,     type: "datetime",                    precision: 1
     end
-    assert_line :smalldatetime, type: "smalldatetime", limit: nil, precision: nil, scale: nil, default: "01-01-1901 15:45:00.0"
-    if connection_dblib_73?
-      assert_line :time_7,            type: "time",         limit: nil,           precision: 7,     scale: nil,  default: "04:20:00.2883215"
-      assert_line :time_2,            type: "time",         limit: nil,           precision: 2,     scale: nil,  default: nil
-      assert_line :time_default,      type: "time",         limit: nil,           precision: 7,     scale: nil,  default: "15:03:42.0621978"
+    assert_line :smalldatetime,     type: "smalldatetime",                                              default: "01-01-1901 15:45:00.0"
+    if connection_tds_73
+      assert_line :time_7,          type: "time",                        precision: 7,                  default: "04:20:00.2883215"
+      assert_line :time_2,          type: "time",                        precision: 2
+      assert_line :time_default,    type: "time",                        precision: 7,                  default: "15:03:42.0621978"
     end
     # Character Strings
-    assert_line :char_10,           type: "char",         limit: 10,            precision: nil,   scale: nil,  default: "1234567890",           collation: nil
-    assert_line :varchar_50,        type: "varchar",      limit: 50,            precision: nil,   scale: nil,  default: "test varchar_50",      collation: nil
-    assert_line :varchar_max,       type: "varchar_max",  limit: nil,           precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
-    assert_line :text,              type: "text_basic",   limit: nil,           precision: nil,   scale: nil,  default: "test text",            collation: nil
+    assert_line :char_10,           type: "char",          limit: 10,                                   default: "1234567890"
+    assert_line :varchar_50,        type: "varchar",       limit: 50,                                   default: "test varchar_50"
+    assert_line :varchar_max,       type: "varchar_max",                                                default: "test varchar_max"
+    assert_line :text,              type: "text_basic",                                                 default: "test text"
     # Unicode Character Strings
-    assert_line :nchar_10,          type: "nchar",        limit: 10,            precision: nil,   scale: nil,  default: "12345678åå",           collation: nil
-    assert_line :nvarchar_50,       type: "string",       limit: 50,            precision: nil,   scale: nil,  default: "test nvarchar_50 åå",  collation: nil
-    assert_line :nvarchar_max,      type: "text",         limit: nil,           precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
-    assert_line :ntext,             type: "ntext",        limit: nil,           precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
+    assert_line :nchar_10,          type: "nchar",         limit: 10,                                   default: "12345678åå"
+    assert_line :nvarchar_50,       type: "string",        limit: 50,                                   default: "test nvarchar_50 åå"
+    assert_line :nvarchar_max,      type: "text",                                                       default: "test nvarchar_max åå"
+    assert_line :ntext,             type: "ntext",                                                      default: "test ntext åå"
     # Binary Strings
-    assert_line :binary_49,         type: "binary_basic", limit: 49,            precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_49,      type: "varbinary",    limit: 49,            precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_max,     type: "binary",       limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :binary_49,         type: "binary_basic",  limit: 49
+    assert_line :varbinary_49,      type: "varbinary",     limit: 49
+    assert_line :varbinary_max,     type: "binary"
     # Other Data Types
-    assert_line :uniqueidentifier,  type: "uuid",         limit: nil,           precision: nil,   scale: nil,  default: -> { "newid()" }
-    assert_line :timestamp,         type: "ss_timestamp", limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :uniqueidentifier,  type: "uuid",                                                       default: -> { "newid()" }
+    assert_line :timestamp,         type: "ss_timestamp"
   end
 
   it "sst_datatypes_migration" do
     columns = SSTestDatatypeMigration.columns_hash
     generate_schema_for_table "sst_datatypes_migration"
+
     # Simple Rails conventions
-    _(columns["integer_col"].sql_type).must_equal      "int(4)"
-    _(columns["bigint_col"].sql_type).must_equal       "bigint(8)"
-    _(columns["boolean_col"].sql_type).must_equal      "bit"
-    _(columns["decimal_col"].sql_type).must_equal      "decimal(18,0)"
-    _(columns["float_col"].sql_type).must_equal        "float"
-    _(columns["string_col"].sql_type).must_equal       "nvarchar(4000)"
-    _(columns["text_col"].sql_type).must_equal         "nvarchar(max)"
-    _(columns["datetime_col"].sql_type).must_equal     "datetime"
-    _(columns["timestamp_col"].sql_type).must_equal    "datetime"
-    _(columns["time_col"].sql_type).must_equal         "time(7)"
-    _(columns["date_col"].sql_type).must_equal         "date"
-    _(columns["binary_col"].sql_type).must_equal       "varbinary(max)"
-    assert_line :integer_col,     type: "integer",      limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :bigint_col,      type: "bigint",       limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :boolean_col,     type: "boolean",      limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :decimal_col,     type: "decimal",      limit: nil,          precision: 18,   scale: nil, default: nil
-    assert_line :float_col,       type: "float",        limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :string_col,      type: "string",       limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :text_col,        type: "text",         limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :datetime_col,    type: "datetime",     limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :timestamp_col,   type: "datetime",     limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :time_col,        type: "time",         limit: nil,          precision: 7,    scale: nil, default: nil
-    assert_line :date_col,        type: "date",         limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :binary_col,      type: "binary",       limit: nil,          precision: nil,  scale: nil, default: nil
+    _(columns["integer_col"].sql_type).must_equal                "int(4)"
+    _(columns["bigint_col"].sql_type).must_equal                 "bigint(8)"
+    _(columns["boolean_col"].sql_type).must_equal                "bit"
+    _(columns["decimal_col"].sql_type).must_equal                "decimal(18,0)"
+    _(columns["float_col"].sql_type).must_equal                  "float"
+    _(columns["string_col"].sql_type).must_equal                 "nvarchar(4000)"
+    _(columns["text_col"].sql_type).must_equal                   "nvarchar(max)"
+    _(columns["datetime_nil_precision_col"].sql_type).must_equal "datetime"
+    _(columns["datetime_col"].sql_type).must_equal               "datetime2(6)"
+    _(columns["timestamp_col"].sql_type).must_equal              "datetime2(6)"
+    _(columns["time_col"].sql_type).must_equal                   "time(7)"
+    _(columns["date_col"].sql_type).must_equal                   "date"
+    _(columns["binary_col"].sql_type).must_equal                 "varbinary(max)"
+
+    assert_line :integer_col,                type: "integer"
+    assert_line :bigint_col,                 type: "bigint"
+    assert_line :boolean_col,                type: "boolean"
+    assert_line :decimal_col,                type: "decimal",              precision: 18
+    assert_line :float_col,                  type: "float"
+    assert_line :string_col,                 type: "string"
+    assert_line :text_col,                   type: "text"
+    assert_line :datetime_nil_precision_col, type: "datetime",             precision: nil
+    assert_line :datetime_col,               type: "datetime"
+    assert_line :datetime_col,               type: "datetime"
+    assert_line :timestamp_col,              type: "datetime"
+    assert_line :time_col,                   type: "time",                 precision: 7
+    assert_line :date_col,                   type: "date"
+    assert_line :binary_col,                 type: "binary"
+
     # Our type methods.
-    _(columns["real_col"].sql_type).must_equal         "real"
-    _(columns["money_col"].sql_type).must_equal        "money"
-    _(columns["smalldatetime_col"].sql_type).must_equal "smalldatetime"
-    _(columns["datetime2_col"].sql_type).must_equal    "datetime2(7)"
-    _(columns["datetimeoffset"].sql_type).must_equal   "datetimeoffset(7)"
-    _(columns["smallmoney_col"].sql_type).must_equal   "smallmoney"
-    _(columns["char_col"].sql_type).must_equal         "char(1)"
-    _(columns["varchar_col"].sql_type).must_equal      "varchar(8000)"
-    _(columns["text_basic_col"].sql_type).must_equal   "text"
-    _(columns["nchar_col"].sql_type).must_equal        "nchar(1)"
-    _(columns["ntext_col"].sql_type).must_equal        "ntext"
-    _(columns["binary_basic_col"].sql_type).must_equal "binary(1)"
-    _(columns["varbinary_col"].sql_type).must_equal    "varbinary(8000)"
-    _(columns["uuid_col"].sql_type).must_equal         "uniqueidentifier"
-    _(columns["sstimestamp_col"].sql_type).must_equal  "timestamp"
-    _(columns["json_col"].sql_type).must_equal         "nvarchar(max)"
-    assert_line :real_col,          type: "real",           limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :money_col,         type: "money",          limit: nil,           precision: 19,    scale: 4,    default: nil
-    assert_line :smalldatetime_col, type: "smalldatetime",  limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :datetime2_col,     type: "datetime",       limit: nil,           precision: 7,     scale: nil,  default: nil
-    assert_line :datetimeoffset,    type: "datetimeoffset", limit: nil,           precision: 7,     scale: nil,  default: nil
-    assert_line :smallmoney_col,    type: "smallmoney",     limit: nil,           precision: 10,    scale: 4,    default: nil
-    assert_line :char_col,          type: "char",           limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :varchar_col,       type: "varchar",        limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :text_basic_col,    type: "text_basic",     limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :nchar_col,         type: "nchar",          limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :ntext_col,         type: "ntext",          limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :binary_basic_col,  type: "binary_basic",   limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_col,     type: "varbinary",      limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :uuid_col,          type: "uuid",           limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :sstimestamp_col,   type: "ss_timestamp",   limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :json_col,          type: "text",           limit: nil,           precision: nil,   scale: nil,  default: nil
+    _(columns["real_col"].sql_type).must_equal            "real"
+    _(columns["money_col"].sql_type).must_equal           "money"
+    _(columns["smalldatetime_col"].sql_type).must_equal   "smalldatetime"
+    _(columns["datetime2_col"].sql_type).must_equal       "datetime2(7)"
+    _(columns["datetimeoffset"].sql_type).must_equal      "datetimeoffset(7)"
+    _(columns["smallmoney_col"].sql_type).must_equal      "smallmoney"
+    _(columns["char_col"].sql_type).must_equal            "char(1)"
+    _(columns["varchar_col"].sql_type).must_equal         "varchar(8000)"
+    _(columns["text_basic_col"].sql_type).must_equal      "text"
+    _(columns["nchar_col"].sql_type).must_equal           "nchar(1)"
+    _(columns["ntext_col"].sql_type).must_equal           "ntext"
+    _(columns["binary_basic_col"].sql_type).must_equal    "binary(1)"
+    _(columns["binary_basic_16_col"].sql_type).must_equal "binary(16)"
+    _(columns["varbinary_col"].sql_type).must_equal       "varbinary(8000)"
+    _(columns["uuid_col"].sql_type).must_equal            "uniqueidentifier"
+    _(columns["sstimestamp_col"].sql_type).must_equal     "timestamp"
+    _(columns["json_col"].sql_type).must_equal            "nvarchar(max)"
+
+    assert_line :real_col,            type: "real"
+    assert_line :money_col,           type: "money",                      precision: 19,  scale: 4
+    assert_line :smalldatetime_col,   type: "smalldatetime"
+    assert_line :datetime2_col,       type: "datetime",                   precision: 7
+    assert_line :datetimeoffset,      type: "datetimeoffset",             precision: 7
+    assert_line :smallmoney_col,      type: "smallmoney",                 precision: 10,  scale: 4
+    assert_line :char_col,            type: "char",           limit: 1
+    assert_line :varchar_col,         type: "varchar"
+    assert_line :text_basic_col,      type: "text_basic"
+    assert_line :nchar_col,           type: "nchar",          limit: 1
+    assert_line :ntext_col,           type: "ntext"
+    assert_line :binary_basic_col,    type: "binary_basic",   limit: 1
+    assert_line :binary_basic_16_col, type: "binary_basic",   limit: 16
+    assert_line :varbinary_col,       type: "varbinary"
+    assert_line :uuid_col,            type: "uuid"
+    assert_line :sstimestamp_col,     type: "ss_timestamp",                                           null: false
+    assert_line :json_col,            type: "text"
   end
 
   it "dump column collation" do
     generate_schema_for_table('sst_string_collation')
 
-    assert_line :string_without_collation, type: "string", limit: nil, default: nil, collation: nil
-    assert_line :string_default_collation, type: "varchar", limit: nil, default: nil, collation: nil
-    assert_line :string_with_collation, type: "varchar", limit: nil, default: nil, collation: "SQL_Latin1_General_CP1_CS_AS"
-    assert_line :varchar_with_collation, type: "varchar", limit: nil, default: nil, collation: "SQL_Latin1_General_CP1_CS_AS"
+    assert_line :string_without_collation, type: "string"
+    assert_line :string_default_collation, type: "varchar"
+    assert_line :string_with_collation,    type: "varchar",                           collation: "SQL_Latin1_General_CP1_CS_AS"
+    assert_line :varchar_with_collation,   type: "varchar",                           collation: "SQL_Latin1_General_CP1_CS_AS"
   end
 
   # Special Cases
@@ -133,15 +144,16 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
   it "honor nonstandard primary keys" do
     generate_schema_for_table("movies") do |output|
       match = output.match(%r{create_table "movies"(.*)do})
-      assert_not_nil(match, "nonstandardpk table not found")
+      assert_not_nil(match, "non-standard primary key table not found")
       assert_match %r(primary_key: "movieid"), match[1], "non-standard primary key not preserved"
     end
   end
 
   it "no id with model driven primary key" do
     output = generate_schema_for_table "sst_no_pk_data"
+
     _(output).must_match %r{create_table "sst_no_pk_data".*id:\sfalse.*do}
-    assert_line :name, type: "string", limit: nil, default: nil, collation: nil
+    assert_line :name, type: "string"
   end
 
   it "dumps field with unique key constraints only once" do
@@ -150,13 +162,35 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     _(output.scan('t.integer "unique_field"').length).must_equal(1)
   end
 
+  it "schemas are dumped and tables names only include non-default schema" do
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream)
+    generated_schema = stream.string
+
+    # Only generate non-default schemas. Default schema is 'dbo'.
+    assert_not_includes generated_schema, 'create_schema "dbo"'
+    assert_not_includes generated_schema, 'create_schema "db_owner"'
+    assert_not_includes generated_schema, 'create_schema "INFORMATION_SCHEMA"'
+    assert_not_includes generated_schema, 'create_schema "sys"'
+    assert_not_includes generated_schema, 'create_schema "guest"'
+    assert_includes generated_schema, 'create_schema "test"'
+    assert_includes generated_schema, 'create_schema "test2"'
+
+    # Only non-default schemas should be included in table names. Default schema is 'dbo'.
+    assert_includes generated_schema, 'create_table "accounts"'
+    assert_includes generated_schema, 'create_table "test.aliens"'
+    assert_includes generated_schema, 'create_table "test2.sst_schema_test_multiple_schema"'
+  end
+
   private
 
   def generate_schema_for_table(*table_names)
-    require "stringio"
-    stream = StringIO.new
+    previous_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
     ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream)
+
     @generated_schema = stream.string
     yield @generated_schema if block_given?
     @schema_lines = Hash.new
@@ -167,21 +201,27 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
       @schema_lines[Regexp.last_match[1]] = SchemaLine.new(line)
     end
     @generated_schema
+  ensure
+    ActiveRecord::SchemaDumper.ignore_tables = previous_ignore_tables
   end
 
   def line(column_name)
     @schema_lines[column_name.to_s]
   end
 
-  def assert_line(column_name, options = {})
+  def assert_line(column_name, expected_options = {})
     line = line(column_name)
     assert line, "Could not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
 
-    [:type, :limit, :precision, :scale, :collation, :default].each do |key|
-      next unless options.key?(key)
+    # Check that the expected and actual option keys.
+    expected_options_keys = expected_options.keys
+    expected_options_keys.delete(:type)
+    _(expected_options_keys.sort).must_equal (line.options.keys.sort), "For column '#{column_name}' expected schema options and actual schema options do not match."
 
+    # Check the expected and actual option values.
+    expected_options.each do |key, expected|
       actual   = key == :type ? line.send(:type_method) : line.send(key)
-      expected = options[key]
+
       message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
 
       if expected.nil?
@@ -207,7 +247,13 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
                 :options
 
     def self.option(method_name)
-      define_method(method_name) { options.present? ? options[method_name.to_sym] : nil }
+      define_method(method_name) do
+        if options.key?(method_name.to_sym)
+          options[method_name.to_sym]
+        else
+          throw "Schema line does include the '#{method_name}' option!"
+        end
+      end
     end
 
     def initialize(line)
@@ -220,6 +266,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     option :scale
     option :default
     option :collation
+    option :null
 
     def to_s
       line.squish
@@ -234,6 +281,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     def parse_line
       _all, type_method, col_name, options = @line.match(LINE_PARSER).to_a
       options = parse_options(options)
+
       [type_method, col_name, options]
     end
 
@@ -243,8 +291,6 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
       else
         {}
       end
-    rescue SyntaxError
-      {}
     end
   end
 end