activerecord-sqlserver-adapter 4.2.18 → 5.0.0

data/test/cases/column_test_sqlserver.rb

@@ -36,14 +36,13 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'bigint(8)' do
       col = column('bigint')
       col.sql_type.must_equal           'bigint(8)'
+      col.type.must_equal               :bigint
       col.null.must_equal               true
       col.default.must_equal            42
       obj.bigint.must_equal             42
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::BigInteger
-      type.type.must_equal              :bigint
-      type.must_be                      :number?
       type.limit.must_equal             8
       assert_obj_set_and_save :bigint, -9_223_372_036_854_775_808
       assert_obj_set_and_save :bigint, 9_223_372_036_854_775_807
@@ -52,14 +51,13 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'int(4)' do
       col = column('int')
       col.sql_type.must_equal           'int(4)'
+      col.type.must_equal               :integer
       col.null.must_equal               true
       col.default.must_equal            42
       obj.int.must_equal                42
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Integer
-      type.type.must_equal              :integer
-      type.must_be                      :number?
       type.limit.must_equal             4
       assert_obj_set_and_save :int, -2_147_483_648
       assert_obj_set_and_save :int, 2_147_483_647
@@ -68,14 +66,13 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'smallint(2)' do
       col = column('smallint')
       col.sql_type.must_equal           'smallint(2)'
+      col.type.must_equal               :integer
       col.null.must_equal               true
       col.default.must_equal            42
       obj.smallint.must_equal           42
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::SmallInteger
-      type.type.must_equal              :integer
-      type.must_be                      :number?
       type.limit.must_equal             2
       assert_obj_set_and_save :smallint, -32_768
       assert_obj_set_and_save :smallint, 32_767
@@ -84,14 +81,13 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'tinyint(1)' do
       col = column('tinyint')
       col.sql_type.must_equal           'tinyint(1)'
+      col.type.must_equal               :integer
       col.null.must_equal               true
       col.default.must_equal            42
       obj.tinyint.must_equal            42
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::TinyInteger
-      type.type.must_equal              :integer
-      type.must_be                      :number?
       type.limit.must_equal             1
       assert_obj_set_and_save :tinyint, 0
       assert_obj_set_and_save :tinyint, 255
@@ -100,15 +96,14 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'bit' do
       col = column('bit')
       col.sql_type.must_equal           'bit'
+      col.type.must_equal               :boolean
       col.null.must_equal               true
       col.default.must_equal            true
       obj.bit.must_equal                true
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Boolean
-      type.type.must_equal              :boolean
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       obj.bit = 0
       obj.bit.must_equal false
       obj.save!
@@ -122,15 +117,14 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'decimal(9,2)' do
       col = column('decimal_9_2')
       col.sql_type.must_equal           'decimal(9,2)'
+      col.type.must_equal               :decimal
       col.null.must_equal               true
       col.default.must_equal            BigDecimal('12345.01')
       obj.decimal_9_2.must_equal        BigDecimal('12345.01')
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Decimal
-      type.type.must_equal              :decimal
-      type.must_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         9
       type.scale.must_equal             2
       obj.decimal_9_2 = '1234567.8901'
@@ -144,8 +138,8 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       col.sql_type.must_equal           'decimal(16,4)'
       col.default.must_equal            BigDecimal('1234567.89')
       obj.decimal_16_4.must_equal       BigDecimal('1234567.89')
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.precision.must_equal         16
       type.scale.must_equal             4
       obj.decimal_16_4 = '1234567.8901001'
@@ -157,15 +151,14 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'numeric(18,0)' do
       col = column('numeric_18_0')
       col.sql_type.must_equal           'numeric(18,0)'
+      col.type.must_equal               :decimal
       col.null.must_equal               true
       col.default.must_equal            BigDecimal('191')
       obj.numeric_18_0.must_equal       BigDecimal('191')
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Decimal
-      type.type.must_equal              :decimal
-      type.must_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         18
       type.scale.must_equal             0
       obj.numeric_18_0 = '192.1'
