activerecord-sqlserver-adapter 4.1.8 → 4.2.0.pre

data/test/cases/pessimistic_locking_test_sqlserver.rb

@@ -0,0 +1,90 @@
+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_sql %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 'reload with lock when #lock! called' do
+      assert_nothing_raised do
+        Person.transaction do
+          person = Person.find 1
+          old, person.first_name = person.first_name, 'fooman'
+          person.lock!
+          assert_equal old, person.first_name
+        end
+      end
+    end
+
+    it 'can add a custom lock directive' do
+      assert_sql %r|SELECT \[people\]\.\* FROM \[people\] WITH\(HOLDLOCK, ROWLOCK\)| do
+        Person.lock('WITH(HOLDLOCK, ROWLOCK)').load
+      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 10 ROWS FETCH NEXT 5 ROWS ONLY/
+      loader_sql = /SELECT.*FROM \[people\] WITH\(UPDLOCK\).*WHERE \[people\]\.\[id\] IN/
+      assert_sql(eager_ids_sql, loader_sql) 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/schema_dumper_test_sqlserver.rb

@@ -0,0 +1,175 @@
+require 'cases/helper_sqlserver'
+
+class SchemaDumperTestSQLServer < ActiveRecord::TestCase
+
+  before { all_tables }
+
+  let(:all_tables)   { ActiveRecord::Base.connection.tables }
+  let(:schema)       { @generated_schema }
+
+  it 'sst_datatypes' do
+    generate_schema_for_table 'sst_datatypes'
+    # Exact Numerics
+    assert_line :bigint,            type: 'bigint',       limit: '8',           precision: nil,   scale: nil,  default: '42'
+    assert_line :int,               type: 'integer',      limit: '4',           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: '0',  default: '191.0'
+    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'
+    # 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: %r{123.4[45]}
+    # Date and Time
+    assert_line :date,              type: 'date',         limit: nil,           precision: nil,   scale: nil,  default: "'0001-01-01'"
+    assert_line :datetime,          type: 'datetime',     limit: nil,           precision: nil,   scale: nil,  default: "'1753-01-01 00:00:00'"
+    assert_line :smalldatetime,     type: 'datetime',     limit: nil,           precision: nil,   scale: nil,  default: "'1901-01-01 15:45:00'"
+    assert_line :time_2,            type: 'time',         limit: nil,           precision: '2',   scale: nil,  default: nil
+    assert_line :time_7,            type: 'time',         limit: nil,           precision: nil,   scale: nil,  default: nil
+    # Character Strings
+    assert_line :char_10,           type: 'char',         limit: '10',          precision: nil,   scale: nil,  default: "\"1234567890\""
+    assert_line :varchar_50,        type: 'varchar',      limit: '50',          precision: nil,   scale: nil,  default: "\"test varchar_50\""
+    assert_line :varchar_max,       type: 'varchar_max',  limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test varchar_max\""
+    assert_line :text,              type: 'text_basic',   limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test text\""
+    # Unicode Character Strings
+    assert_line :nchar_10,          type: 'nchar',        limit: '10',          precision: nil,   scale: nil,  default: "\"12345678åå\""
+    assert_line :nvarchar_50,       type: 'string',       limit: '50',          precision: nil,   scale: nil,  default: "\"test nvarchar_50 åå\""
+    assert_line :nvarchar_max,      type: 'text',         limit: '2147483647',  precision: nil,   scale: nil,  default: "\"test nvarchar_max åå\""
+    assert_line :ntext,             type: 'ntext',        limit: '2147483647',  precision: nil,   scale: nil,  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: '2147483647',  precision: nil,   scale: nil,  default: nil
+    # Other Data Types
+    assert_line :uniqueidentifier,  type: 'uuid',         limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :timestamp,         type: 'ss_timestamp', limit: nil,           precision: nil,   scale: nil,  default: nil
+  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: '4',          precision: nil,  scale: nil, default: nil
+    assert_line :bigint_col,      type: 'bigint',       limit: '8',          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: '0', default: nil
+    assert_line :float_col,       type: 'float',        limit: nil,          precision: nil,  scale: nil, default: nil
+    assert_line :string_col,      type: 'string',       limit: '4000',       precision: nil,  scale: nil, default: nil
+    assert_line :text_col,        type: 'text',         limit: '2147483647', 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: nil,  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: '2147483647', precision: nil,  scale: nil, default: nil
+    # Our type methods.
+    columns['real_col'].sql_type.must_equal         'real'
+    columns['money_col'].sql_type.must_equal        'money'
+    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'
+    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 :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: '8000',        precision: nil,   scale: nil,  default: nil
+    assert_line :text_basic_col,    type: 'text_basic',   limit: '2147483647',  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: '2147483647',  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: '8000',        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
+  end
+
+  # Special Cases
+
+  it 'primary_key' 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_match %r(primary_key: "movieid"), match[1], "non-standard primary key not preserved"
+    end
+  end
+
+
+  private
+
+  def generate_schema_for_table(*table_names)
+    require 'stringio'
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, 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
+  end
+
+  def line(column_name)
+    @schema_lines[column_name.to_s]
+  end
+
+  def assert_line(column_name, options={})
+    line = line(column_name)
+    assert line, "Count not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
+    line.type_method.must_equal  options[:type],      "Type of #{options[:type].inspect} not found in:\n #{line}"            if options.key?(:type)
+    line.limit.must_equal        options[:limit],     "Limit of #{options[:limit].inspect} not found in:\n #{line}"          if options.key?(:limit)
+    line.precision.must_equal    options[:precision], "Precision of #{options[:precision].inspect} not found in:\n #{line}"  if options.key?(:precision)
+    line.scale.must_equal        options[:scale],     "Scale of #{options[:scale].inspect} not found in:\n #{line}"          if options.key?(:scale)
+    line.default.must_equal      options[:default],   "Default of #{options[:default].inspect} not found in:\n #{line}"      if options.key?(:default) && options[:default].is_a?(String)
+    line.default.must_match      options[:default],   "Default of #{options[:default].inspect} not found in:\n #{line}"      if options.key?(:default) && options[:default].is_a?(Regexp)
+  end
+
+  class SchemaLine
+
+    attr_reader :line
+
+    def self.match(method_name, pattern)
+      define_method(method_name) { line.match(pattern).try :[], 1 }
+    end
+
+    def initialize(line)
+      @line = line
+    end
+
+    match :type_method,   %r{\A\s+t\.(.*?)\s}
+    match :limit,         %r{\slimit:\s(.*?)[,\s]}
+    match :default,       %r{\sdefault:\s(.*)\n}
+    match :precision,     %r{\sprecision:\s(.*?)[,\s]}
+    match :scale,         %r{\sscale:\s(.*?)[,\s]}
+
+    def to_s
+      line
+    end
+
+  end
+
+end
+

