activerecord-sqlserver-adapter-odbc-extended 8.0.10

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+require "stringio"
+
+class SchemaDumperTestSQLServer < ActiveRecord::TestCase
+  before { all_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",                                                     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",                                                      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-1900"
+    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",                    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",                                              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,                                   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,                                   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
+    assert_line :varbinary_49,      type: "varbinary",     limit: 49
+    assert_line :varbinary_max,     type: "binary"
+    # Other Data Types
+    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_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["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"
+    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
+
+  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, "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"
+  end
+
+  it "dumps field with unique key constraints only once" do
+    output = generate_schema_for_table "unique_key_dumped_table"
+
+    _(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)
+    previous_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+    ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
+
+    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
+    type_matcher = /\A\s+t\.\w+\s+"(.*?)"[,\n]/
+    @generated_schema.each_line do |line|
+      next unless line =~ type_matcher
+
+      @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, expected_options = {})
+    line = line(column_name)
+    assert line, "Could not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+
+    # 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)
+
+      message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
+
+      if expected.nil?
+        _(actual).must_be_nil message
+      elsif expected.is_a?(Array)
+        _(actual).must_include expected, message
+      elsif expected.is_a?(Float)
+        _(actual).must_be_close_to expected, 0.001
+      elsif expected.is_a?(Proc)
+        _(actual.call).must_equal(expected.call)
+      else
+        _(actual).must_equal expected, message
+      end
+    end
+  end
+
+  class SchemaLine
+    LINE_PARSER = %r{t\.(\w+)\s+"(.*?)"[,\s+](.*)}
+
+    attr_reader :line,
+                :type_method,
+                :col_name,
+                :options
+
+    def self.option(method_name)
+      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)
+      @line = line
+      @type_method, @col_name, @options = parse_line
+    end
+
+    option :limit
+    option :precision
+    option :scale
+    option :default
+    option :collation
+    option :null
+
+    def to_s
+      line.squish
+    end
+
+    def inspect
+      "#<SchemaLine col_name=#{col_name.inspect}, options=#{options.inspect}>"
+    end
+
+    private
+
+    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
+
+    def parse_options(opts)
+      if opts.present?
+        eval "{#{opts}}"
+      else
+        {}
+      end
+    end
+  end
+end