@@ -177,15 +170,14 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'numeric(36,2)' do
       col = column('numeric_36_2')
       col.sql_type.must_equal           'numeric(36,2)'
+      col.type.must_equal               :decimal
       col.null.must_equal               true
       col.default.must_equal            BigDecimal('12345678901234567890.01')
       obj.numeric_36_2.must_equal       BigDecimal('12345678901234567890.01')
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Decimal
-      type.type.must_equal              :decimal
-      type.must_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         36
       type.scale.must_equal             2
       obj.numeric_36_2 = '192.123'
@@ -197,15 +189,14 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'money' do
       col = column('money')
       col.sql_type.must_equal           'money'
+      col.type.must_equal               :money
       col.null.must_equal               true
       col.default.must_equal            BigDecimal('4.20')
       obj.money.must_equal              BigDecimal('4.20')
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Money
-      type.type.must_equal              :money
-      type.must_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         19
       type.scale.must_equal             4
       obj.money = '922337203685477.58061'
@@ -217,15 +208,14 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'smallmoney' do
       col = column('smallmoney')
       col.sql_type.must_equal           'smallmoney'
+      col.type.must_equal               :smallmoney
       col.null.must_equal               true
       col.default.must_equal            BigDecimal('4.20')
       obj.smallmoney.must_equal         BigDecimal('4.20')
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::SmallMoney
-      type.type.must_equal              :smallmoney
-      type.must_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         10
       type.scale.must_equal             4
       obj.smallmoney = '214748.36461'
@@ -241,17 +231,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'float' do
       col = column('float')
       col.sql_type.must_equal           'float'
+      col.type.must_equal               :float
       col.null.must_equal               true
       col.default.must_equal            123.00000001
       obj.float.must_equal              123.00000001
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Float
-      type.type.must_equal              :float
-      type.must_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       obj.float = '214748.36461'
       obj.float.must_equal        214748.36461
       obj.save!
@@ -261,17 +250,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'real' do
       col = column('real')
       col.sql_type.must_equal           'real'
+      col.type.must_equal               :real
       col.null.must_equal               true
       col.default.must_be_close_to      123.45, 0.01
       obj.real.must_be_close_to         123.45, 0.01
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Real
-      type.type.must_equal              :real
-      type.must_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       obj.real = '214748.36461'
       obj.real.must_be_close_to         214748.36461, 0.01
       obj.save!
@@ -283,22 +271,30 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'date' do
       col = column('date')
       col.sql_type.must_equal           'date'
+      col.type.must_equal               :date
       col.null.must_equal               true
       col.default.must_equal            connection_dblib_73? ? Date.civil(0001, 1, 1) : '0001-01-01'
       obj.date.must_equal               Date.civil(0001, 1, 1)
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Date
-      type.type.must_equal              :date
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
-      # Can cast strings.
-      obj.date = '0001-01-01'
-      obj.date.must_equal               Date.civil(0001, 1, 1)
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
+      # Can cast strings. SQL Server format.
+      obj.date = '04-01-0001'
+      obj.date.must_equal               Date.civil(0001, 4, 1)
+      obj.save!
+      obj.date.must_equal               Date.civil(0001, 4, 1)
+      obj.reload
+      obj.date.must_equal               Date.civil(0001, 4, 1)
+      # Can cast strings. ISO format.
+      obj.date = '0001-04-01'
+      obj.date.must_equal               Date.civil(0001, 4, 1)
       obj.save!
-      obj.reload.date.must_equal        Date.civil(0001, 1, 1)
+      obj.date.must_equal               Date.civil(0001, 4, 1)
+      obj.reload
+      obj.date.must_equal               Date.civil(0001, 4, 1)
       # Can keep and return assigned date.
       assert_obj_set_and_save :date, Date.civil(1972, 04, 14)
       # Can accept and cast time objects.
@@ -311,109 +307,144 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'datetime' do
       col = column('datetime')
       col.sql_type.must_equal           'datetime'
+      col.type.must_equal               :datetime
       col.null.must_equal               true
