activerecord-sqlserver-adapter 4.2.18 → 5.0.0

data/lib/active_record/connection_adapters/sqlserver_column.rb

@@ -2,22 +2,9 @@ module ActiveRecord
   module ConnectionAdapters
     class SQLServerColumn < Column
 
-      def initialize(name, default, cast_type, sql_type = nil, null = true, sqlserver_options = {})
-        super(name, default, cast_type, sql_type, null)
-        @sqlserver_options = sqlserver_options.symbolize_keys
-        @default_function = @sqlserver_options[:default_function]
-      end
-
-      def sql_type_for_statement
-        if is_integer? || is_real?
-          sql_type.sub(/\((\d+)?\)/, '')
-        else
-          sql_type
-        end
-      end
-
-      def table_name
-        @sqlserver_options[:table_name]
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment = nil, sqlserver_options = {})
+        @sqlserver_options = sqlserver_options || {}
+        super(name, default, sql_type_metadata, null, table_name, default_function, collation, comment: comment)
       end
 
       def is_identity?
@@ -29,23 +16,11 @@ module ActiveRecord
       end
 
       def is_utf8?
-        @sql_type =~ /nvarchar|ntext|nchar/i
-      end
-
-      def is_integer?
-        @sql_type =~ /int/i
-      end
-
-      def is_real?
-        @sql_type =~ /real/i
-      end
-
-      def collation
-        @sqlserver_options[:collation]
+        sql_type =~ /nvarchar|ntext|nchar/i
       end
 
       def case_sensitive?
-        collation && !collation.match(/_CI/)
+        collation && collation.match(/_CS/)
       end
 
     end

data/lib/active_record/sqlserver_base.rb

@@ -7,14 +7,10 @@ module ActiveRecord
       case mode
       when :dblib
         require 'tiny_tds'
-      when :odbc
-        raise ArgumentError, 'Missing :dsn configuration.' unless config.key?(:dsn)
-        require 'odbc'
-        require 'active_record/connection_adapters/sqlserver/core_ext/odbc'
       else
         raise ArgumentError, "Unknown connection mode in #{config.inspect}."
       end
-      ConnectionAdapters::SQLServerAdapter.new(nil, logger, nil, config.merge(mode: mode))
+      ConnectionAdapters::SQLServerAdapter.new(nil, nil, config.merge(mode: mode))
     end
   end
 end

data/lib/arel/visitors/sqlserver.rb

@@ -19,11 +19,7 @@ module Arel
 
       def visit_Arel_Nodes_Bin o, collector
         visit o.expr, collector
-        if o.expr.val.is_a? Numeric
-          collector
-        else
-          collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
-        end
+        collector << " #{ActiveRecord::ConnectionAdapters::SQLServerAdapter.cs_equality_operator} "
       end
 
       def visit_Arel_Nodes_UpdateStatement(o, a)
@@ -77,9 +73,13 @@ module Arel
         # Apparently, o.engine.connection can actually be a different adapter
         # than sqlserver. Can be removed if fixed in ActiveRecord. See:
         # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
-        table_name = if o.engine.connection.respond_to?(:sqlserver?) && o.engine.connection.database_prefix_remote_server?
-          remote_server_table_name(o)
-        else
+        table_name = begin
+          if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
+            remote_server_table_name(o)
+          else
+            quote_table_name(o.name)
+          end
+        rescue Exception => e
           quote_table_name(o.name)
         end
         if o.table_alias
@@ -170,7 +170,7 @@ module Arel
         core = o.cores.first
         distinct = Nodes::Distinct === core.set_quantifier
         oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
-        limitone = node_value(o.limit) == 1
+        limitone = [nil, 0, 1].include? node_value(o.limit)
         if distinct && oneasone && limitone && !o.offset
           core.projections = [Arel.sql("TOP(1) 1 AS [one]")]
           o.limit = nil
@@ -190,25 +190,16 @@ module Arel
 
       def primary_Key_From_Table t
         return unless t
-        return t.primary_key if t.primary_key
-        if engine_pk = t.engine.primary_key
-          pk = t.engine.arel_table[engine_pk]
-          return pk if pk
-        end
-        pk = t.engine.connection.schema_cache.primary_keys(t.engine.table_name)
-        return pk if pk
-        column_name = t.engine.columns.first.try(:name)
+        column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.try(:second).try(:name)
         column_name ? t[column_name] : nil
       end
 
       def remote_server_table_name o
         ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
-          "#{o.engine.connection.database_prefix}#{o.name}"
+          "#{o.class.engine.connection.database_prefix}#{o.name}"
         ).quoted
       end
 
     end
   end
 end
-
-Arel::Visitors::VISITORS['sqlserver'] = Arel::Visitors::SQLServer

data/test/bin/setup.sh

@@ -3,17 +3,15 @@
 set -x
 set -e
 
