activerecord-sqlserver-adapter-odbc-extended 8.0.10

data/test/cases/migration_test_sqlserver.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/person"
+
+class MigrationTestSQLServer < ActiveRecord::TestCase
+  describe "For transactions" do
+    before do
+      @trans_test_table1 = "sqlserver_trans_table1"
+      @trans_test_table2 = "sqlserver_trans_table2"
+      @trans_tables = [@trans_test_table1, @trans_test_table2]
+    end
+
+    after do
+      @trans_tables.each do |table_name|
+        ActiveRecord::Migration.drop_table(table_name) if connection.tables.include?(table_name)
+      end
+    end
+
+    it "not create a tables if error in migrations" do
+      begin
+        migrations_dir = File.join ARTest::SQLServer.migrations_root, "transaction_table"
+        quietly { ActiveRecord::MigrationContext.new(migrations_dir).up }
+      rescue Exception => e
+        assert_match %r|this and all later migrations canceled|, e.message
+      end
+      _(connection.tables).wont_include @trans_test_table1
+      _(connection.tables).wont_include @trans_test_table2
+    end
+  end
+
+  describe "For changing column" do
+    it "not raise exception when column contains default constraint" do
+      lock_version_column = Person.columns_hash["lock_version"]
+      assert_equal :integer, lock_version_column.type
+      assert lock_version_column.default.present?
+      assert_nothing_raised { connection.change_column "people", "lock_version", :string }
+      Person.reset_column_information
+      lock_version_column = Person.columns_hash["lock_version"]
+      assert_equal :string, lock_version_column.type
+      assert lock_version_column.default.nil?
+      assert_nothing_raised { connection.change_column "people", "lock_version", :integer }
+      Person.reset_column_information
+    end
+
+    it "not drop the default constraint if just renaming" do
+      find_default = lambda do
+        connection.execute_procedure(:sp_helpconstraint, "sst_string_defaults", "nomsg").flatten.select do |row|
+          row["constraint_type"] == "DEFAULT on column string_with_pretend_paren_three"
+        end.last
+      end
+      default_before = find_default.call
+      connection.change_column :sst_string_defaults, :string_with_pretend_paren_three, :string, limit: 255
+      default_after = find_default.call
+      assert default_after
+      assert_equal default_before["constraint_keys"], default_after["constraint_keys"]
+    end
+
+    it "change limit" do
+      assert_nothing_raised { connection.change_column :people, :lock_version, :integer, limit: 8 }
+    end
+
+    it 'change limit' do
+      assert_nothing_raised { connection.change_column :people, :lock_version, :integer, limit: 8 }
+    end
+
+    it 'change null and default' do
+      assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
+    end
+
+    it "change null and default" do
+      assert_nothing_raised { connection.change_column :people, :first_name, :text, null: true, default: nil }
+    end
+
+    it "change collation" do
+      assert_nothing_raised { connection.change_column :sst_string_collation, :string_with_collation, :varchar, collation: :SQL_Latin1_General_CP437_BIN }
+
+      SstStringCollation.reset_column_information
+      assert_equal "SQL_Latin1_General_CP437_BIN", SstStringCollation.columns_hash['string_with_collation'].collation
+    end
+  end
+
+  describe "#create_schema" do
+    it "creates a new schema" do
+      connection.create_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+    end
+
+    it "creates a new schema with an owner" do
+      connection.create_schema("some schema", :guest)
+
+      schemas = connection.exec_query("select name, principal_id from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema", "principal_id" => 2 }
+    end
+  end
+
+  describe "#change_table_schema" do
+    before { connection.create_schema("foo") }
+
+    it "transfer the given table to the given schema" do
+      connection.change_table_schema("foo", "orders")
+
+      assert connection.data_source_exists?("foo.orders")
+    end
+  end
+
+  describe "#drop_schema" do
+    before { connection.create_schema("some schema") }
+
+    it "drops a schema" do
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      assert_includes schemas, { "name" => "some schema" }
+
+      connection.drop_schema("some schema")
+
+      schemas = connection.exec_query("select name from sys.schemas").to_a
+
+      refute_includes schemas, { "name" => "some schema" }
+    end
+  end
+
+  describe 'creating stored procedure' do
+    it 'stored procedure contains inserts are created successfully' do
+      sql = <<-SQL
+          CREATE OR ALTER PROCEDURE do_some_task
+          AS
+          IF NOT EXISTS(SELECT * FROM sys.objects WHERE type = 'U' AND name = 'SomeTableName')
+          BEGIN
+            CREATE TABLE SomeTableName (SomeNum int PRIMARY KEY CLUSTERED);
+            INSERT INTO SomeTableName(SomeNum) VALUES(1);
+          END
+        SQL
+
+      assert_nothing_raised { connection.execute(sql) }
+    ensure
+      connection.execute("DROP PROCEDURE IF EXISTS dbo.do_some_task;")
+    end
+  end
+end