-      col.default.must_equal            Time.utc(1753, 01, 01, 00, 00, 00, 123000), "Microseconds were <#{col.default.usec}> vs <123000>"
-      obj.datetime.must_equal           Time.utc(1753, 01, 01, 00, 00, 00, 123000), "Microseconds were <#{obj.datetime.usec}> vs <123000>"
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      time = Time.utc 1753, 01, 01, 00, 00, 00, 123000
+      col.default.must_equal            time, "Microseconds were <#{col.default.usec}> vs <123000>"
+      obj.datetime.must_equal           time, "Microseconds were <#{obj.datetime.usec}> vs <123000>"
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::DateTime
-      type.type.must_equal              :datetime
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
+      obj.save!
+      obj.must_equal obj.class.where(datetime: time).first
       # Can save to proper accuracy and return again.
-      obj.datetime = Time.utc(2010, 01, 01, 12, 34, 56, 3000)
-      obj.datetime.must_equal           Time.utc(2010, 01, 01, 12, 34, 56, 3000), "Microseconds were <#{obj.datetime.usec}> vs <3000>"
+      time = Time.utc 2010, 04, 01, 12, 34, 56, 3000
+      obj.datetime = time
+      obj.datetime.must_equal           time, "Microseconds were <#{obj.datetime.usec}> vs <3000>"
       obj.save!
-      obj.reload.datetime.must_equal    Time.utc(2010, 01, 01, 12, 34, 56, 3000), "Microseconds were <#{obj.reload.datetime.usec}> vs <3000>"
+      obj.datetime.must_equal           time, "Microseconds were <#{obj.datetime.usec}> vs <3000>"
+      obj.reload
+      obj.datetime.must_equal           time, "Microseconds were <#{obj.datetime.usec}> vs <3000>"
+      obj.must_equal obj.class.where(datetime: time).first
       # Will cast to true DB value on attribute write, save and return again.
-      obj.datetime = Time.utc(2010, 01, 01, 12, 34, 56, 234567)
-      obj.datetime.must_equal           Time.utc(2010, 01, 01, 12, 34, 56, 233000), "Microseconds were <#{obj.datetime.usec}> vs <233000>"
+      time  = Time.utc 2010, 04, 01, 12, 34, 56, 234567
+      time2 = Time.utc 2010, 04, 01, 12, 34, 56, 233000
+      obj.datetime = time
+      obj.datetime.must_equal           time2, "Microseconds were <#{obj.datetime.usec}> vs <233000>"
+      obj.save!
+      obj.datetime.must_equal           time2, "Microseconds were <#{obj.datetime.usec}> vs <233000>"
+      obj.reload
+      obj.datetime.must_equal           time2, "Microseconds were <#{obj.datetime.usec}> vs <233000>"
+      obj.must_equal obj.class.where(datetime: time).first
+      obj.must_equal obj.class.where(datetime: time2).first
+      # Set and find nil.
+      obj.datetime = nil
+      obj.datetime.must_be_nil
       obj.save!
-      obj.reload.datetime.must_equal    Time.utc(2010, 01, 01, 12, 34, 56, 233000), "Microseconds were <#{obj.reload.datetime.usec}> vs <233000>"
+      obj.datetime.must_be_nil
+      obj.must_equal obj.class.where(datetime: nil).first
     end
 
     it 'datetime2' do
       skip 'datetime2 not supported in this protocal version' unless connection_dblib_73?
       col = column('datetime2_7')
       col.sql_type.must_equal           'datetime2(7)'
+      col.type.must_equal               :datetime
       col.null.must_equal               true