-tag=1.2
+docker pull metaskills/mssql-server-linux-rails
 
-docker pull metaskills/mssql-server-linux-rails:$tag
-
-container=$(docker ps -a -q --filter ancestor=metaskills/mssql-server-linux-rails:$tag)
+container=$(docker ps -a -q --filter ancestor=metaskills/mssql-server-linux-rails)
 if [[ -z $container ]]; then
-  docker run -p 1433:1433 -d metaskills/mssql-server-linux-rails:$tag && sleep 10
+  docker run -p 1433:1433 -d metaskills/mssql-server-linux-rails && sleep 10
   exit
 fi
 
-container=$(docker ps -q --filter ancestor=metaskills/mssql-server-linux-rails:$tag)
+container=$(docker ps -q --filter ancestor=metaskills/mssql-server-linux-rails)
 if [[ -z $container ]]; then
   docker start $container && sleep 10
 fi

data/test/cases/adapter_test_sqlserver.rb

@@ -17,7 +17,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     string = connection.inspect
     string.must_match %r{ActiveRecord::ConnectionAdapters::SQLServerAdapter}
     string.must_match %r{version\: \d.\d}
-    string.must_match %r{mode: (dblib|odbc)}
+    string.must_match %r{mode: dblib}
     string.must_match %r{azure: (true|false)}
     string.wont_match %r{host}
     string.wont_match %r{password}
@@ -96,7 +96,7 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       connection.send :initialize_dateformatter
       assert_nothing_raised do
         starting = Time.utc(2000, 1, 31, 5, 42, 0)
-        ending = Date.new(2006, 12, 31)
+        ending = Time.new(2006, 12, 31)
         Task.create! starting: starting, ending: ending
       end
     end
@@ -158,14 +158,14 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       end
     end
 
-    it 'find identity column using #identity_column' do
+    it 'find identity column using #identity_columns' do
       task_id_column = Task.columns_hash['id']
-      assert_equal task_id_column.name, connection.send(:identity_column, Task.table_name).name
-      assert_equal task_id_column.sql_type, connection.send(:identity_column, Task.table_name).sql_type
+      assert_equal task_id_column.name, connection.send(:identity_columns, Task.table_name).first.name
+      assert_equal task_id_column.sql_type, connection.send(:identity_columns, Task.table_name).first.sql_type
     end
 
-    it 'return nil when calling #identity_column for a table_name with no identity' do
-      assert_nil connection.send(:identity_column, Subscriber.table_name)
+    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 []
     end
 
   end
@@ -364,8 +364,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       assert_equal 0, SSTestCustomersView.new.balance
     end
 
-    it 'respond true to table_exists?' do
-      assert SSTestCustomersView.table_exists?
+    it 'respond true to data_source_exists?' do
+      assert SSTestCustomersView.connection.data_source_exists?(SSTestCustomersView.table_name)
     end
 
     # With aliased column names
@@ -392,17 +392,8 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
         SSTestStringDefaultsView.columns_hash['pretend_null'].inspect
     end
 
-    it 'respond true to table_exists?' do
-      assert SSTestStringDefaultsView.table_exists?
-    end
-
-    # Doing identity inserts
-
-    it 'be able to do an identity insert' do
-      customer = SSTestCustomersView.new
-      customer.id = 420
-      customer.save!
-      assert SSTestCustomersView.find(420)
+    it 'respond true to data_source_exists?' do
+      assert SSTestStringDefaultsView.connection.data_source_exists?(SSTestStringDefaultsView.table_name)
     end
 
     # That have more than 4000 chars for their defintion

data/test/cases/coerced_tests.rb

@@ -1,30 +1,49 @@
 require 'cases/helper_sqlserver'
 
 
-# Windows/Appveyor
-if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-  # All of these are due to Time.local(2000).zone. See http://git.io/v3t0o
-  class BelongsToAssociationsTest < ActiveRecord::TestCase
-    coerce_tests! :test_belongs_to_with_touch_option_on_touch_without_updated_at_attributes
-  end
-  class BasicsTest < ActiveRecord::TestCase
-    coerce_tests! :test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc
-    coerce_tests! :test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local
-    coerce_tests! :test_preserving_time_objects_with_utc_time_conversion_to_default_timezone_local
+
+require 'models/event'
+class UniquenessValidationTest < ActiveRecord::TestCase
+  # So sp_executesql swallows this exception. Run without prpared to see it.
+  coerce_tests! :test_validate_uniqueness_with_limit
+  def test_validate_uniqueness_with_limit_coerced
+    connection.unprepared_statement do
+      assert_raise(ActiveRecord::ValueTooLong) do
+        Event.create(title: "abcdefgh")
+      end
+    end
   end