data/test/cases/order_test_sqlserver.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/post"
+
+class OrderTestSQLServer < ActiveRecord::TestCase
+  fixtures :posts
+
+  it "not mangel complex order clauses" do
+    xyz_order = "CASE WHEN [title] LIKE N'XYZ%' THEN 0 ELSE 1 END"
+    xyz_post = Post.create title: "XYZ Post", body: "Test cased orders."
+    assert_equal xyz_post, Post.order(Arel.sql(xyz_order)).first
+  end
+
+  it "support column" do
+    order = "title"
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(order).first
+  end
+
+  it "support column ASC" do
+    order = "title ASC"
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(order).first
+  end
+
+  it "support column DESC" do
+    order = "title DESC"
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    assert_equal post1, Post.order(order).first
+  end
+
+  it "support column as symbol" do
+    order = :title
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(order).first
+  end
+
+  it "support table and column" do
+    order = "posts.title"
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(order).first
+  end
+
+  it "support quoted column" do
+    order = "[title]"
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+  end
+
+  it "support quoted table and column" do
+    order = "[posts].[title]"
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+  end
+
+  it "support primary: column, secondary: column" do
+    order = "title DESC, body"
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it "support primary: table and column, secondary: column" do
+    order = "posts.title DESC, body"
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
+    assert_equal post1, Post.order(order).first
+    assert_equal post2, Post.order(order).second
+  end
+
+  it "support primary: case expression, secondary: column" do
+    order = "(CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC, body"
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    post2 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  it "support primary: quoted table and column, secondary: case expresion" do
+    order = "[posts].[body] DESC, (CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END) DESC"
+    post1 = Post.create title: "ZZZ Post", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "ZZY Post", body: "ZZZ Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  it "support inline function" do
+    order = "LEN(title)"
+    post1 = Post.create title: "A", body: "AAA Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+  end
+
+  it "support inline function with parameters" do
+    order = "SUBSTRING(title, 1, 3)"
+    post1 = Post.create title: "AAA Post", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+  end
+
+  it "support inline function with parameters DESC" do
+    order = "SUBSTRING(title, 1, 3) DESC"
+    post1 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+  end
+
+  it "support primary: inline function, secondary: column" do
+    order = "LEN(title), body"
+    post1 = Post.create title: "A", body: "AAA Test cased orders."
+    post2 = Post.create title: "A", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  it "support primary: inline function, secondary: column with direction" do
+    order = "LEN(title) ASC, body DESC"
+    post1 = Post.create title: "A", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "A", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  it "support primary: column, secondary: inline function" do
+    order = "body DESC, LEN(title)"
+    post1 = Post.create title: "Post", body: "ZZZ Test cased orders."
+    post2 = Post.create title: "Longer Post", body: "ZZZ Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  it "support primary: case expression, secondary: inline function" do
+    order = "CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC, LEN(body) ASC"
+    post1 = Post.create title: "ZZZ Post", body: "Z"
+    post2 = Post.create title: "ZZZ Post", body: "Test cased orders."
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  it "support primary: inline function, secondary: case expression" do
+    order = "LEN(body), CASE WHEN [title] LIKE N'ZZZ%' THEN title ELSE '' END DESC"
+    post1 = Post.create title: "ZZZ Post", body: "Z"
+    post2 = Post.create title: "Post", body: "Z"
+    assert_equal post1, Post.order(Arel.sql(order)).first
+    assert_equal post2, Post.order(Arel.sql(order)).second
+  end
+
+  # Executing this kind of queries will raise "A column has been specified more than once in the order by list"
+  # This test shows that we don't do anything to prevent this
+  it "doesn't deduplicate semantically equal orders" do
+    sql = Post.order(:id).order("posts.id ASC").to_sql
+    assert_equal "SELECT [posts].* FROM [posts] ORDER BY [posts].[id] ASC, posts.id ASC", sql
+  end
+end

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "models/person"
+require "models/reader"
+
+class PessimisticLockingTestSQLServer < ActiveRecord::TestCase
+  fixtures :people, :readers
+
+  before do
+    Person.columns
+    Reader.columns
+  end
+
+  it "uses with updlock by default" 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
+
+  describe "For simple finds with default lock option" do
+    it "lock with simple find" do
+      assert_nothing_raised do
+        Person.transaction do
+          _(Person.lock(true).find(1)).must_equal Person.find(1)
+        end
+      end
+    end
+
+    it "lock with scoped find" do
+      assert_nothing_raised do
+        Person.transaction do
+          Person.lock(true).scoping do
+            _(Person.find(1)).must_equal Person.find(1)
+          end
+        end
+      end
+    end
+
+    it "lock with eager find" do
+      assert_nothing_raised do
+        Person.transaction do
+          person = Person.lock(true).includes(:readers).find(1)
+          _(person).must_equal Person.find(1)
+        end
+      end
+    end
+
+    it "can add a custom lock directive" 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_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_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_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_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
+    end
+  end
+
+  describe "For paginated finds" do
+    before do
+      Person.delete_all
+      20.times { |n| Person.create!(first_name: "Thing_#{n}") }
+    end
+
+    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_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"
+        _(people[2].first_name).must_equal "Thing_12"
+        _(people[3].first_name).must_equal "Thing_13"
+        _(people[4].first_name).must_equal "Thing_14"
+      end
+    end
+  end
+end