-      col.default.must_equal            Time.utc(9999, 12, 31, 23, 59, 59, Rational(999999900, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <999999900>"
-      obj.datetime2_7.must_equal        Time.utc(9999, 12, 31, 23, 59, 59, Rational(999999900, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <999999900>"
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      time = Time.utc 9999, 12, 31, 23, 59, 59, Rational(999999900, 1000)
+      col.default.must_equal            time, "Nanoseconds were <#{col.default.nsec}> vs <999999900>"
+      obj.datetime2_7.must_equal        time, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <999999900>"
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::DateTime2
-      type.type.must_equal              :datetime2
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         7
-      type.scale.must_equal             nil
+      type.scale.must_be_nil
+      obj.save!
+      obj.must_equal obj.class.where(datetime2_7: time).first
       # Can save 100 nanosecond precisoins and return again.
-      obj.datetime2_7 = Time.utc(9999, 12, 31, 23, 59, 59, Rational(123456755, 1000))
-      obj.datetime2_7.must_equal           Time.utc(9999, 12, 31, 23, 59, 59, Rational(123456800, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
+      time  = Time.utc 9999, 12, 31, 23, 59, 59, Rational(123456755, 1000)
+      time2 = Time.utc 9999, 12, 31, 23, 59, 59, Rational(123456800, 1000)
+      obj.datetime2_7 = time
+      obj.datetime2_7.must_equal           time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
       obj.save!
-      obj.reload.datetime2_7.must_equal    Time.utc(9999, 12, 31, 23, 59, 59, Rational(123456800, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
+      obj.datetime2_7.must_equal           time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
+      obj.reload
+      obj.datetime2_7.must_equal           time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
+      obj.must_equal obj.class.where(datetime2_7: time).first
+      obj.must_equal obj.class.where(datetime2_7: time2).first
       # Can save small fraction nanosecond precisoins and return again.
-      obj.datetime2_7 = Time.utc(2008, 6, 21, 13, 30, 0, Rational(15020, 1000))
-      obj.datetime2_7.must_equal           Time.utc(2008, 6, 21, 13, 30, 0, Rational(15000, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <15000>"
+      time  = Time.utc 2008, 6, 21, 13, 30, 0, Rational(15020, 1000)
+      time2 = Time.utc 2008, 6, 21, 13, 30, 0, Rational(15000, 1000)
+      obj.datetime2_7 = time
+      obj.datetime2_7.must_equal           time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <15000>"
       obj.save!
-      obj.reload.datetime2_7.must_equal    Time.utc(2008, 6, 21, 13, 30, 0, Rational(15000, 1000)), "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <15000>"
-      # With other precisions.
+      obj.reload.datetime2_7.must_equal    time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <15000>"
+      obj.must_equal obj.class.where(datetime2_7: time).first
+      obj.must_equal obj.class.where(datetime2_7: time2).first
+      # datetime2_3
       time = Time.utc 9999, 12, 31, 23, 59, 59, Rational(123456789, 1000)
       col = column('datetime2_3')
-      col.cast_type.precision.must_equal 3
+      connection.lookup_cast_type_from_column(col).precision.must_equal 3
       obj.datetime2_3 = time
       obj.datetime2_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetime2_3.nsec}> vs <123000000>"
       obj.save! ; obj.reload
       obj.datetime2_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetime2_3.nsec}> vs <123000000>"
+      obj.must_equal obj.class.where(datetime2_3: time).first
+      # datetime2_1
       col = column('datetime2_1')
-      col.cast_type.precision.must_equal 1
+      connection.lookup_cast_type_from_column(col).precision.must_equal 1
       obj.datetime2_1 = time
       obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
       obj.save! ; obj.reload
       obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
+      obj.must_equal obj.class.where(datetime2_1: time).first
+      # datetime2_0
       col = column('datetime2_0')
-      col.cast_type.precision.must_equal 0
+      connection.lookup_cast_type_from_column(col).precision.must_equal 0
       time = Time.utc 2016, 4, 19, 16, 45, 40, 771036
       obj.datetime2_0 = time
       obj.datetime2_0.must_equal time.change(nsec: 0), "Nanoseconds were <#{obj.datetime2_0.nsec}> vs <0>"
       obj.save! ; obj.reload
       obj.datetime2_0.must_equal time.change(nsec: 0), "Nanoseconds were <#{obj.datetime2_0.nsec}> vs <0>"
+      obj.must_equal obj.class.where(datetime2_0: time).first
     end
 
     it 'datetimeoffset' do
       skip 'datetimeoffset not supported in this protocal version' unless connection_dblib_73?
       col = column('datetimeoffset_7')
       col.sql_type.must_equal           'datetimeoffset(7)'
+      col.type.must_equal               :datetime
       col.null.must_equal               true
       col.default.must_equal            Time.new(1984, 01, 24, 04, 20, 00, -28800).change(nsec: 123456700), "Nanoseconds <#{col.default.nsec}> vs <123456700>"
       obj.datetimeoffset_7.must_equal   Time.new(1984, 01, 24, 04, 20, 00, -28800).change(nsec: 123456700), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <999999900>"
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::DateTimeOffset
-      type.type.must_equal              :datetimeoffset
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         7
-      type.scale.must_equal             nil
+      type.scale.must_be_nil
       # Can save 100 nanosecond precisoins and return again.
-      obj.datetimeoffset_7 = Time.new(2010, 01, 01, 12, 34, 56, +18000).change(nsec: 123456755)
-      obj.datetimeoffset_7.must_equal   Time.new(2010, 01, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
-      obj.save! ; obj.reload
-      obj.datetimeoffset_7.must_equal   Time.new(2010, 01, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      obj.datetimeoffset_7 = Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456755)
+      obj.datetimeoffset_7.must_equal   Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      obj.save!
+      obj.datetimeoffset_7.must_equal   Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
+      obj.reload
+      obj.datetimeoffset_7.must_equal   Time.new(2010, 04, 01, 12, 34, 56, +18000).change(nsec: 123456800), "Nanoseconds were <#{obj.datetimeoffset_7.nsec}> vs <123456800>"
       # With other precisions.
       time = ActiveSupport::TimeZone['America/Los_Angeles'].local 2010, 12, 31, 23, 59, 59, Rational(123456755, 1000)
       col = column('datetimeoffset_3')
-      col.cast_type.precision.must_equal 3
+      connection.lookup_cast_type_from_column(col).precision.must_equal 3
       obj.datetimeoffset_3 = time
       obj.datetimeoffset_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
       # TODO: FreeTDS date bug fixed: https://github.com/FreeTDS/freetds/issues/44
-      return
       obj.save! ; obj.reload
       obj.datetimeoffset_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
       col = column('datetime2_1')
-      col.cast_type.precision.must_equal 1
+      connection.lookup_cast_type_from_column(col).precision.must_equal 1
       obj.datetime2_1 = time
       obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
       obj.save! ; obj.reload
@@ -423,38 +454,38 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'smalldatetime' do
       col = column('smalldatetime')
       col.sql_type.must_equal           'smalldatetime'
+      col.type.must_equal               :smalldatetime
       col.null.must_equal               true
       col.default.must_equal            Time.utc(1901, 01, 01, 15, 45, 00, 000)
       obj.smalldatetime.must_equal      Time.utc(1901, 01, 01, 15, 45, 00, 000)
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::SmallDateTime
-      type.type.must_equal              :smalldatetime
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Will remove fractional seconds and return again.
       obj.smalldatetime = Time.utc(2078, 06, 05, 4, 20, 00, 3000)
-      obj.smalldatetime.must_equal          Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.smalldatetime.usec}> vs <0>"
+      obj.smalldatetime.must_equal      Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.smalldatetime.usec}> vs <0>"
       obj.save!
-      obj.reload.smalldatetime.must_equal   Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
+      obj.smalldatetime.must_equal      Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
+      obj.reload
+      obj.smalldatetime.must_equal      Time.utc(2078, 06, 05, 4, 20, 00, 0), "Microseconds were <#{obj.reload.smalldatetime.usec}> vs <0>"
     end
 
     it 'time(7)' do
       skip 'time() not supported in this protocal version' unless connection_dblib_73?
       col = column('time_7')
       col.sql_type.must_equal           'time(7)'
+      col.type.must_equal               :time
       col.null.must_equal               true
       col.default.must_equal            Time.utc(1900, 01, 01, 04, 20, 00, Rational(288321500, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <288321500>"
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Time
-      type.type.must_equal              :time
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         7
-      type.scale.must_equal             nil
+      type.scale.must_be_nil
       # Time's #usec precision (low micro)
       obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 300)
       obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
@@ -478,16 +509,15 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
       skip 'time() not supported in this protocal version' unless connection_dblib_73?
       col = column('time_2')
       col.sql_type.must_equal           'time(2)'
+      col.type.must_equal               :time
       col.null.must_equal               true
-      col.default.must_equal            nil
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default.must_be_nil
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Time
-      type.type.must_equal              :time
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
+      type.limit.must_be_nil
       type.precision.must_equal         2
-      type.scale.must_equal             nil
+      type.scale.must_be_nil
       # Always uses TinyTDS/Windows 2000-01-01 convention too.
       obj.time_2 = Time.utc(2015, 01, 10, 15, 45, 00, 0)
       obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0)
@@ -510,17 +540,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'char(10)' do
       col = column('char_10')
       col.sql_type.must_equal           'char(10)'
+      col.type.must_equal               :char
       col.null.must_equal               true
       col.default.must_equal            '1234567890'
       obj.char_10.must_equal            '1234567890'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Char
-      type.type.must_equal              :char
-      type.wont_be                      :number?
       type.limit.must_equal             10
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       obj.char_10 = '012345'
       obj.char_10.strip.must_equal         '012345'
@@ -531,17 +560,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'varchar(50)' do
       col = column('varchar_50')
       col.sql_type.must_equal           'varchar(50)'
+      col.type.must_equal               :varchar
       col.null.must_equal               true
       col.default.must_equal            'test varchar_50'
       obj.varchar_50.must_equal         'test varchar_50'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Varchar
-      type.type.must_equal              :varchar
-      type.wont_be                      :number?
       type.limit.must_equal             50
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :varchar_50, 'Hello World'
     end
@@ -549,17 +577,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'varchar(max)' do
       col = column('varchar_max')
       col.sql_type.must_equal           'varchar(max)'
+      col.type.must_equal               :varchar_max
       col.null.must_equal               true
       col.default.must_equal            'test varchar_max'
       obj.varchar_max.must_equal        'test varchar_max'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::VarcharMax
-      type.type.must_equal              :varchar_max
-      type.wont_be                      :number?
       type.limit.must_equal             2_147_483_647
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :varchar_max, 'Hello World'
     end
@@ -567,17 +594,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'text' do
       col = column('text')
       col.sql_type.must_equal           'text'
+      col.type.must_equal               :text_basic
       col.null.must_equal               true
       col.default.must_equal            'test text'
       obj.text.must_equal               'test text'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Text
-      type.type.must_equal              :text_basic
-      type.wont_be                      :number?
       type.limit.must_equal             2_147_483_647
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :text, 'Hello World'
     end
@@ -587,17 +613,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'nchar(10)' do
       col = column('nchar_10')
       col.sql_type.must_equal           'nchar(10)'
+      col.type.must_equal               :nchar
       col.null.must_equal               true
       col.default.must_equal            '12345678åå'
       obj.nchar_10.must_equal           '12345678åå'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::UnicodeChar
-      type.type.must_equal              :nchar
-      type.wont_be                      :number?
       type.limit.must_equal             10
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       obj.nchar_10 = "五六"
       obj.nchar_10.strip.must_equal         "五六"
@@ -608,17 +633,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'nvarchar(50)' do
       col = column('nvarchar_50')
       col.sql_type.must_equal           'nvarchar(50)'
+      col.type.must_equal               :string
       col.null.must_equal               true
       col.default.must_equal            'test nvarchar_50 åå'
       obj.nvarchar_50.must_equal        'test nvarchar_50 åå'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::UnicodeVarchar
-      type.type.must_equal              :string
-      type.wont_be                      :number?
       type.limit.must_equal             50
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :nvarchar_50, "一二34五六"
     end
@@ -626,17 +650,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'nvarchar(max)' do
       col = column('nvarchar_max')
       col.sql_type.must_equal           'nvarchar(max)'
+      col.type.must_equal               :text
       col.null.must_equal               true
       col.default.must_equal            'test nvarchar_max åå'
       obj.nvarchar_max.must_equal       'test nvarchar_max åå'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::UnicodeVarcharMax
-      type.type.must_equal              :text
-      type.wont_be                      :number?
       type.limit.must_equal             2_147_483_647
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :nvarchar_max, "一二34五六"
     end
@@ -644,17 +667,16 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'ntext' do
       col = column('ntext')
       col.sql_type.must_equal           'ntext'
+      col.type.must_equal               :ntext
       col.null.must_equal               true
       col.default.must_equal            'test ntext åå'
       obj.ntext.must_equal              'test ntext åå'
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::UnicodeText
-      type.type.must_equal              :ntext
-      type.wont_be                      :number?
       type.limit.must_equal             2_147_483_647
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :ntext, "一二34五六"
     end
@@ -667,16 +689,15 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'binary(49)' do
       col = column('binary_49')
       col.sql_type.must_equal           'binary(49)'
+      col.type.must_equal               :binary_basic
       col.null.must_equal               true
-      col.default.must_equal            nil
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default.must_be_nil
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Binary
-      type.type.must_equal              :binary_basic
-      type.wont_be                      :number?
       type.limit.must_equal             49
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       binary_data.encoding.must_equal Encoding::BINARY
       binary_data.length.must_equal 49
@@ -689,16 +710,15 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'varbinary(49)' do
       col = column('varbinary_49')
       col.sql_type.must_equal           'varbinary(49)'
+      col.type.must_equal               :varbinary
       col.null.must_equal               true
-      col.default.must_equal            nil
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default.must_be_nil
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Varbinary
-      type.type.must_equal              :varbinary
-      type.wont_be                      :number?
       type.limit.must_equal             49
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       binary_data_20 = binary_data.to(20)
       binary_data_20.encoding.must_equal Encoding::BINARY
@@ -711,16 +731,15 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'varbinary(max)' do
       col = column('varbinary_max')
       col.sql_type.must_equal           'varbinary(max)'
+      col.type.must_equal               :binary
       col.null.must_equal               true
-      col.default.must_equal            nil
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default.must_be_nil
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::VarbinaryMax
-      type.type.must_equal              :binary
-      type.wont_be                      :number?
       type.limit.must_equal             2_147_483_647
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       binary_data.encoding.must_equal Encoding::BINARY
       assert_obj_set_and_save :varbinary_max, binary_data
@@ -731,19 +750,18 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'uniqueidentifier' do
       col = column('uniqueidentifier')
       col.sql_type.must_equal           'uniqueidentifier'
+      col.type.must_equal               :uuid
       col.null.must_equal               true
-      col.default.must_equal            nil
+      col.default.must_be_nil
       col.default_function.must_equal   'newid()'
-      type = col.cast_type
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Uuid
-      type.type.must_equal              :uuid
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic set and save.
       obj.uniqueidentifier = "this will not qualify as valid"
-      obj.uniqueidentifier.must_equal   nil
+      obj.uniqueidentifier.must_be_nil
       obj.save! ; obj.reload
       obj.uniqueidentifier.must_match   Type::Uuid::ACCEPTABLE_UUID
       obj.uniqueidentifier = "6F9619FF-8B86-D011-B42D-00C04FC964FF"
@@ -755,18 +773,17 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'timestamp' do
       col = column('timestamp')
       col.sql_type.must_equal           'timestamp'
+      col.type.must_equal               :ss_timestamp
       col.null.must_equal               true
-      col.default.must_equal            nil
-      col.default_function.must_equal   nil
-      type = col.cast_type
+      col.default.must_be_nil
+      col.default_function.must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
       type.must_be_instance_of          Type::Timestamp
-      type.type.must_equal              :ss_timestamp
-      type.wont_be                      :number?
-      type.limit.must_equal             nil
-      type.precision.must_equal         nil
-      type.scale.must_equal             nil
+      type.limit.must_be_nil
+      type.precision.must_be_nil
+      type.scale.must_be_nil
       # Basic read.
-      obj.timestamp.must_equal   nil
+      obj.timestamp.must_be_nil
       obj.save! ; obj.reload
       obj.timestamp.must_match   %r|\000|
       obj.timestamp