data/test/cases/schema_test_sqlserver.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class SchemaTestSQLServer < ActiveRecord::TestCase
+  describe "When table is dbo schema" do
+    it "find primary key for tables with odd schema" do
+      _(connection.primary_key("sst_natural_pk_data")).must_equal "legacy_id"
+    end
+  end
+
+  describe "When table is in non-dbo schema" do
+    it "work with table exists" do
+      assert connection.data_source_exists?("test.sst_schema_natural_id")
+      assert connection.data_source_exists?("[test].[sst_schema_natural_id]")
+    end
+
+    it "find primary key for tables with odd schema" do
+      _(connection.primary_key("test.sst_schema_natural_id")).must_equal "legacy_id"
+    end
+
+    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
+
+    it "read only column properties for table in specific schema" do
+      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
+      assert_equal 1, test_columns.select { |c| c.is_identity? }.size
+      assert_equal 1, dbo_columns.select { |c| c.is_identity? }.size
+      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
+      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/trigger_test_sqlserver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class SQLServerTriggerTest < ActiveRecord::TestCase
+  after { exclude_output_inserted_table_names.clear }
+
+  let(:exclude_output_inserted_table_names) do
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.exclude_output_inserted_table_names
+  end
+
+  it "can insert into a table with output inserted - with a true setting for table name" do
+    exclude_output_inserted_table_names["sst_table_with_trigger"] = true
+    assert SSTestTriggerHistory.all.empty?
+    obj = SSTestTrigger.create! event_name: "test trigger"
+    _(["Fixnum", "Integer"]).must_include obj.id.class.name
+    _(obj.event_name).must_equal "test trigger"
+    _(obj.id).must_be :present?
+    _(obj.id.to_s).must_equal SSTestTriggerHistory.first.id_source
+  end
+
+  it "can insert into a table with output inserted - with a uniqueidentifier value" do
+    exclude_output_inserted_table_names["sst_table_with_uuid_trigger"] = "uniqueidentifier"
+    assert SSTestTriggerHistory.all.empty?
+    obj = SSTestTriggerUuid.create! event_name: "test uuid trigger"
+    _(obj.id.class.name).must_equal "String"
+    _(obj.event_name).must_equal "test uuid trigger"
+    _(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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class UtilsTestSQLServer < ActiveRecord::TestCase
+  it ".quote_string" do
+    _(SQLServer::Utils.quote_string("I'll store this in C:\\Users")).must_equal "I''ll store this in C:\\Users"
+  end
+
+  it ".unquote_string" do
+    _(SQLServer::Utils.unquote_string("I''ll store this in C:\\Users")).must_equal "I'll store this in C:\\Users"
+  end
+
+  it ".quoted_raw" do
+    _(SQLServer::Utils.quoted_raw("some.Name")).must_equal "[some.Name]"
+  end
+
+  describe ".extract_identifiers constructor and thus SQLServer::Utils::Name value object" do
+    let(:valid_names) { valid_names_unquoted + valid_names_quoted }
+
+    let(:valid_names_unquoted) {
+      [
+        "server.database.schema.object",
+        "server.database..object",
+        "server..schema.object",
+        "server...object",
+        "database.schema.object",
+        "database..object",
+        "schema.object",
+        "object"
+      ]
+    }
+
+    let(:valid_names_quoted) {
+      [
+        "[server].[database].[schema].[object]",
+        "[server].[database]..[object]",
+        "[server]..[schema].[object]",
+        "[server]...[object]",
+        "[database].[schema].[object]",
+        "[database]..[object]",
+        "[schema].[object]",
+        "[object]"
+      ]
+    }
+
+    let(:server_names)   { valid_names.partition { |name| name =~ /server/ } }
+    let(:database_names) { valid_names.partition { |name| name =~ /database/ } }
+    let(:schema_names)   { valid_names.partition { |name| name =~ /schema/ } }
+
+    it "extracts and returns #object identifier unquoted by default or quoted as needed" do
+      valid_names.each do |n|
+        name = extract_identifiers(n)
+        _(name.object).must_equal "object", "With #{n.inspect} for #object"
+        _(name.object_quoted).must_equal "[object]", "With #{n.inspect} for #object_quoted"
+      end
+    end
+
+    [:schema, :database, :server].each do |part|
+      it "extracts and returns #{part} identifier unquoted by default or quoted as needed" do
+        present, blank = send(:"#{part}_names")
+        present.each do |n|
+          name = extract_identifiers(n)
+          _(name.send(:"#{part}")).must_equal "#{part}", "With #{n.inspect} for ##{part} method"
+          _(name.send(:"#{part}_quoted")).must_equal "[#{part}]", "With #{n.inspect} for ##{part}_quoted method"
+        end
+        blank.each do |n|
+          name = extract_identifiers(n)
+          _(name.send(:"#{part}")).must_be_nil "With #{n.inspect} for ##{part} method"
+          _(name.send(:"#{part}_quoted")).must_be_nil "With #{n.inspect} for ##{part}_quoted method"
+        end
+      end
+    end
+
+    it "does not blow up on nil or blank string name" do
+      _(extract_identifiers(nil).object).must_be_nil
+      _(extract_identifiers(" ").object).must_be_nil
+    end
+
+    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]"
+    end
+
+    it "can take a symbol argument" do
+      _(extract_identifiers(:object).object).must_equal "object"
+    end
+
+    it "allows identifiers with periods to work" do
+      _(extract_identifiers("[obj.name]").quoted).must_equal "[obj.name]"
+      _(extract_identifiers("[obj.name].[foo]").quoted).must_equal "[obj.name].[foo]"
+    end
+
+    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
+      _(extract_identifiers("database.object").fully_qualified?).must_equal false
+      _(extract_identifiers("server...object").fully_qualified?).must_equal false
+      _(extract_identifiers("server.database..object").fully_qualified?).must_equal false
+      _(extract_identifiers("server.database.schema.object").fully_qualified?).must_equal true
+      _(extract_identifiers("server.database.schema.").fully_qualified?).must_equal true
+      _(extract_identifiers("[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[schema].[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[database].[schema].[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[database].[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[server.name]...[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[server.name].[database]..[obj.name]").fully_qualified?).must_equal false
+      _(extract_identifiers("[server.name].[database].[schema].[obj.name]").fully_qualified?).must_equal true
+      _(extract_identifiers("[server.name].[database].[schema].").fully_qualified?).must_equal true
+    end
+
+    it "can return fully qualified quoted table name" do
+      name = extract_identifiers("[my.server].db.schema.")
+      _(name.fully_qualified_database_quoted).must_equal "[my.server].[db]"
+      name = extract_identifiers("[server.name].[database].[schema].[object]")
+      _(name.fully_qualified_database_quoted).must_equal "[server.name].[database]"
+      name = extract_identifiers("server.database.schema.object")
+      _(name.fully_qualified_database_quoted).must_equal "[server].[database]"
+    end
+  end
+
+  private
+
+  def extract_identifiers(name)
+    SQLServer::Utils.extract_identifiers(name)
+  end
+end

data/test/cases/uuid_test_sqlserver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class SQLServerUuidTest < ActiveRecord::TestCase
+  let(:acceptable_uuid) { ActiveRecord::ConnectionAdapters::SQLServer::Type::Uuid::ACCEPTABLE_UUID }
+
+  it "has a uuid primary key" do
+    _(SSTestUuid.columns_hash["id"].type).must_equal :uuid
+    assert SSTestUuid.primary_key
+  end
+
+  it "can create with a new pk" do
+    obj = SSTestUuid.create!
+    _(obj.id).must_be :present?
+    _(obj.id).must_match acceptable_uuid
+  end
+
+  it "can create other uuid column on reload" do
+    obj = SSTestUuid.create!
+    obj.reload
+    _(obj.other_uuid).must_match acceptable_uuid
+  end
+
+  it "can find uuid pk via connection" do
+    _(connection.primary_key(SSTestUuid.table_name)).must_equal "id"
+  end
+
+  it "changing column 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()"
+    # Now to a different function.
+    connection.change_column table_name, :thingy, :uuid, null: false, default: "NEWID()"
+    SSTestUuid.reset_column_information
+    column = SSTestUuid.columns_hash["thingy"]
+    _(column.default_function).must_equal "newid()"
+  end
+
+  it "can insert even when use_output_inserted to false " do
+    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