-  class DirtyTest < ActiveRecord::TestCase
-    coerce_tests! :test_save_always_should_update_timestamps_when_serialized_attributes_are_present
-    coerce_tests! :test_previous_changes # Coupled to above test.
+
+  # So sp_executesql swallows this exception. Run without prpared to see it.
+  coerce_tests! :test_validate_uniqueness_with_limit_and_utf8
+  def test_validate_uniqueness_with_limit_and_utf8_coerced
+    connection.unprepared_statement do
+      assert_raise(ActiveRecord::ValueTooLong) do
+        Event.create(title: "一二三四五六七八")
+      end
+    end
   end
 end
 
 
+
+
+require 'models/event'
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
-
     # As far as I can tell, SQL Server does not support null bytes in strings.
     coerce_tests! :test_update_prepared_statement
 
+    # So sp_executesql swallows this exception. Run without prpared to see it.
+    coerce_tests! :test_value_limit_violations_are_translated_to_specific_exception
+    def test_value_limit_violations_are_translated_to_specific_exception_coerced
+      connection.unprepared_statement do
+        error = assert_raises(ActiveRecord::ValueTooLong) do
+          Event.create(title: 'abcdefgh')
+        end
+        assert_not_nil error.cause
+      end
+    end
   end
 end
 
@@ -33,7 +52,6 @@ end
 
 require 'models/topic'
 class AttributeMethodsTest < ActiveRecord::TestCase
-
   coerce_tests! :test_typecast_attribute_from_select_to_false
   def test_typecast_attribute_from_select_to_false_coerced
     Topic.create(:title => 'Budget')
@@ -47,26 +65,19 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = Topic.all.merge!(:select => "topics.*, IIF (1 = 1, 1, 0) as is_test").first
     assert topic.is_test?
   end
-
 end
 
 
 
 
 class BasicsTest < ActiveRecord::TestCase
-
   coerce_tests! :test_column_names_are_escaped
   def test_column_names_are_escaped_coerced
-    conn      = ActiveRecord::Base.connection
-    classname = conn.class.name[/[^:]*$/]
-    badchar   = "'"
-    quoted = conn.quote_column_name "foo#{badchar}bar"
-    assert_equal "[foo'bar]", quoted
+    conn = ActiveRecord::Base.connection
+    assert_equal '[t]]]', conn.quote_column_name('t]')
   end
 
-  # PENDING: [Rails5.x] Remove coerced tests and use simple symbol types..
-  # This test has a few problems. First, it would require that we use the
-  # `Type::SQLServer::BigInteger.new(limit: 8)` for the `world_population` attribute.
+  # We do not have do the DecimalWithoutScale type.
   coerce_tests! :test_numeric_fields
   coerce_tests! :test_numeric_fields_with_scale
 
@@ -76,14 +87,12 @@ class BasicsTest < ActiveRecord::TestCase
   # Caused in Rails v4.2.5 by adding `firm_id` column in this http://git.io/vBfMs
   # commit. Trust Rails has this covered.
   coerce_tests! :test_find_keeps_multiple_group_values
-
 end
 
 
 
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
-
   # Since @client.firm is a single first/top, and we use FETCH the order clause is used.
   coerce_tests! :test_belongs_to_does_not_use_order_by
 
@@ -93,7 +102,6 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_no_match(/\[firm_with_primary_keys_companies\]\.\[id\]/, sql)
     assert_match(/\[firm_with_primary_keys_companies\]\.\[name\]/, sql)
   end
-
 end
 
 
@@ -101,11 +109,8 @@ end
 
 module ActiveRecord
   class BindParameterTest < ActiveRecord::TestCase
-
     # Never finds `sql` since we use `EXEC sp_executesql` wrappers.
-    coerce_tests! :test_binds_are_logged,
-                  :test_binds_are_logged_after_type_cast
-
+    coerce_tests! :test_binds_are_logged
   end
 end
 
@@ -113,7 +118,6 @@ end
 
 
 class CalculationsTest < ActiveRecord::TestCase
-
   # Are decimal, not integer.
   coerce_tests! :test_should_return_decimal_average_of_integer_field
   def test_should_return_decimal_average_of_integer_field_coerced
@@ -123,38 +127,34 @@ class CalculationsTest < ActiveRecord::TestCase
 
   coerce_tests! :test_limit_is_kept
   def test_limit_is_kept_coerced
-    queries = assert_sql { Account.limit(1).count }
+    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 1 ROWS ONLY}
+    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 = assert_sql { Account.limit(1).offset(1).count }
+    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 1 ROWS FETCH NEXT 1 ROWS ONLY}
+    queries.first.must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET @0 ROWS FETCH NEXT @1 ROWS ONLY.*@0 = 1, @1 = 1}
   end
 
+  # Leave it up to users to format selects/functions so HAVING works correctly.
+  coerce_tests! :test_having_with_strong_parameters
 end
 
 
 
