activerecord-sqlserver-adapter 5.2.0 → 5.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a148546b3f7d4e6734c8c8a7d834c242a7e1cec5344601d527f0c567cd6ad2e1
-  data.tar.gz: 261bd21097b324059eb205960c73c1eb3f1c8d4cb9a6da7c91876d64d33f8381
+  metadata.gz: 5c31b843cb8193ccc2c2777a80e658c3b7675c3ea5387f78f3b4b1316b96dd00
+  data.tar.gz: ab77e8f296d0eb35877a34f5a0d31fa1da51f69e09bb852db6b97ced8c133f04
 SHA512:
-  metadata.gz: ed85ad0fb65a3e32312c10db899037786549abe289e5cfeb519634d0a4e090a39c4c193b89e8285ba3d3a786c68e4c317440e94e217cb256a109c68b8497fb3d
-  data.tar.gz: 49f1e9767c1c411e9a86ff8678bc5ac6470d31bead60dba3ca6039fd2fb2a8435ed4c1dda6e59b9745ba4c32ea46166c28907cfce84614aaa64aae080214db5b
+  metadata.gz: 11d4df1451f076a4877e09698a9696355f16d2b958ef0fb19f353217211c0871645736c40ab2300bfba7f6e7fcac994b918de927dfef40db66cca2500dd43b5a
+  data.tar.gz: cecaad6271fb78bb6ace828f7e16bd67007c0ae5e55f6759c49c710f5cb02dbe361f9a06bf9159599b36cf1c6325c0e631670cf30dca519447145d0bee62823e

data/.travis.yml

@@ -17,9 +17,9 @@ matrix:
   include:
     - name: 2.3.8
       env: TARGET_VERSION=2.3.8
-    - name: 2.4.5
-      env: TARGET_VERSION=2.4.5
-    - name: 2.5.3
-      env: TARGET_VERSION=2.5.3
-    - name: 2.6.0
-      env: TARGET_VERSION=2.6.0
+    - name: 2.4.6
+      env: TARGET_VERSION=2.4.6
+    - name: 2.5.5
+      env: TARGET_VERSION=2.5.5
+    - name: 2.6.3
+      env: TARGET_VERSION=2.6.3

data/CHANGELOG.md

@@ -1,5 +1,20 @@
+## v5.2.1
+
+#### Fixed
+
+- #691 Fix constraints bug
+- #700 SET SINGLE_USER before dropping the database
+- #733 Calculate should not remove ordering for MSSQL
+- #735 Order by selected items when using distinct exists
+- #737 Use default precision for 'time' column type
+- #744 Adapter does not use prepared statement cache
+- #743 Set default time precision when registering time type
+- #745 Quoted table names containing square brackets need to be regex escaped
+
 ## v5.2.0
 
+#### Fixed
+
 - #686 sql_for_insert set table name in case when pk is not nil
 
 ## v5.2.0.rc2

data/Dockerfile

@@ -1,4 +1,4 @@
-ARG TARGET_VERSION=2.5.3
+ARG TARGET_VERSION=2.6.3
 
 FROM wpolicarpo/activerecord-sqlserver-adapter:${TARGET_VERSION}
 

data/README.md