data/test/cases/primary_keys_test_sqlserver.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "support/schema_dumping_helper"
+
+class PrimaryKeyUuidTypeTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+    @connection.create_table(:barcodes, primary_key: "code", id: :uuid, force: true)
+  end
+
+  teardown do
+    @connection.drop_table(:barcodes, if_exists: true)
+  end
+
+  def test_any_type_primary_key
+    assert_equal "code", Barcode.primary_key
+
+    column = Barcode.column_for_attribute(Barcode.primary_key)
+    assert_not column.null
+    assert_equal :uuid, column.type
+    assert_not_predicate column, :is_identity?
+    assert_predicate column, :is_primary?
+  ensure
+    Barcode.reset_column_information
+  end
+
+  test "schema dump primary key includes default" do
+    schema = dump_table_schema "barcodes"
+    assert_match %r/create_table "barcodes", primary_key: "code", id: :uuid, default: -> { "newid\(\)" }/, schema
+  end
+end
+
+class PrimaryKeyIntegerTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  self.use_transactional_tests = false
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  class Widget < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.lease_connection
+  end
+
+  teardown do
+    @connection.drop_table :barcodes, if_exists: true
+    @connection.drop_table :widgets, if_exists: true
+  end
+
+  test "integer primary key without default" do
+    @connection.create_table(:widgets, id: :integer, force: true)
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_predicate column, :is_identity?
+    assert_equal :integer, column.type
+    assert_not_predicate column, :bigint?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", id: :integer, force: :cascade do/, schema
+  end
+
+  test "bigint primary key without default" do
+    @connection.create_table(:widgets, id: :bigint, force: true)
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_predicate column, :is_identity?
+    assert_equal :integer, column.type
+    assert_predicate column, :bigint?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", force: :cascade do/, schema
+  end
+
+  test "don't set identity to integer and bigint when there is a default" do
+    @connection.create_table(:barcodes, id: :integer, default: nil, force: true)
+    @connection.create_table(:widgets, id: :bigint, default: nil, force: true)
+
+    column = @connection.columns(:widgets).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_not_predicate column, :is_identity?
+
+    schema = dump_table_schema "widgets"
+    assert_match %r/create_table "widgets", id: :bigint, default: nil, force: :cascade do/, schema
+
+    column = @connection.columns(:barcodes).find { |c| c.name == "id" }
+    assert_predicate column, :is_primary?
+    assert_not_predicate column, :is_identity?
+
+    schema = dump_table_schema "barcodes"
+    assert_match %r/create_table "barcodes", id: :integer, default: nil, force: :cascade do/, schema
+  end
+end