-
 module ActiveRecord
   class Migration
     class ChangeSchemaTest < ActiveRecord::TestCase
-
        # We test these.
       coerce_tests! :test_create_table_with_bigint,
                     :test_create_table_with_defaults
-
-
     end
     class ChangeSchemaWithDependentObjectsTest < ActiveRecord::TestCase
-
       # In SQL Server you have to delete the tables yourself in the right order.
       coerce_tests! :test_create_table_with_force_cascade_drops_dependent_objects
-
     end
   end
 end
@@ -165,7 +165,6 @@ end
 module ActiveRecord
   class Migration
     class ColumnAttributesTest < ActiveRecord::TestCase
-
       # We have a default 4000 varying character limit.
       coerce_tests! :test_add_column_without_limit
       def test_add_column_without_limit_coerced
@@ -173,7 +172,6 @@ module ActiveRecord
         TestModel.reset_column_information
         TestModel.columns_hash["description"].limit.must_equal 4000
       end
-
     end
   end
 end
@@ -184,14 +182,14 @@ end
 module ActiveRecord
   class Migration
     class ColumnsTest
-
-      # Our defaults are reall 70000 integers vs '70000' strings.
+      # Our defaults are real 70000 integers vs '70000' strings.
       coerce_tests! :test_rename_column_preserves_default_value_not_null
       def test_rename_column_preserves_default_value_not_null_coerced
         add_column 'test_models', 'salary', :integer, :default => 70000
         default_before = connection.columns("test_models").find { |c| c.name == "salary" }.default
         assert_equal 70000, default_before
         rename_column "test_models", "salary", "annual_salary"
+        TestModel.reset_column_information
         assert TestModel.column_names.include?("annual_salary")
         default_after = connection.columns("test_models").find { |c| c.name == "annual_salary" }.default
         assert_equal 70000, default_after
@@ -208,6 +206,14 @@ module ActiveRecord
         assert_equal [], connection.indexes('test_models').map(&:name)
       end
 
+      # Choose `StatementInvalid` vs `ActiveRecordError`.
+      coerce_tests! :test_rename_nonexistent_column
+      def test_rename_nonexistent_column_coerced
+        exception = ActiveRecord::StatementInvalid
+        assert_raise(exception) do
+          rename_column "test_models", "nonexistent", "should_fail"
+        end
+      end
     end
   end
 end
@@ -215,13 +221,53 @@ end
 
 
 
-class CoreTest < ActiveRecord::TestCase
+class MigrationTest < ActiveRecord::TestCase
+  # We do not have do the DecimalWithoutScale type.
+  coerce_tests! :test_add_table_with_decimals
+  def test_add_table_with_decimals_coerced
+    Person.connection.drop_table :big_numbers rescue nil
+    assert !BigNumber.table_exists?
+    GiveMeBigNumbers.up
+    BigNumber.reset_column_information
+    assert BigNumber.create(
+      :bank_balance => 1586.43,
+      :big_bank_balance => BigDecimal("1000234000567.95"),
+      :world_population => 6000000000,
+      :my_house_population => 3,
+      :value_of_e => BigDecimal("2.7182818284590452353602875")
+    )
+    b = BigNumber.first
+    assert_not_nil b
+    assert_not_nil b.bank_balance
+    assert_not_nil b.big_bank_balance
+    assert_not_nil b.world_population
+    assert_not_nil b.my_house_population
+    assert_not_nil b.value_of_e
+    assert_kind_of BigDecimal, b.world_population
+    assert_equal '6000000000.0', b.world_population.to_s
+    assert_kind_of Integer, b.my_house_population
+    assert_equal 3, b.my_house_population
+    assert_kind_of BigDecimal, b.bank_balance
+    assert_equal BigDecimal("1586.43"), b.bank_balance
+    assert_kind_of BigDecimal, b.big_bank_balance
+    assert_equal BigDecimal("1000234000567.95"), b.big_bank_balance
+    GiveMeBigNumbers.down
+    assert_raise(ActiveRecord::StatementInvalid) { BigNumber.first }
+  end
+
+  # For some reason our tests set Rails.@_env which breaks test env switching.
+  coerce_tests! :test_migration_sets_internal_metadata_even_when_fully_migrated
+  coerce_tests! :test_internal_metadata_stores_environment
+end
+
+
 
+
+class CoreTest < ActiveRecord::TestCase
   # I think fixtures are useing the wrong time zone and the `:first`
   # `topics`.`bonus_time` attribute of 2005-01-30t15:28:00.00+01:00 is
   # getting local EST time for me and set to "09:28:00.0000000".
   coerce_tests! :test_pretty_print_persisted
-
 end
 
 
@@ -229,7 +275,6 @@ end
 
 module ActiveRecord
   module ConnectionAdapters