data/test/cases/schema_test_sqlserver.rb

@@ -0,0 +1,54 @@
+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.table_exists?('test.sst_schema_natural_id')
+      assert connection.table_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
+
+
+end
+

data/test/cases/scratchpad_test_sqlserver.rb

@@ -0,0 +1,9 @@
+require 'cases/helper_sqlserver'
+
+class ScratchpadTestSQLServer < ActiveRecord::TestCase
+
+  it 'helps debug things' do
+    #
+  end
+
+end

data/test/cases/showplan_test_sqlserver.rb

@@ -0,0 +1,65 @@
+require 'cases/helper_sqlserver'
+require 'models/car'
+
+class ShowplanTestSQLServer < ActiveRecord::TestCase
+
+  fixtures :cars
+
+  describe 'Unprepare previously prepared SQL' do
+
+    it 'from simple statement' do
+      plan = Car.where(id: 1).explain
+      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.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.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
+
+  end
+
+  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.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
+    end
+
+  end
+
+  describe 'With SHOWPLAN_XML option' do
+
+    it 'show formatted xml' do
+      with_showplan_option('SHOWPLAN_XML') do
+        plan = Car.where(id: 1).explain
+        plan.must_include 'ShowPlanXML'
+      end
+    end
+
+  end
+
+
+  private
+
+  def with_showplan_option(option)
+    old_option = ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option = option
+    yield
+  ensure
+    ActiveRecord::ConnectionAdapters::SQLServerAdapter.showplan_option = old_option
+  end
+
+end

data/test/cases/specific_schema_test_sqlserver.rb