data/test/cases/rake_test_sqlserver.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class SQLServerRakeTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  cattr_accessor :azure_skip
+  self.azure_skip = connection_sqlserver_azure?
+
+  let(:db_tasks)              { ActiveRecord::Tasks::DatabaseTasks }
+  let(:new_database)          { "activerecord_unittest_tasks" }
+  let(:default_configuration) { ARTest.test_configuration_hashes["arunit"] }
+  let(:configuration)         { default_configuration.merge("database" => new_database) }
+  let(:db_config)             { ActiveRecord::Base.configurations.resolve(configuration) }
+
+  before { skip "on azure" if azure_skip }
+  before { disconnect! unless azure_skip }
+  after  { reconnect unless azure_skip }
+
+  private
+
+  def disconnect!
+    connection.disconnect!
+  end
+
+  def reconnect
+    config = default_configuration
+    if connection_sqlserver_azure?
+      ActiveRecord::Base.establish_connection(config.merge("database" => "master"))
+      connection.drop_database(new_database) rescue nil
+      disconnect!
+      ActiveRecord::Base.establish_connection(config)
+    else
+      ActiveRecord::Base.establish_connection(config)
+      connection.drop_database(new_database) rescue nil
+    end
+  end
+end
+
+class SQLServerRakeCreateTest < SQLServerRakeTest
+  self.azure_skip = false
+
+  it "establishes connection to database after create " do
+    quietly { db_tasks.create configuration }
+    _(connection.current_database).must_equal(new_database)
+  end
+
+  it "creates database with default collation" do
+    quietly { db_tasks.create configuration }
+    _(connection.collation).must_equal "SQL_Latin1_General_CP1_CI_AS"
+  end
+
+  it "creates database with given collation" do
+    quietly { db_tasks.create configuration.merge("collation" => "Latin1_General_CI_AS") }
+    _(connection.collation).must_equal "Latin1_General_CI_AS"
+  end
+
+  it "prints error message when database exists" do
+    quietly { db_tasks.create configuration }
+    message = capture(:stderr) { db_tasks.create configuration }
+    _(message).must_match %r{activerecord_unittest_tasks.*already exists}
+  end
+end
+
+class SQLServerRakeDropTest < SQLServerRakeTest
+  self.azure_skip = false
+
+  it "drops database and uses master" do
+    quietly do
+      db_tasks.create configuration
+      db_tasks.drop configuration
+    end
+    _(connection.current_database).must_equal "master"
+  end
+
+  it "prints error message when database does not exist" do
+    message = capture(:stderr) { db_tasks.drop configuration.merge("database" => "doesnotexist") }
+    _(message).must_match %r{'doesnotexist' does not exist}
+  end
+end
+
+class SQLServerRakePurgeTest < SQLServerRakeTest
+  before do
+    quietly { db_tasks.create(configuration) }
+    connection.create_table :users, force: true do |t|
+      t.string :name, :email
+      t.timestamps null: false
+    end
+  end
+
+  it "clears active connections, drops database, and recreates with established connection" do
+    _(connection.current_database).must_equal(new_database)
+    _(connection.tables).must_include "users"
+    quietly { db_tasks.purge(configuration) }
+    _(connection.current_database).must_equal(new_database)
+    _(connection.tables).wont_include "users"
+  end
+end
+
+class SQLServerRakeCharsetTest < SQLServerRakeTest
+  before do
+    quietly { db_tasks.create(configuration) }
+  end
+
+  it "retrieves charset" do
+    _(db_tasks.charset(configuration)).must_equal "iso_1"
+  end
+end
+
+class SQLServerRakeCollationTest < SQLServerRakeTest
+  before do
+    quietly { db_tasks.create(configuration) }
+  end
+
+  it "retrieves collation" do
+    _(db_tasks.collation(configuration)).must_equal "SQL_Latin1_General_CP1_CI_AS"
+  end
+end
+
+class SQLServerRakeStructureDumpLoadTest < SQLServerRakeTest
+  let(:filename) { File.join ARTest::SQLServer.migrations_root, "structure.sql" }
+  let(:filedata) { File.read(filename) }
+
+  before do
+    quietly { db_tasks.create(configuration) }
+    connection.create_table :users, force: true do |t|
+      t.string :name, :email
+      t.text :background1
+      t.text_basic :background2
+      t.timestamps null: false
+    end
+  end
+
+  after do
+    FileUtils.rm_rf(filename)
+  end
+
+  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+}
+  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\]}
+    db_tasks.purge(configuration)
+    _(connection.tables).wont_include "users"
+    db_tasks.load_schema db_config, :sql, filename
+    _(connection.tables).must_include "users"
+  end
+end
+
+class SQLServerRakeSchemaCacheDumpLoadTest < SQLServerRakeTest
+  let(:filename) { File.join ARTest::SQLServer.test_root_sqlserver, "schema_cache.yml" }
+  let(:filedata) { File.read(filename) }
+
+  before do
+    quietly { db_tasks.create(configuration) }
+
+    connection.create_table :users, force: true do |t|
+      t.string :name, null: false
+    end
+  end
+
+  after do
+    FileUtils.rm_rf(filename)
+  end
+
+  it "dumps schema cache with SQL Server metadata" do
+    quietly { db_tasks.dump_schema_cache connection, 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")
+
+    assert col_id.is_identity
+    assert col_id.is_primary
+    assert_equal col_id.ordinal_position, 1
+    assert_equal col_id.table_name, "users"
+
+    assert_not col_name.is_identity
+    assert_not col_name.is_primary
+    assert_equal col_name.ordinal_position, 2
+    assert_equal col_name.table_name, "users"
+  end
+end