-
     # Just like PostgreSQLAdapter does.
     TypeLookupTest.coerce_all_tests! if defined?(TypeLookupTest)
 
@@ -237,7 +282,6 @@ module ActiveRecord
     # a value of 'default_env' will still show tests failing. Just ignoring all
     # of them since we have no monkey in this circus.
     MergeAndResolveDefaultUrlConfigTest.coerce_all_tests! if defined?(MergeAndResolveDefaultUrlConfigTest)
-
   end
 end
 
@@ -259,10 +303,16 @@ end
 
 
 class DefaultScopingTest < ActiveRecord::TestCase
-
   # We are not doing order duplicate removal anymore.
   coerce_tests! :test_order_in_default_scope_should_not_prevail
 
+  # Use our escaped format in assertion.
+  coerce_tests! :test_with_abstract_class_scope_should_be_executed_in_correct_context
+  def test_with_abstract_class_scope_should_be_executed_in_correct_context_coerced
+    vegetarian_pattern, gender_pattern = [/[lions].[is_vegetarian]/, /[lions].[gender]/]
+    assert_match vegetarian_pattern, Lion.all.to_sql
+    assert_match gender_pattern, Lion.female.to_sql
+  end
 end
 
 
@@ -271,7 +321,7 @@ end
 require 'models/post'
 require 'models/subscriber'
 class EachTest < ActiveRecord::TestCase
-
+  # Quoting in tests does not cope with bracket quoting.
   coerce_tests! :test_find_in_batches_should_quote_batch_order
   def test_find_in_batches_should_quote_batch_order_coerced
     c = Post.connection
@@ -283,20 +333,23 @@ class EachTest < ActiveRecord::TestCase
     end
   end
 
+  # Quoting in tests does not cope with bracket quoting.
+  coerce_tests! :test_in_batches_should_quote_batch_order
+  def test_in_batches_should_quote_batch_order_coerced
+    c = Post.connection
+    assert_sql(/ORDER BY \[posts\]\.\[id\]/) do
+      Post.in_batches(of: 1) do |relation|
+        assert_kind_of ActiveRecord::Relation, relation
+        assert_kind_of Post, relation.first
+      end
+    end
+  end
 end
 
 
 
 
-require 'models/owner'
-class Owner < ActiveRecord::Base
-  scope :including_last_pet, -> {
-    select('owners.*, (select TOP (1) p.pet_id from pets p where p.owner_id = owners.owner_id order by p.name desc ) as last_pet_id').
-    includes(:last_pet)
-  }
-end
 class EagerAssociationTest < ActiveRecord::TestCase
-
   # Use LEN() vs length() function.
   coerce_tests! :test_count_with_include
   def test_count_with_include_coerced
@@ -305,10 +358,6 @@ class EagerAssociationTest < ActiveRecord::TestCase
 
   # Use TOP (1) in scope vs limit 1.
   coerce_tests! %r{including association based on sql condition and no database column}
-  it "including association based on sql condition and no database column coerced" do
-    assert_equal pets(:parrot), Owner.including_last_pet.first.last_pet
-  end
-
 end
 
 
@@ -316,13 +365,12 @@ end
 
 require 'models/topic'
 class FinderTest < ActiveRecord::TestCase
-
   coerce_tests! %r{doesn't have implicit ordering},
                 :test_find_doesnt_have_implicit_ordering # We have implicit ordering, via FETCH.
 
   coerce_tests! :test_exists_does_not_select_columns_without_alias
   def test_exists_does_not_select_columns_without_alias_coerced
-    assert_sql(/SELECT\s+1 AS one FROM \[topics\].*OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY/i) do
+    assert_sql(/SELECT\s+1 AS one FROM \[topics\].*OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.*@0 = 1/i) do
       Topic.exists?
     end
   end
@@ -335,14 +383,35 @@ class FinderTest < ActiveRecord::TestCase
 
   coerce_tests! :test_take_and_first_and_last_with_integer_should_use_sql_limit
   def test_take_and_first_and_last_with_integer_should_use_sql_limit_coerced
-    assert_sql(/OFFSET 0 ROWS FETCH NEXT 3 ROWS ONLY/) { Topic.take(3).entries }
-    assert_sql(/OFFSET 0 ROWS FETCH NEXT 2 ROWS ONLY/) { Topic.first(2).entries }
-    assert_sql(/OFFSET 0 ROWS FETCH NEXT 5 ROWS ONLY/) { Topic.last(5).entries }
+    assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 3/) { Topic.take(3).entries }
+    assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 2/) { Topic.first(2).entries }
+    assert_sql(/OFFSET 0 ROWS FETCH NEXT @0 ROWS ONLY.* @0 = 5/) { Topic.last(5).entries }
   end
 
   # This fails only when run in the full test suite task. Just taking it out of the mix.
   coerce_tests! :test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
 