@@ -0,0 +1,118 @@
+require 'cases/helper_sqlserver'
+
+class SpecificSchemaTestSQLServer < ActiveRecord::TestCase
+
+  after { SSTestEdgeSchema.delete_all }
+
+  it 'handle dollar symbols' do
+    SSTestDollarTableName.new.save
+    SSTestDollarTableName.limit(20).offset(1)
+  end
+
+  it 'models can use tinyint pk tables' do
+    obj = SSTestTinyintPk.create! name: '1'
+    obj.id.is_a? Fixnum
+    SSTestTinyintPk.find(obj.id).must_equal obj
+  end
+
+  it 'be able to complex count tables with no primary key' do
+    SSTestNoPkData.delete_all
+    10.times { |n| SSTestNoPkData.create! name: "Test#{n}" }
+    assert_equal 1, SSTestNoPkData.where(name: 'Test5').count
+  end
+
+  it 'quote table names properly even when they are views' do
+    obj = SSTestQuotedTable.create!
+    assert_nothing_raised { assert SSTestQuotedTable.first }
+    obj = SSTestQuotedTableUser.create!
+    assert_nothing_raised { assert SSTestQuotedTableUser.first }
+    obj = SSTestQuotedView1.create!
+    assert_nothing_raised { assert SSTestQuotedView1.first }
+    obj = SSTestQuotedView2.create!
+    assert_nothing_raised { assert SSTestQuotedView2.first }
+  end
+
+  it 'cope with multi line defaults' do
+    default = SSTestStringDefault.new
+    assert_equal "Some long default with a\nnew line.", default.string_with_multiline_default
+  end
+
+  it 'default strings before save' do
+    default = SSTestStringDefault.new
+    assert_equal nil, default.string_with_null_default
+    assert_equal 'null', default.string_with_pretend_null_one
+    assert_equal '(null)', default.string_with_pretend_null_two
+    assert_equal 'NULL', default.string_with_pretend_null_three
+    assert_equal '(NULL)', default.string_with_pretend_null_four
+    assert_equal '(3)', default.string_with_pretend_paren_three
+  end
+
+  it 'default strings after save' do
+    default = SSTestStringDefault.create
+    assert_equal nil, default.string_with_null_default
+    assert_equal 'null', default.string_with_pretend_null_one
+    assert_equal '(null)', default.string_with_pretend_null_two
+    assert_equal 'NULL', default.string_with_pretend_null_three
+    assert_equal '(NULL)', default.string_with_pretend_null_four
+  end
+
+  # Natural primary keys.
+
+  it 'work with identity inserts' do
+    record = SSTestNaturalPkData.new name: 'Test', description: 'Natural identity inserts.'
+    record.id = '12345ABCDE'
+    assert record.save
+    assert_equal '12345ABCDE', record.reload.id
+  end
+
+  it 'work with identity inserts when the key is an int' do
+    record = SSTestNaturalPkIntData.new name: 'Test', description: 'Natural identity inserts.'
+    record.id = 12
+    assert record.save
+    assert_equal 12, record.reload.id
+  end
+
+  it 'use primary key for row table order in pagination sql' do
+    sql = /ORDER BY \[sst_natural_pk_data\]\.\[legacy_id\] ASC OFFSET 5 ROWS FETCH NEXT 5 ROWS ONLY/
+    assert_sql(sql) { SSTestNaturalPkData.limit(5).offset(5).load }
+  end
+
+  # Special quoted column
+
+  it 'work as normal' do
+    SSTestEdgeSchema.delete_all
+    r = SSTestEdgeSchema.create! 'crazy]]quote' => 'crazyqoute'
+    assert SSTestEdgeSchema.columns_hash['crazy]]quote']
+    assert_equal r, SSTestEdgeSchema.where('crazy]]quote' => 'crazyqoute').first
+  end
+
+  # With column names that have spaces
+
+  it 'create record using a custom attribute reader and be able to load it back in' do
+    value = 'Saved value into a column that has a space in the name.'
+    record = SSTestEdgeSchema.create! with_spaces: value
+    assert_equal value, SSTestEdgeSchema.find(record.id).with_spaces
+  end
+
+  # With description column
+
+  it 'allow all sorts of ordering without adapter munging it up with special description column' do
+    SSTestEdgeSchema.create! description: 'A'
+    SSTestEdgeSchema.create! description: 'B'
+    SSTestEdgeSchema.create! description: 'C'
+    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description').map(&:description)
+    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description asc').map(&:description)
+    assert_equal ['A','B','C'], SSTestEdgeSchema.order('description ASC').map(&:description)
+    assert_equal ['C','B','A'], SSTestEdgeSchema.order('description desc').map(&:description)
+    assert_equal ['C','B','A'], SSTestEdgeSchema.order('description DESC').map(&:description)
+  end
+
+  # For uniqueidentifier model helpers
+
+  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.must_match(acceptable_uuid)
+  end
+
+end