@@ -1,17 +1,10 @@
 # ActiveRecord SQL Server Adapter. For SQL Server 2012 And Higher.
 
 * [![TravisCI](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter.svg?branch=master)](https://travis-ci.org/rails-sqlserver/activerecord-sqlserver-adapter) - TravisCI
-* [![CircleCI](https://circleci.com/gh/rails-sqlserver/activerecord-sqlserver-adapter/tree/master.svg?style=svg)](https://circleci.com/gh/rails-sqlserver/activerecord-sqlserver-adapter/tree/master) - CircleCI
 * [![Build Status](https://ci.appveyor.com/api/projects/status/mtgbx8f57vr7k2qa/branch/master?svg=true)](https://ci.appveyor.com/project/rails-sqlserver/activerecord-sqlserver-adapter/branch/master) - Appveyor
 * [![Gem Version](http://img.shields.io/gem/v/activerecord-sqlserver-adapter.svg)](https://rubygems.org/gems/activerecord-sqlserver-adapter) - Gem Version
-* [![Dependency Status](https://dependencyci.com/github/rails-sqlserver/activerecord-sqlserver-adapter/badge)](https://dependencyci.com/github/rails-sqlserver/activerecord-sqlserver-adapter) - Dependency Status
 * [![Gitter chat](https://img.shields.io/badge/%E2%8A%AA%20GITTER%20-JOIN%20CHAT%20%E2%86%92-brightgreen.svg?style=flat)](https://gitter.im/rails-sqlserver/activerecord-sqlserver-adapter) - Community
 
-## Supporting TinyTDS/Adapter
-
-Both TinyTDS and the Rails SQL Server Adapter are MIT-licensed open source projects. Its ongoing development is made possible thanks to the support by these awesome [backers](https://github.com/rails-sqlserver/tiny_tds/blob/master/BACKERS.md). If you'd like to join them, check out our [Patreon Campaign](https://www.patreon.com/metaskills).
-
-
 ## About The Adapter
 
 The SQL Server adapter for ActiveRecord v5.2 using SQL Server 2012 or higher.

data/VERSION

@@ -1 +1 @@
-5.2.0
+5.2.1

data/lib/active_record/connection_adapters/sqlserver/core_ext/calculations.rb

@@ -6,6 +6,25 @@ module ActiveRecord
     module SQLServer
       module CoreExt
         module Calculations
+
+          # Same as original except we don't perform PostgreSQL hack that removes ordering.
+          def calculate(operation, column_name)
+            if has_include?(column_name)
+              relation = apply_join_dependency
+
+              if operation.to_s.downcase == "count"
+                unless distinct_value || distinct_select?(column_name || select_for_count)
+                  relation.distinct!
+                  relation.select_values = [ klass.primary_key || table[Arel.star] ]
+                end
+              end
+
+              relation.calculate(operation, column_name)
+            else
+              perform_calculation(operation, column_name)
+            end
+          end
+
           private
 
           def build_count_subquery(relation, column_name, distinct)

data/lib/active_record/connection_adapters/sqlserver/core_ext/finder_methods.rb

@@ -0,0 +1,43 @@
+require 'active_record/relation'
+require 'active_record/version'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module FinderMethods
+
+          private
+
+          # Same as original except we order by values in distinct select if present.
+          def construct_relation_for_exists(conditions)
+            if distinct_value && offset_value
+              relation = limit!(1)
+
+              if select_values.present?
+                relation = relation.order(*select_values)
+              else
+                relation = relation.except(:order)
+              end
+            else
+              relation = except(:select, :distinct, :order)._select!(::ActiveRecord::FinderMethods::ONE_AS_ONE).limit!(1)
+            end
+
+            case conditions
+            when Array, Hash
+              relation.where!(conditions) unless conditions.empty?
+            else
+              relation.where!(primary_key => conditions) unless conditions == :none
+            end
+
+            relation
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Relation.include(ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::FinderMethods)
+end

data/lib/active_record/connection_adapters/sqlserver/core_ext/query_methods.rb

@@ -0,0 +1,26 @@
+require 'active_record/relation'
+require 'active_record/version'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLServer
+      module CoreExt
+        module QueryMethods
+
+          private
+
+          # Copy of original from Rails master. This patch can be removed when adapter supports Rails 6.
+          def table_name_matches?(from)
+            table_name = Regexp.escape(table.name)
+            quoted_table_name = Regexp.escape(connection.quote_table_name(table.name))
+            /(?:\A|(?<!FROM)\s)(?:\b#{table_name}\b|#{quoted_table_name})(?!\.)/i.match?(from.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Relation.include(ActiveRecord::ConnectionAdapters::SQLServer::CoreExt::QueryMethods)
+end

data/lib/active_record/connection_adapters/sqlserver/database_tasks.rb

@@ -12,6 +12,7 @@ module ActiveRecord
 
         def drop_database(database)
           name = SQLServer::Utils.extract_identifiers(database)
+          do_execute "ALTER DATABASE #{name} SET SINGLE_USER WITH ROLLBACK IMMEDIATE"
           do_execute "DROP DATABASE #{name}"
         end
 

data/lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -141,7 +141,13 @@ module ActiveRecord
           sql_commands = []
           indexes = []
           column_object = schema_cache.columns(table_name).find { |c| c.name.to_s == column_name.to_s }
-          if options_include_default?(options) || (column_object && column_object.type != type.to_sym)
+          without_constraints = options.key?(:default) || options.key?(:limit)
+          default = if !options.key?(:default) && column_object
+            column_object.default
+          else
+            options[:default]
+          end
+          if without_constraints || (column_object && column_object.type != type.to_sym)
             remove_default_constraint(table_name, column_name)
             indexes = indexes(table_name).select { |index| index.columns.include?(column_name.to_s) }
             remove_indexes(table_name, column_name)
@@ -149,10 +155,9 @@ module ActiveRecord
           sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
           sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, limit: options[:limit], precision: options[:precision], scale: options[:scale])}"
           sql_commands.last << ' NOT NULL' if !options[:null].nil? && options[:null] == false
-          if options.key?(:default) && default_constraint_name(table_name, column_name).present?
-            change_column_default(table_name, column_name, options[:default])
-          elsif options_include_default?(options)
-            sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{quote_default_expression(options[:default], column_object)} FOR #{quote_column_name(column_name)}"
+          if without_constraints
+            default = quote_default_expression(default, column_object || column_for(table_name, column_name))
+            sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{default} FOR #{quote_column_name(column_name)}"
           end
           # Add any removed indexes back
           indexes.each do |index|

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -7,6 +7,8 @@ require 'active_record/connection_adapters/sqlserver/core_ext/calculations'
 require 'active_record/connection_adapters/sqlserver/core_ext/explain'
 require 'active_record/connection_adapters/sqlserver/core_ext/explain_subscriber'
 require 'active_record/connection_adapters/sqlserver/core_ext/attribute_methods'
+require 'active_record/connection_adapters/sqlserver/core_ext/finder_methods'
+require 'active_record/connection_adapters/sqlserver/core_ext/query_methods'
 require 'active_record/connection_adapters/sqlserver/version'
 require 'active_record/connection_adapters/sqlserver/type'
 require 'active_record/connection_adapters/sqlserver/database_limits'
@@ -40,6 +42,9 @@ module ActiveRecord
 
       ADAPTER_NAME = 'SQLServer'.freeze
 
+      # Default precision for 'time' (See https://docs.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql)
+      DEFAULT_TIME_PRECISION = 7
+
       attr_reader :spid
 
       cattr_accessor :cs_equality_operator, instance_accessor: false
@@ -296,8 +301,7 @@ module ActiveRecord
         end
         m.register_type              'smalldatetime',     SQLServer::Type::SmallDateTime.new
         m.register_type              %r{\Atime}i do |sql_type|
-          scale = extract_scale(sql_type)
-          precision = extract_precision(sql_type)
+          precision = extract_precision(sql_type) || DEFAULT_TIME_PRECISION
           SQLServer::Type::Time.new precision: precision
         end
         # Character Strings

data/test/cases/adapter_test_sqlserver.rb

@@ -15,14 +15,14 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
   it 'has basic and non-senstive information in the adpaters inspect method' do
     string = connection.inspect
-    string.must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
-    string.must_match %r{version\: \d.\d}
-    string.must_match %r{mode: dblib}
-    string.must_match %r{azure: (true|false)}
-    string.wont_match %r{host}
-    string.wont_match %r{password}
-    string.wont_match %r{username}
-    string.wont_match %r{port}
+    _(string).must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
+    _(string).must_match %r{version\: \d.\d}
+    _(string).must_match %r{mode: dblib}
+    _(string).must_match %r{azure: (true|false)}
+    _(string).wont_match %r{host}
+    _(string).wont_match %r{password}
+    _(string).wont_match %r{username}
+    _(string).wont_match %r{port}
   end
 
   it 'has a 128 max #table_alias_length' do
@@ -161,7 +161,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'return an empty array when calling #identity_columns for a table_name with no identity' do
-      connection.send(:identity_columns, Subscriber.table_name).must_equal []
+      _(connection.send(:identity_columns, Subscriber.table_name)).must_equal []
     end
 
   end
@@ -303,7 +303,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'find SSTestCustomersView table name' do
-      connection.views.must_include 'sst_customers_view'
+      _(connection.views).must_include 'sst_customers_view'
     end
 
     it 'work with dynamic finders' do
@@ -344,9 +344,9 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'find identity column' do
-      SSTestCustomersView.primary_key.must_equal 'id'
-      connection.primary_key(SSTestCustomersView.table_name).must_equal 'id'
-      SSTestCustomersView.columns_hash['id'].must_be :is_identity?
+      _(SSTestCustomersView.primary_key).must_equal 'id'
+      _(connection.primary_key(SSTestCustomersView.table_name)).must_equal 'id'
+      _(SSTestCustomersView.columns_hash['id']).must_be :is_identity?
     end
 
     it 'find default values' do
@@ -371,9 +371,9 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'find identity column' do
-      SSTestStringDefaultsView.primary_key.must_equal 'id'
-      connection.primary_key(SSTestStringDefaultsView.table_name).must_equal 'id'
-      SSTestStringDefaultsView.columns_hash['id'].must_be :is_identity?
+      _(SSTestStringDefaultsView.primary_key).must_equal 'id'
+      _(connection.primary_key(SSTestStringDefaultsView.table_name)).must_equal 'id'
+      _(SSTestStringDefaultsView.columns_hash['id']).must_be :is_identity?
     end
 
     it 'find default values' do
@@ -422,8 +422,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
 
   it 'in_memory_oltp' do
     if ENV['IN_MEMORY_OLTP'] && connection.supports_in_memory_oltp?
-      SSTMemory.primary_key.must_equal 'id'
-      SSTMemory.columns_hash['id'].must_be :is_identity?
+      _(SSTMemory.primary_key).must_equal 'id'
+      _(SSTMemory.columns_hash['id']).must_be :is_identity?
     else
       skip 'supports_in_memory_oltp? => false'
     end

data/test/cases/change_column_null_test_sqlserver.rb

@@ -24,19 +24,19 @@ class ChangeColumnNullTestSqlServer < ActiveRecord::TestCase
 
   describe '#change_column_null' do
     it 'does not change the column limit' do
-      name_column.limit.must_equal 15
+      _(name_column.limit).must_equal 15
     end
 
     it 'does not change the column default' do
-      code_column.default.must_equal 'n/a'
+      _(code_column.default).must_equal 'n/a'
     end
 
     it 'does not change the column precision' do
-      value_column.precision.must_equal 32
+      _(value_column.precision).must_equal 32
     end
 
     it 'does not change the column scale' do
-      value_column.scale.must_equal 8
+      _(value_column.scale).must_equal 8
     end
   end
 end

data/test/cases/coerced_tests.rb

@@ -145,8 +145,27 @@ end
 
 module ActiveRecord
   class BindParameterTest < ActiveRecord::TestCase
-    # Never finds `sql` since we use `EXEC sp_executesql` wrappers.
+    # Same as original coerced test except log is found using `EXEC sp_executesql` wrapper.
     coerce_tests! :test_binds_are_logged
+    def test_binds_are_logged_coerced
+      sub   = Arel::Nodes::BindParam.new(1)
+      binds = [Relation::QueryAttribute.new("id", 1, Type::Value.new)]
+      sql   = "select * from topics where id = #{sub.to_sql}"
+
+      @connection.exec_query(sql, "SQL", binds)
+
+      logged_sql = "EXEC sp_executesql N'#{sql}', N'#{sub.to_sql} int', #{sub.to_sql} = 1"
+      message = @subscriber.calls.find { |args| args[4][:sql] == logged_sql }
+
+      assert_equal binds, message[4][:binds]
+    end
+
+    # SQL Server adapter does not use a statement cache as query plans are already reused using `EXEC sp_executesql`.
+    coerce_tests! :test_statement_cache
+    coerce_tests! :test_statement_cache_with_query_cache
+    coerce_tests! :test_statement_cache_with_find_by
+    coerce_tests! :test_statement_cache_with_in_clause
+    coerce_tests! :test_statement_cache_with_sql_string_literal
   end
 end
 
@@ -192,14 +211,14 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_limit_is_kept_coerced
     queries = capture_sql_ss { Account.limit(1).count }
     assert_equal 1, queries.length
-    queries.first.must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1}
+    _(queries.first).must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1}
   end
 
   coerce_tests! :test_limit_with_offset_is_kept
   def test_limit_with_offset_is_kept_coerced
     queries = capture_sql_ss { Account.limit(1).offset(1).count }
     assert_equal 1, queries.length
-    queries.first.must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY.*@0 = 1, @1 = 1}
+    _(queries.first).must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY.*@0 = 1, @1 = 1}
   end
 
   # SQL Server needs an alias for the calculated column
@@ -265,7 +284,7 @@ module ActiveRecord
       def test_add_column_without_limit_coerced
         add_column :test_models, :description, :string, limit: nil
         TestModel.reset_column_information
-        TestModel.columns_hash["description"].limit.must_equal 4000
+        _(TestModel.columns_hash["description"].limit).must_equal 4000
       end
     end
   end
@@ -615,14 +634,14 @@ class PersistenceTest < ActiveRecord::TestCase
   coerce_tests! :test_update_all_doesnt_ignore_order
   def test_update_all_doesnt_ignore_order_coerced
     david, mary = authors(:david), authors(:mary)
-    david.id.must_equal 1
-    mary.id.must_equal 2
-    david.name.wont_equal mary.name
+    _(david.id).must_equal 1
+    _(mary.id).must_equal 2
+    _(david.name).wont_equal mary.name
     assert_sql(/UPDATE.*\(SELECT \[authors\].\[id\] FROM \[authors\].*ORDER BY \[authors\].\[id\]/i) do
       Author.where('[id] > 1').order(:id).update_all(name: 'Test')
     end
-    david.reload.name.must_equal 'David'
-    mary.reload.name.must_equal 'Test'
+    _(david.reload.name).must_equal 'David'
+    _(mary.reload.name).must_equal 'Test'
   end
 
   # We can not UPDATE identity columns.

data/test/cases/column_test_sqlserver.rb

@@ -18,9 +18,9 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     def column(name) ; SSTestDatatype.columns_hash[name] ; end
     def assert_obj_set_and_save(attribute, value)
       obj.send :"#{attribute}=", value
-      obj.send(attribute).must_equal value
+      _(obj.send(attribute)).must_equal value
       obj.save!
-      obj.reload.send(attribute).must_equal value
+      _(obj.reload.send(attribute)).must_equal value
     end
 
     # http://msdn.microsoft.com/en-us/library/ms187752.aspx
@@ -29,199 +29,199 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
 
     it 'int(4) PRIMARY KEY' do
       col = column('id')
-      col.sql_type.must_equal          'int(4)'
-      col.null.must_equal              false
+      _(col.sql_type).must_equal          'int(4)'
+      _(col.null).must_equal              false
     end
 
     it 'bigint(8)' do
       col = column('bigint')
-      col.sql_type.must_equal           'bigint(8)'
-      col.type.must_equal               :integer
-      col.null.must_equal               true
-      col.default.must_equal            42
-      obj.bigint.must_equal             42
-      col.default_function.must_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::BigInteger
-      type.limit.must_equal             8
+      _(col.sql_type).must_equal           'bigint(8)'
+      _(col.type).must_equal               :integer
+      _(col.null).must_equal               true
+      _(col.default).must_equal            42
+      _(obj.bigint).must_equal             42
+      _(col.default_function).must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::BigInteger
+      _(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
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Integer
-      type.limit.must_equal             4
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Integer
+      _(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
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::SmallInteger
-      type.limit.must_equal             2
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::SmallInteger
+      _(type.limit).must_equal             2
       assert_obj_set_and_save :smallint, -32_768
       assert_obj_set_and_save :smallint, 32_767
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::TinyInteger
-      type.limit.must_equal             1
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::TinyInteger
+      _(type.limit).must_equal             1
       assert_obj_set_and_save :tinyint, 0
       assert_obj_set_and_save :tinyint, 255
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Boolean
-      type.limit.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Boolean
+      _(type.limit).must_be_nil
       obj.bit = 0
-      obj.bit.must_equal false
+      _(obj.bit).must_equal false
       obj.save!
-      obj.reload.bit.must_equal false
+      _(obj.reload.bit).must_equal false
       obj.bit = '1'
-      obj.bit.must_equal true
+      _(obj.bit).must_equal true
       obj.save!
-      obj.reload.bit.must_equal true
+      _(obj.reload.bit).must_equal true
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Decimal
-      type.limit.must_be_nil
-      type.precision.must_equal         9
-      type.scale.must_equal             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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Decimal
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         9
+      _(type.scale).must_equal             2
       obj.decimal_9_2 = '1234567.8901'
-      obj.decimal_9_2.must_equal        BigDecimal('1234567.89')
+      _(obj.decimal_9_2).must_equal        BigDecimal('1234567.89')
       obj.save!
-      obj.reload.decimal_9_2.must_equal BigDecimal('1234567.89')
+      _(obj.reload.decimal_9_2).must_equal BigDecimal('1234567.89')
     end
 
     it 'decimal(16,4)' do
       col = column('decimal_16_4')
-      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_be_nil
+      _(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_be_nil
       type = connection.lookup_cast_type_from_column(col)
-      type.precision.must_equal         16
-      type.scale.must_equal             4
+      _(type.precision).must_equal         16
+      _(type.scale).must_equal             4
       obj.decimal_16_4 = '1234567.8901001'
-      obj.decimal_16_4.must_equal        BigDecimal('1234567.8901')
+      _(obj.decimal_16_4).must_equal        BigDecimal('1234567.8901')
       obj.save!
-      obj.reload.decimal_16_4.must_equal BigDecimal('1234567.8901')
+      _(obj.reload.decimal_16_4).must_equal BigDecimal('1234567.8901')
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Decimal
-      type.limit.must_be_nil
-      type.precision.must_equal         18
-      type.scale.must_equal             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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Decimal
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         18
+      _(type.scale).must_equal             0
       obj.numeric_18_0 = '192.1'
-      obj.numeric_18_0.must_equal        BigDecimal('192')
+      _(obj.numeric_18_0).must_equal        BigDecimal('192')
       obj.save!
-      obj.reload.numeric_18_0.must_equal BigDecimal('192')
+      _(obj.reload.numeric_18_0).must_equal BigDecimal('192')
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Decimal
-      type.limit.must_be_nil
-      type.precision.must_equal         36
-      type.scale.must_equal             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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Decimal
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         36
+      _(type.scale).must_equal             2
       obj.numeric_36_2 = '192.123'
-      obj.numeric_36_2.must_equal        BigDecimal('192.12')
+      _(obj.numeric_36_2).must_equal        BigDecimal('192.12')
       obj.save!
-      obj.reload.numeric_36_2.must_equal BigDecimal('192.12')
+      _(obj.reload.numeric_36_2).must_equal BigDecimal('192.12')
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Money
-      type.limit.must_be_nil
-      type.precision.must_equal         19
-      type.scale.must_equal             4
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Money
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         19
+      _(type.scale).must_equal             4
       obj.money = '922337203685477.58061'
-      obj.money.must_equal              BigDecimal('922337203685477.5806')
+      _(obj.money).must_equal              BigDecimal('922337203685477.5806')
       obj.save!
-      obj.reload.money.must_equal       BigDecimal('922337203685477.5806')
+      _(obj.reload.money).must_equal       BigDecimal('922337203685477.5806')
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::SmallMoney
-      type.limit.must_be_nil
-      type.precision.must_equal         10
-      type.scale.must_equal             4
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::SmallMoney
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         10
+      _(type.scale).must_equal             4
       obj.smallmoney = '214748.36461'
-      obj.smallmoney.must_equal        BigDecimal('214748.3646')
+      _(obj.smallmoney).must_equal        BigDecimal('214748.3646')
       obj.save!
-      obj.reload.smallmoney.must_equal BigDecimal('214748.3646')
+      _(obj.reload.smallmoney).must_equal BigDecimal('214748.3646')
     end
 
     # Approximate Numerics
@@ -230,386 +230,418 @@ 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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Float
-      type.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Float
+      _(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.float).must_equal        214748.36461
       obj.save!
-      obj.reload.float.must_equal 214748.36461
+      _(obj.reload.float).must_equal 214748.36461
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Real
-      type.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Real
+      _(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.real).must_be_close_to         214748.36461, 0.01
       obj.save!
-      obj.reload.real.must_be_close_to  214748.36461, 0.01
+      _(obj.reload.real).must_be_close_to  214748.36461, 0.01
     end
 
     # Date and Time
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Date
-      type.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Date
+      _(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.date).must_equal               Date.civil(0001, 4, 1)
       obj.save!
-      obj.date.must_equal               Date.civil(0001, 4, 1)
+      _(obj.date).must_equal               Date.civil(0001, 4, 1)
       obj.reload
-      obj.date.must_equal               Date.civil(0001, 4, 1)
+      _(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.date).must_equal               Date.civil(0001, 4, 1)
       obj.save!
-      obj.date.must_equal               Date.civil(0001, 4, 1)
+      _(obj.date).must_equal               Date.civil(0001, 4, 1)
       obj.reload
-      obj.date.must_equal               Date.civil(0001, 4, 1)
+      _(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.
       obj.date = Time.utc(2010, 4, 14, 12, 34, 56, 3000)
-      obj.date.must_equal               Date.civil(2010, 4, 14)
+      _(obj.date).must_equal               Date.civil(2010, 4, 14)
       obj.save!
-      obj.reload.date.must_equal        Date.civil(2010, 4, 14)
+      _(obj.reload.date).must_equal        Date.civil(2010, 4, 14)
     end
 
     it 'datetime' do
       col = column('datetime')
-      col.sql_type.must_equal           'datetime'
-      col.type.must_equal               :datetime
-      col.null.must_equal               true
+      _(col.sql_type).must_equal           'datetime'
+      _(col.type).must_equal               :datetime
+      _(col.null).must_equal               true
       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
+      _(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.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(type).must_be_instance_of          Type::DateTime
+      _(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
+      _(obj).must_equal obj.class.where(datetime: time).first
       # Can save to proper accuracy and return again.
       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.datetime).must_equal           time, "Microseconds were <#{obj.datetime.usec}> vs <3000>"
       obj.save!
-      obj.datetime.must_equal           time, "Microseconds were <#{obj.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
+      _(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.
       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.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.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
+      _(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.datetime).must_be_nil
       obj.save!
-      obj.datetime.must_be_nil
-      obj.must_equal obj.class.where(datetime: nil).first
+      _(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?
+      skip 'datetime2 not supported in this protocol 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.sql_type).must_equal           'datetime2(7)'
+      _(col.type).must_equal               :datetime
+      _(col.null).must_equal               true
       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
+      _(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.limit.must_be_nil
-      type.precision.must_equal         7
-      type.scale.must_be_nil
+      _(type).must_be_instance_of          Type::DateTime2
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         7
+      _(type.scale).must_be_nil
       obj.save!
-      obj.must_equal obj.class.where(datetime2_7: time).first
+      _(obj).must_equal obj.class.where(datetime2_7: time).first
       # Can save 100 nanosecond precisoins and return again.
       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.datetime2_7).must_equal           time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <123456800>"
       obj.save!
-      obj.datetime2_7.must_equal           time2, "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
+      _(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.
       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.datetime2_7).must_equal           time2, "Nanoseconds were <#{obj.datetime2_7.nsec}> vs <15000>"
       obj.save!
-      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
+      _(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')
-      connection.lookup_cast_type_from_column(col).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.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
+      _(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')
-      connection.lookup_cast_type_from_column(col).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.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
+      _(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')
-      connection.lookup_cast_type_from_column(col).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.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
+      _(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?
+      skip 'datetimeoffset not supported in this protocol version' unless connection_dblib_73?
       col = column('datetimeoffset_7')
-      col.sql_type.must_equal           'datetimeoffset(7)'
-      col.type.must_equal               :datetimeoffset
-      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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::DateTimeOffset
-      type.limit.must_be_nil
-      type.precision.must_equal         7
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'datetimeoffset(7)'
+      _(col.type).must_equal               :datetimeoffset
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::DateTimeOffset
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         7
+      _(type.scale).must_be_nil
       # Can save 100 nanosecond precisoins and return again.
       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.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.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>"
+      _(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>"
       # Maintains the timezone
       time = ActiveSupport::TimeZone['America/Los_Angeles'].local 2010, 12, 31, 23, 59, 59, Rational(123456800, 1000)
       obj.datetimeoffset_7 = time
-      obj.datetimeoffset_7.must_equal time
+      _(obj.datetimeoffset_7).must_equal time
       obj.save!
-      obj.datetimeoffset_7.must_equal time
-      obj.reload.datetimeoffset_7.must_equal time
+      _(obj.datetimeoffset_7).must_equal time
+      _(obj.reload.datetimeoffset_7).must_equal time
       # With other precisions.
       time = ActiveSupport::TimeZone['America/Los_Angeles'].local 2010, 12, 31, 23, 59, 59, Rational(123456755, 1000)
       col = column('datetimeoffset_3')
-      connection.lookup_cast_type_from_column(col).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>"
+      _(obj.datetimeoffset_3).must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
       obj.save!
-      obj.datetimeoffset_3.must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
+      _(obj.datetimeoffset_3).must_equal time.change(nsec: 123000000), "Nanoseconds were <#{obj.datetimeoffset_3.nsec}> vs <123000000>"
       col = column('datetime2_1')
-      connection.lookup_cast_type_from_column(col).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.datetime2_1).must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
       obj.save!
-      obj.datetime2_1.must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
+      _(obj.datetime2_1).must_equal time.change(nsec: 100000000), "Nanoseconds were <#{obj.datetime2_1.nsec}> vs <100000000>"
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::SmallDateTime
-      type.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::SmallDateTime
+      _(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.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>"
+      _(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?
+      skip 'time() not supported in this protocol 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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Time
-      type.limit.must_be_nil
-      type.precision.must_equal         7
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Time
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         7
+      _(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>"
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
       obj.save! ; obj.reload
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_7.usec}> vs <0>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_7.nsec}> vs <300>"
       # Time's #usec precision (high micro)
       obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, 234567)
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
       obj.save! ; obj.reload
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_7.usec}> vs <234567>"
       # Time's #usec precision (high nano rounded)
       obj.time_7 = Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321545, 1000))
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
       obj.save! ; obj.reload
-      obj.time_7.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
+      _(obj.time_7).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_7.nsec}> vs <288321500>"
     end
 
     it 'time(2)' do
-      skip 'time() not supported in this protocal version' unless connection_dblib_73?
+      skip 'time() not supported in this protocol 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_be_nil
-      col.default_function.must_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Time
-      type.limit.must_be_nil
-      type.precision.must_equal         2
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'time(2)'
+      _(col.type).must_equal               :time
+      _(col.null).must_equal               true
+      _(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.limit).must_be_nil
+      _(type.precision).must_equal         2
+      _(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)
+      _(obj.time_2).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0)
       obj.save! ; obj.reload
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0)
+      _(obj.time_2).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0)
       # Time's #usec precision (barely in 2 precision equal to 0.03 seconds)
       obj.time_2 = Time.utc(2000, 01, 01, 15, 45, 00, 30000)
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
+      _(obj.time_2).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
       obj.save! ; obj.reload
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
+      _(obj.time_2).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 30000), "Microseconds were <#{obj.time_2.usec}> vs <30000>"
       # Time's #usec precision (below 2 precision)
       obj.time_2 = Time.utc(2000, 01, 01, 15, 45, 00, 4000)
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
+      _(obj.time_2).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
       obj.save! ; obj.reload
-      obj.time_2.must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
+      _(obj.time_2).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 0), "Microseconds were <#{obj.time_2.usec}> vs <0>"
+    end
+
+    it 'time using default precision' do
+      skip 'time() not supported in this protocol version' unless connection_dblib_73?
+      col = column('time_default')
+      _(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, 15, 03, 42, Rational(62197800, 1000)), "Nanoseconds were <#{col.default.nsec}> vs <62197800>"
+      _(col.default_function).must_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Time
+      _(type.limit).must_be_nil
+      _(type.precision).must_equal         7
+      _(type.scale).must_be_nil
+      # Time's #usec precision (low micro)
+      obj.time_default = Time.utc(2000, 01, 01, 15, 45, 00, 300)
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_default.usec}> vs <0>"
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_default.nsec}> vs <300>"
+      obj.save! ; obj.reload
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Microseconds were <#{obj.time_default.usec}> vs <0>"
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 300), "Nanoseconds were <#{obj.time_default.nsec}> vs <300>"
+      # Time's #usec precision (high micro)
+      obj.time_default = Time.utc(2000, 01, 01, 15, 45, 00, 234567)
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_default.usec}> vs <234567>"
+      obj.save! ; obj.reload
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, 234567), "Microseconds were <#{obj.time_default.usec}> vs <234567>"
+      # Time's #usec precision (high nano rounded)
+      obj.time_default = Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321545, 1000))
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_default.nsec}> vs <288321500>"
+      obj.save! ; obj.reload
+      _(obj.time_default).must_equal             Time.utc(2000, 01, 01, 15, 45, 00, Rational(288321500, 1000)), "Nanoseconds were <#{obj.time_default.nsec}> vs <288321500>"
     end
 
     # Character Strings
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Char
-      type.limit.must_equal             10
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Char
+      _(type.limit).must_equal             10
+      _(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'
+      _(obj.char_10.strip).must_equal         '012345'
       obj.save!
-      obj.reload.char_10.strip.must_equal  '012345'
+      _(obj.reload.char_10.strip).must_equal  '012345'
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Varchar
-      type.limit.must_equal             50
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Varchar
+      _(type.limit).must_equal             50
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :varchar_50, 'Hello World'
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::VarcharMax
-      type.limit.must_equal             2_147_483_647
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::VarcharMax
+      _(type.limit).must_equal             2_147_483_647
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :varchar_max, 'Hello World'
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Text
-      type.limit.must_equal             2_147_483_647
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Text
+      _(type.limit).must_equal             2_147_483_647
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :text, 'Hello World'
     end
@@ -618,71 +650,71 @@ 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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::UnicodeChar
-      type.limit.must_equal             10
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::UnicodeChar
+      _(type.limit).must_equal             10
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       obj.nchar_10 = "五六"
-      obj.nchar_10.strip.must_equal         "五六"
+      _(obj.nchar_10.strip).must_equal         "五六"
       obj.save!
-      obj.reload.nchar_10.strip.must_equal  "五六"
+      _(obj.reload.nchar_10.strip).must_equal  "五六"
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::UnicodeVarchar
-      type.limit.must_equal             50
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::UnicodeVarchar
+      _(type.limit).must_equal             50
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :nvarchar_50, "一二34五六"
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::UnicodeVarcharMax
-      type.limit.must_equal             2_147_483_647
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::UnicodeVarcharMax
+      _(type.limit).must_equal             2_147_483_647
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :nvarchar_max, "一二34五六"
     end
 
     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_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::UnicodeText
-      type.limit.must_equal             2_147_483_647
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(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_be_nil
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::UnicodeText
+      _(type.limit).must_equal             2_147_483_647
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
       assert_obj_set_and_save :ntext, "一二34五六"
     end
@@ -694,60 +726,60 @@ 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_be_nil
-      col.default_function.must_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Binary
-      type.limit.must_equal             49
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'binary(49)'
+      _(col.type).must_equal               :binary_basic
+      _(col.null).must_equal               true
+      _(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.limit).must_equal             49
+      _(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
+      _(binary_data.encoding).must_equal Encoding::BINARY
+      _(binary_data.length).must_equal 49
       obj.binary_49 = binary_data
-      obj.binary_49.must_equal binary_data
+      _(obj.binary_49).must_equal binary_data
       obj.save!
-      obj.reload.binary_49.must_equal binary_data
+      _(obj.reload.binary_49).must_equal binary_data
     end
 
     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_be_nil
-      col.default_function.must_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Varbinary
-      type.limit.must_equal             49
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'varbinary(49)'
+      _(col.type).must_equal               :varbinary
+      _(col.null).must_equal               true
+      _(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.limit).must_equal             49
+      _(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
+      _(binary_data_20.encoding).must_equal Encoding::BINARY
       obj.varbinary_49 = binary_data_20
-      obj.varbinary_49.must_equal binary_data_20
+      _(obj.varbinary_49).must_equal binary_data_20
       obj.save!
-      obj.reload.varbinary_49.must_equal binary_data_20
+      _(obj.reload.varbinary_49).must_equal binary_data_20
     end
 
     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_be_nil
-      col.default_function.must_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::VarbinaryMax
-      type.limit.must_equal             2_147_483_647
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'varbinary(max)'
+      _(col.type).must_equal               :binary
+      _(col.null).must_equal               true
+      _(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.limit).must_equal             2_147_483_647
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic set and save.
-      binary_data.encoding.must_equal Encoding::BINARY
+      _(binary_data.encoding).must_equal Encoding::BINARY
       assert_obj_set_and_save :varbinary_max, binary_data
     end
 
@@ -755,43 +787,43 @@ 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_be_nil
-      col.default_function.must_equal   'newid()'
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Uuid
-      type.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'uniqueidentifier'
+      _(col.type).must_equal               :uuid
+      _(col.null).must_equal               true
+      _(col.default).must_be_nil
+      _(col.default_function).must_equal   'newid()'
+      type = connection.lookup_cast_type_from_column(col)
+      _(type).must_be_instance_of          Type::Uuid
+      _(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_be_nil
+      _(obj.uniqueidentifier).must_be_nil
       obj.save! ; obj.reload
-      obj.uniqueidentifier.must_match   Type::Uuid::ACCEPTABLE_UUID
+      _(obj.uniqueidentifier).must_match   Type::Uuid::ACCEPTABLE_UUID
       obj.uniqueidentifier = "6F9619FF-8B86-D011-B42D-00C04FC964FF"
-      obj.uniqueidentifier.must_equal   "6F9619FF-8B86-D011-B42D-00C04FC964FF"
+      _(obj.uniqueidentifier).must_equal   "6F9619FF-8B86-D011-B42D-00C04FC964FF"
       obj.save! ; obj.reload
-      obj.uniqueidentifier.must_equal   "6F9619FF-8B86-D011-B42D-00C04FC964FF"
+      _(obj.uniqueidentifier).must_equal   "6F9619FF-8B86-D011-B42D-00C04FC964FF"
     end
 
     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_be_nil
-      col.default_function.must_be_nil
-      type = connection.lookup_cast_type_from_column(col)
-      type.must_be_instance_of          Type::Timestamp
-      type.limit.must_be_nil
-      type.precision.must_be_nil
-      type.scale.must_be_nil
+      _(col.sql_type).must_equal           'timestamp'
+      _(col.type).must_equal               :ss_timestamp
+      _(col.null).must_equal               true
+      _(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.limit).must_be_nil
+      _(type.precision).must_be_nil
+      _(type.scale).must_be_nil
       # Basic read.
-      obj.timestamp.must_be_nil
+      _(obj.timestamp).must_be_nil
       obj.save! ; obj.reload
-      obj.timestamp.must_match   %r|\000|
+      _(obj.timestamp).must_match   %r|\000|
       obj.timestamp
       # Can set another attribute
       obj.uniqueidentifier = "6F9619FF-8B86-D011-B42D-00C04FC964FF"
@@ -801,7 +833,7 @@ class ColumnTestSQLServer < ActiveRecord::TestCase
     it 'does not mark object as changed after save' do
       obj.save!
       obj.attributes
-      obj.changed?.must_equal false
+      _(obj.changed?).must_equal false
     end
 
   end