+  # Can not use array condition due to not finding right type and hence fractional second quoting.
+  coerce_tests! :test_condition_utc_time_interpolation_with_default_timezone_local
+  def test_condition_utc_time_interpolation_with_default_timezone_local_coerced
+    with_env_tz 'America/New_York' do
+      with_timezone_config default: :local do
+        topic = Topic.first
+        assert_equal topic, Topic.where(written_on: topic.written_on.getutc).first
+      end
+    end
+  end
+
+  # Can not use array condition due to not finding right type and hence fractional second quoting.
+  coerce_tests! :test_condition_local_time_interpolation_with_default_timezone_utc
+  def test_condition_local_time_interpolation_with_default_timezone_utc_coerced
+    with_env_tz 'America/New_York' do
+      with_timezone_config default: :utc do
+        topic = Topic.first
+        assert_equal topic, Topic.where(written_on: topic.written_on.getlocal).first
+      end
+    end
+  end
 end
 
 
@@ -351,7 +420,6 @@ end
 module ActiveRecord
   class Migration
     class ForeignKeyTest < ActiveRecord::TestCase
-
       # We do not support :restrict.
       coerce_tests! :test_add_on_delete_restrict_foreign_key
       def test_add_on_delete_restrict_foreign_key_coerced
@@ -362,7 +430,6 @@ module ActiveRecord
           @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :restrict
         end
       end
-
     end
   end
 end
@@ -371,10 +438,8 @@ end
 
 
 class HasOneAssociationsTest < ActiveRecord::TestCase
-
   # We use OFFSET/FETCH vs TOP. So we always have an order.
   coerce_tests! :test_has_one_does_not_use_order_by
-
 end
 
 
@@ -382,7 +447,6 @@ end
 
 require 'models/company'
 class InheritanceTest < ActiveRecord::TestCase
-
   coerce_tests! :test_a_bad_type_column
   def test_a_bad_type_column_coerced
     Company.connection.with_identity_insert_enabled('companies') do
@@ -394,32 +458,24 @@ class InheritanceTest < ActiveRecord::TestCase
   coerce_tests! :test_eager_load_belongs_to_primary_key_quoting
   def test_eager_load_belongs_to_primary_key_quoting_coerced
     con = Account.connection
-    assert_sql(/\[companies\]\.\[id\] IN \(1\)/) do
+    assert_sql(/\[companies\]\.\[id\] = 1/) do
       Account.all.merge!(:includes => :firm).find(1)
     end
   end
-
 end
 
 
 
 
-class BigNumber < ActiveRecord::Base
-  attribute :value_of_e, Type::SQLServer::Integer.new
-  attribute :my_house_population, Type::SQLServer::Integer.new
-end
-class MigrationTest < ActiveRecord::TestCase
-
-  # PENDING: [Rails5.x] Remove coerced tests and use simple symbol types.
-  coerce_tests! :test_add_table_with_decimals
-
+class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
+  # Uses || operator in SQL. Just trust core gets value out of this test.
+  coerce_tests! :test_does_not_override_select
 end
 
 
 
 
 class NamedScopingTest < ActiveRecord::TestCase
-
   # This works now because we add an `order(:id)` sort to break the order tie for deterministic results.
   coerce_tests! :test_scopes_honor_current_scopes_from_when_defined
   def test_scopes_honor_current_scopes_from_when_defined_coerced
@@ -431,7 +487,6 @@ class NamedScopingTest < ActiveRecord::TestCase
     assert_equal authors(:david).posts.ranked_by_comments.limit_by(5).to_a.sort_by(&:id), authors(:david).posts.top(5).to_a.sort_by(&:id)
     assert_equal Post.ranked_by_comments.limit_by(5), Post.top(5)
   end
-
 end
 
 
@@ -440,7 +495,6 @@ end
 require 'models/developer'
 require 'models/computer'
 class NestedRelationScopingTest < ActiveRecord::TestCase
-
   coerce_tests! :test_merge_options
   def test_merge_options_coerced
     Developer.where('salary = 80000').scoping do
@@ -452,7 +506,6 @@ class NestedRelationScopingTest < ActiveRecord::TestCase
       end
     end
   end
-
 end
 
 
@@ -460,7 +513,6 @@ end
 
 require 'models/topic'
 class PersistenceTest < ActiveRecord::TestCase
-
   # We can not UPDATE identity columns.
   coerce_tests! :test_update_columns_changing_id
 
@@ -501,7 +553,6 @@ class PersistenceTest < ActiveRecord::TestCase
     # assert_nothing_raised { topic.reload }
     # assert_equal topic.title, Topic.find(1234).title
   end
-
 end
 
 
@@ -510,15 +561,15 @@ end
 require 'models/topic'
 module ActiveRecord
   class PredicateBuilderTest < ActiveRecord::TestCase
-
     coerce_tests! :test_registering_new_handlers
     def test_registering_new_handlers_coerced
-      PredicateBuilder.register_handler(Regexp, proc do |column, value|
+      Topic.predicate_builder.register_handler(Regexp, proc do |column, value|
         Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
       end)
-      assert_match %r{\[topics\]\.\[title\] ~ rails}i, Topic.where(title: /rails/).to_sql
+      assert_match %r{\[topics\].\[title\] ~ rails}i, Topic.where(title: /rails/).to_sql
+    ensure
+      Topic.reset_column_information
     end
-
   end
 end
 
@@ -527,14 +578,12 @@ end
 
 require 'models/task'
 class QueryCacheTest < ActiveRecord::TestCase
-
   coerce_tests! :test_cache_does_not_wrap_string_results_in_arrays
   def test_cache_does_not_wrap_string_results_in_arrays_coerced
     Task.cache do
       assert_kind_of Numeric, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
     end
   end
-
 end
 
 
@@ -542,6 +591,21 @@ end
 
 require 'models/post'
 class RelationTest < ActiveRecord::TestCase
+  # Use LEN vs LENGTH function.
+  coerce_tests! :test_reverse_order_with_function
+  def test_reverse_order_with_function_coerced
+    topics = Topic.order("LEN(title)").reverse_order
+    assert_equal topics(:second).title, topics.first.title
+  end
+
+  # Use LEN vs LENGTH function.
+  coerce_tests! :test_reverse_order_with_function_other_predicates
+  def test_reverse_order_with_function_other_predicates_coerced
+    topics = Topic.order("author_name, LEN(title), id").reverse_order
+    assert_equal topics(:second).title, topics.first.title
+    topics = Topic.order("LEN(author_name), id, LEN(title)").reverse_order
+    assert_equal topics(:fifth).title, topics.first.title
+  end
 
   # We have implicit ordering, via FETCH.
   coerce_tests! %r{doesn't have implicit ordering}
@@ -549,18 +613,12 @@ class RelationTest < ActiveRecord::TestCase
   # We are not doing order duplicate removal anymore.
   coerce_tests! :test_order_using_scoping
 
-  # Account for our `EXEC sp_executesql...` statements.
-  coerce_tests! :test_to_sql_on_eager_join
-  def test_to_sql_on_eager_join_coerced
-    expected = assert_sql { Post.eager_load(:last_comment).order('comments.id DESC').to_a }.first
-    actual = Post.eager_load(:last_comment).order('comments.id DESC').to_sql
-    actual = "EXEC sp_executesql N'#{ActiveRecord::ConnectionAdapters::SQLServer::Utils.quote_string(actual)}'"
-    assert_equal expected, actual
-  end
-
   # We are not doing order duplicate removal anymore.
   coerce_tests! :test_default_scope_order_with_scope_order
 
+  # Leave it up to users to format selects/functions so HAVING works correctly.
+  coerce_tests! :test_multiple_where_and_having_clauses
+  coerce_tests! :test_having_with_binds_for_both_where_and_having
 end
 
 
@@ -568,7 +626,6 @@ end
 
 require 'models/post'
 class SanitizeTest < ActiveRecord::TestCase
-
   coerce_tests! :test_sanitize_sql_like_example_use_case
   def test_sanitize_sql_like_example_use_case_coerced
     searchable_post = Class.new(Post) do
@@ -576,18 +633,16 @@ class SanitizeTest < ActiveRecord::TestCase
         where("title LIKE ?", sanitize_sql_like(term, '!'))
       end
     end
-    assert_sql(/\(title LIKE N''20!% !_reduction!_!!''\)/) do
+    assert_sql(/\(title LIKE N'20!% !_reduction!_!!'\)/) do
       searchable_post.search("20% _reduction_!").to_a
     end
   end
-
 end
 
 
 
 
 class SchemaDumperTest < ActiveRecord::TestCase
-
   # We have precision to 38.
   coerce_tests! :test_schema_dump_keeps_large_precision_integer_columns_as_decimal
   def test_schema_dump_keeps_large_precision_integer_columns_as_decimal_coerced
@@ -604,27 +659,29 @@ class SchemaDumperTest < ActiveRecord::TestCase
   # Fall through false positive with no filter.
   coerce_tests! :test_schema_dumps_partial_indices
   def test_schema_dumps_partial_indices_coerced
-    index_definition = standard_dump.split(/\n/).grep(/add_index.*company_partial_index/).first.strip
-    assert_equal 'add_index "companies", ["firm_id", "type"], name: "company_partial_index", where: "([rating]>(10))"', index_definition
+    index_definition = standard_dump.split(/\n/).grep(/t.index.*company_partial_index/).first.strip
+    assert_equal 't.index ["firm_id", "type"], name: "company_partial_index", where: "([rating]>(10))"', index_definition
   end
 
+  # We do not quote the 2.78 string default.
+  coerce_tests! :test_schema_dump_includes_decimal_options
+  def test_schema_dump_includes_decimal_options_coerced
+    output = dump_all_table_schema([/^[^n]/])
+    assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 2\.78}, output
+  end
 end
 
 class SchemaDumperDefaultsTest < ActiveRecord::TestCase
-
   # These date formats do not match ours. We got these covered in our dumper tests.
   coerce_tests! :test_schema_dump_defaults_with_universally_supported_types
-
 end
 
 
 
 
 class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
-
   # We trust Rails on this since we do not want to install mysql.
   coerce_tests! %r{inspect on Model class does not raise}
-
 end
 
 
@@ -632,7 +689,6 @@ end
 
 require 'models/topic'
 class TransactionTest < ActiveRecord::TestCase
-
   coerce_tests! :test_releasing_named_savepoints
   def test_releasing_named_savepoints_coerced
     Topic.transaction do
@@ -642,7 +698,6 @@ class TransactionTest < ActiveRecord::TestCase
       Topic.connection.release_savepoint("another")
     end
   end
-
 end
 
 
@@ -650,7 +705,6 @@ end
 
 require 'models/tag'
 class TransactionIsolationTest < ActiveRecord::TestCase
-
   # SQL Server will lock the table for counts even when both
   # connections are `READ COMMITTED`. So we bypass with `READPAST`.
   coerce_tests! %r{read committed}
@@ -667,32 +721,32 @@ class TransactionIsolationTest < ActiveRecord::TestCase
 
   # I really need some help understanding this one.
   coerce_tests! %r{repeatable read}
-
-end
-
-
-require 'models/post'
-module ActiveRecord
-  class WhereChainTest < ActiveRecord::TestCase
-
-    coerce_tests! :test_not_eq_with_array_parameter
-    def test_not_eq_with_array_parameter_coerced
-      expected = Arel::Nodes::Not.new("title = N'hello'")
-      relation = Post.where.not(['title = ?', 'hello'])
-      assert_equal([expected], relation.where_values)
-    end
-
-  end
 end
 
 
 
 
+require 'models/book'
 class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
+  # We have a few view tables. use includes vs equality.
+  coerce_tests! :test_views
+  def test_views_coerced
+    assert_includes @connection.views, Ebook.table_name
+  end
 
   # We do better than ActiveRecord and find the views PK.
   coerce_tests! :test_does_not_assume_id_column_as_primary_key
-
+  def test_does_not_assume_id_column_as_primary_key_coerced
+    model = Class.new(ActiveRecord::Base) { self.table_name = "ebooks" }
+    assert_equal 'id', model.primary_key
+  end
+end
+class ViewWithoutPrimaryKeyTest < ActiveRecord::TestCase
+  # We have a few view tables. use includes vs equality.
+  coerce_tests! :test_views
+  def test_views_coerced
+    assert_includes @connection.views, Paperback.table_name
+  end
 end
 
 
@@ -700,7 +754,6 @@ end
 
 require 'models/author'
 class YamlSerializationTest < ActiveRecord::TestCase
-
   coerce_tests! :test_types_of_virtual_columns_are_not_changed_on_round_trip
   def test_types_of_virtual_columns_are_not_changed_on_round_trip_coerced
     author = Author.select('authors.*, 5 as posts_count').first
@@ -708,6 +761,48 @@ class YamlSerializationTest < ActiveRecord::TestCase
     assert_equal 5, author.posts_count
     assert_equal 5, dumped.posts_count
   end
+end
+
+
+
+
+class DateTimePrecisionTest < ActiveRecord::TestCase
+  # Original test had `7` which we support vs `8` which we use.
+  coerce_tests! :test_invalid_datetime_precision_raises_error
+  def test_invalid_datetime_precision_raises_error_coerced
+    assert_raises ActiveRecord::ActiveRecordError do
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 8
+      end
+    end
+  end
+end
+
+
+
 
+class DefaultNumbersTest < ActiveRecord::TestCase
+  # We do better with native types and do not return strings for everything.
+  coerce_tests! :test_default_positive_integer
+  def test_default_positive_integer_coerced
+    record = DefaultNumber.new
+    assert_equal 7, record.positive_integer
+    assert_equal 7, record.positive_integer_before_type_cast
+  end
+  coerce_tests! :test_default_negative_integer
+  def test_default_negative_integer_coerced
+    record = DefaultNumber.new
+    assert_equal -5, record.negative_integer
+    assert_equal -5, record.negative_integer_before_type_cast
+  end
 end
 
+
+
+
+module ActiveRecord
+  class CollectionCacheKeyTest < ActiveRecord::TestCase
+    # Will trust rails has this sorted since you cant offset without a limit.
+    coerce_tests! %r{with offset which return 0 rows}
+  end
+end