activerecord-sqlserver-adapter 4.1.8 → 4.2.0.pre

data/lib/{arel/arel_sqlserver.rb → arel_sqlserver.rb}

@@ -1,5 +1,3 @@
 require 'arel'
-require 'arel/select_manager_sqlserver'
-require 'arel/nodes_sqlserver'
-require 'arel/visitors/sqlserver'
 require 'arel/visitors/bind_visitor'
+require 'arel/visitors/sqlserver'

data/test/cases/adapter_test_sqlserver.rb

@@ -0,0 +1,420 @@
+require 'cases/helper_sqlserver'
+require 'models/topic'
+require 'models/task'
+require 'models/post'
+require 'models/subscriber'
+require 'models/minimalistic'
+
+class AdapterTestSQLServer < ActiveRecord::TestCase
+
+  fixtures :tasks
+
+  let(:basic_insert_sql) { "INSERT INTO [funny_jokes] ([name]) VALUES('Knock knock')" }
+  let(:basic_update_sql) { "UPDATE [customers] SET [address_street] = NULL WHERE [id] = 2" }
+  let(:basic_select_sql) { "SELECT * FROM [customers] WHERE ([customers].[id] = 1)" }
+
+  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|odbc)}
+    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
+    assert connection.table_alias_length <= 128
+  end
+
+  it 'raises invalid statement error for bad SQL' do
+    assert_raise(ActiveRecord::StatementInvalid) { Topic.connection.update("UPDATE XXX") }
+  end
+
+  it 'is has our adapter_name' do
+    assert_equal 'SQLServer', connection.adapter_name
+  end
+
+  it 'supports migrations' do
+    assert connection.supports_migrations?
+  end
+
+  it 'support DDL in transactions' do
+    assert connection.supports_ddl_transactions?
+  end
+
+  it 'allow owner table name prefixs like dbo to still allow table exists to return true' do
+    begin
+      assert_equal 'topics', Topic.table_name
+      assert Topic.table_exists?
+      Topic.table_name = 'dbo.topics'
+      assert Topic.table_exists?, 'Tasks table name of dbo.topics should return true for exists.'
+    ensure
+      Topic.table_name = 'topics'
+    end
+  end
+
+  it 'return true to insert sql query for inserts only' do
+    assert connection.send(:insert_sql?,'INSERT...')
+    assert connection.send(:insert_sql?, "EXEC sp_executesql N'INSERT INTO [fk_test_has_fks] ([fk_id]) VALUES (@0); SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident', N'@0 int', @0 = 0")
+    assert !connection.send(:insert_sql?,'UPDATE...')
+    assert !connection.send(:insert_sql?,'SELECT...')
+  end
+
+  it 'return unquoted table name object from basic INSERT UPDATE and SELECT statements' do
+    assert_equal 'funny_jokes', connection.send(:get_table_name, basic_insert_sql)
+    assert_equal 'customers', connection.send(:get_table_name, basic_update_sql)
+    assert_equal 'customers', connection.send(:get_table_name, basic_select_sql)
+  end
+
+  describe 'with different language' do
+
+    before do
+      @default_language = connection.user_options_language
+    end
+
+    after do
+      connection.execute("SET LANGUAGE #{@default_language}") rescue nil
+      connection.send :initialize_dateformatter
+    end
+
+    it 'memos users dateformat' do
+      connection.execute("SET LANGUAGE us_english") rescue nil
+      dateformat = connection.instance_variable_get(:@database_dateformat)
+      assert_equal 'mdy', dateformat
+    end
+
+    it 'has a dateformatter' do
+      assert Date::DATE_FORMATS[:_sqlserver_dateformat]
+      assert Time::DATE_FORMATS[:_sqlserver_dateformat]
+    end
+
+    it 'does a datetime insertion when language is german' do
+      connection.execute("SET LANGUAGE deutsch")
+      connection.send :initialize_dateformatter
+      assert_nothing_raised do
+        starting = Time.utc(2000, 1, 31, 5, 42, 0)
+        ending = Date.new(2006, 12, 31)
+        Task.create! starting: starting, ending: ending
+      end
+    end
+
+  end
+
+  describe 'testing #lowercase_schema_reflection' do
+
+    before do
+      SSTestUpper.delete_all
+      SSTestUpper.create COLUMN1: 'Got a minute?', COLUMN2: 419
+      SSTestUpper.create COLUMN1: 'Favorite number?', COLUMN2: 69
+    end
+
+    after do
+      connection.lowercase_schema_reflection = false
+    end
+
+    it 'not lowercase schema reflection by default' do
+      assert SSTestUpper.columns_hash['COLUMN1']
+      assert_equal 'Got a minute?', SSTestUpper.first.COLUMN1
+      assert_equal 'Favorite number?', SSTestUpper.last.COLUMN1
+      assert SSTestUpper.columns_hash['COLUMN2']
+    end
+
+    it 'lowercase schema reflection when set' do
+      connection.lowercase_schema_reflection = true
+      assert SSTestUppered.columns_hash['column1']
+      assert_equal 'Got a minute?', SSTestUppered.first.column1
+      assert_equal 'Favorite number?', SSTestUppered.last.column1
+      assert SSTestUppered.columns_hash['column2']
+    end
+
+  end
+
+  describe 'identity inserts' do
+
+    before do
+      @identity_insert_sql = "INSERT INTO [funny_jokes] ([id],[name]) VALUES(420,'Knock knock')"
+      @identity_insert_sql_unquoted = "INSERT INTO funny_jokes (id, name) VALUES(420, 'Knock knock')"
+      @identity_insert_sql_unordered = "INSERT INTO [funny_jokes] ([name],[id]) VALUES('Knock knock',420)"
+      @identity_insert_sql_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] ([id],[name]) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Knock knock'"
+      @identity_insert_sql_unquoted_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] (id, name) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Knock knock'"
+      @identity_insert_sql_unordered_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] ([name],[id]) VALUES (@0, @1)', N'@0 nvarchar(255), @1  int', @0 = N'Knock knock', @1 = 420"
+    end
+
+    it 'return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column' do
+      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql)
+      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted)
+      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered)
+      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_sp)
+      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unquoted_sp)
+      assert_equal '[funny_jokes]', connection.send(:query_requires_identity_insert?,@identity_insert_sql_unordered_sp)
+    end
+
+    it 'return false to #query_requires_identity_insert? for normal SQL' do
+      [basic_insert_sql, basic_update_sql, basic_select_sql].each do |sql|
+        assert !connection.send(:query_requires_identity_insert?,sql), "SQL was #{sql}"
+      end
+    end
+
+    it 'find identity column using #identity_column' 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
+    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)
+    end
+
+  end
+
+  describe 'quoting' do
+
+    it 'return 1 for #quoted_true' do
+      assert_equal '1', connection.quoted_true
+    end
+
+    it 'return 0 for #quoted_false' do
+      assert_equal '0', connection.quoted_false
+    end
+
+    it 'not escape backslash characters like abstract adapter' do
+      string_with_backslashs = "\\n"
+      assert_equal string_with_backslashs, connection.quote_string(string_with_backslashs)
+    end
+
+    it 'quote column names with brackets' do
+      assert_equal '[foo]', connection.quote_column_name(:foo)
+      assert_equal '[foo]', connection.quote_column_name('foo')
+      assert_equal '[foo].[bar]', connection.quote_column_name('foo.bar')
+    end
+
+    it 'not quote already quoted column names with brackets' do
+      assert_equal '[foo]', connection.quote_column_name('[foo]')
+      assert_equal '[foo].[bar]', connection.quote_column_name('[foo].[bar]')
+    end
+
+    it 'quote table names like columns' do
+      assert_equal '[foo].[bar]', connection.quote_column_name('foo.bar')
+      assert_equal '[foo].[bar].[baz]', connection.quote_column_name('foo.bar.baz')
+    end
+
+    it "surround string with national prefix" do
+      assert_equal "N'foo'", connection.quote("foo")
+    end
+
+    it "escape all single quotes by repeating them" do
+      assert_equal "N'''quotation''s'''", connection.quote("'quotation's'")
+    end
+
+  end
+
+  describe 'disabling referential integrity' do
+
+    before do
+      connection.disable_referential_integrity { SSTestHasPk.delete_all; SSTestHasFk.delete_all }
+      @parent = SSTestHasPk.create!
+      @member = SSTestHasFk.create!(fk_id: @parent.id)
+    end
+
+    it 'NOT ALLOW by default the deletion of a referenced parent' do
+      SSTestHasPk.connection.disable_referential_integrity { }
+      assert_raise(ActiveRecord::StatementInvalid) { @parent.destroy }
+    end
+
+    it 'ALLOW deletion of referenced parent using #disable_referential_integrity block' do
+      SSTestHasPk.connection.disable_referential_integrity { @parent.destroy }
+    end
+
+    it 'again NOT ALLOW deletion of referenced parent after #disable_referential_integrity block' do
+      assert_raise(ActiveRecord::StatementInvalid) do
+        SSTestHasPk.connection.disable_referential_integrity { }
+        @parent.destroy
+      end
+    end
+
+  end
+
+  describe 'database statements' do
+
+    it "run the database consistency checker useroptions command" do
+      keys = [:textsize, :language, :isolation_level, :dateformat]
+      user_options = connection.user_options
+      keys.each do |key|
+        msg = "Expected key:#{key} in user_options:#{user_options.inspect}"
+        assert user_options.key?(key), msg
+      end
+    end
+
+    it "return a underscored key hash with indifferent access of the results" do
+      user_options = connection.user_options
+      assert_equal 'read committed', user_options['isolation_level']
+      assert_equal 'read committed', user_options[:isolation_level]
+    end
+
+  end
+
+  describe 'schema statements' do
+
+    it 'create integers when no limit supplied' do
+      assert_equal 'integer', connection.type_to_sql(:integer)
+    end
+
+    it 'create integers when limit is 4' do
+      assert_equal 'integer', connection.type_to_sql(:integer, 4)
+    end
+
+    it 'create integers when limit is 3' do
+      assert_equal 'integer', connection.type_to_sql(:integer, 3)
+    end
+
+    it 'create smallints when limit is less than 3' do
+      assert_equal 'smallint', connection.type_to_sql(:integer, 2)
+      assert_equal 'smallint', connection.type_to_sql(:integer, 1)
+    end
+
+    it 'create bigints when limit is greateer than 4' do
+      assert_equal 'bigint', connection.type_to_sql(:integer, 5)
+      assert_equal 'bigint', connection.type_to_sql(:integer, 6)
+      assert_equal 'bigint', connection.type_to_sql(:integer, 7)
+      assert_equal 'bigint', connection.type_to_sql(:integer, 8)
+    end
+
+    it 'create floats when no limit supplied' do
+      assert_equal 'float', connection.type_to_sql(:float)
+    end
+
+  end
+
+  describe 'indexes' do
+
+    let(:desc_index_name) { 'idx_credit_limit_test_desc' }
+
+    it 'have indexes with descending order' do
+      begin
+        connection.execute "CREATE INDEX [#{desc_index_name}] ON [accounts] (credit_limit DESC)"
+        assert connection.indexes('accounts').find { |i| i.name == desc_index_name }
+      ensure
+        connection.execute "DROP INDEX [#{desc_index_name}] ON [accounts]"
+      end
+    end
+
+  end
+
+  describe 'views' do
+
+    # Using connection.views
+
+    it 'return an array' do
+      assert_instance_of Array, connection.views
+    end
+
+    it 'find SSTestCustomersView table name' do
+      connection.views.must_include 'sst_customers_view'
+    end
+
+    it 'work with dynamic finders' do
+      name = 'MetaSkills'
+      customer = SSTestCustomersView.create! name: name
+      assert_equal customer, SSTestCustomersView.find_by_name(name)
+    end
+
+    it 'not contain system views' do
+      systables = ['sysconstraints','syssegments']
+      systables.each do |systable|
+        assert !connection.views.include?(systable), "This systable #{systable} should not be in the views array."
+      end
+    end
+
+    it 'allow the connection#view_information method to return meta data on the view' do
+      view_info = connection.send(:view_information,'sst_customers_view')
+      assert_equal('sst_customers_view', view_info['TABLE_NAME'])
+      assert_match(/CREATE VIEW sst_customers_view/, view_info['VIEW_DEFINITION'])
+    end
+
+    it 'allow the connection#view_table_name method to return true table_name for the view' do
+      assert_equal 'customers', connection.send(:view_table_name,'sst_customers_view')
+      assert_equal 'topics', connection.send(:view_table_name,'topics'), 'No view here, the same table name should come back.'
+    end
+
+    # With same column names
+
+    it 'have matching column objects' do
+      columns = ['id','name','balance']
+      assert !SSTestCustomersView.columns.blank?
+      assert_equal columns.size, SSTestCustomersView.columns.size
+      columns.each do |colname|
+        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
+          SSTestCustomersView.columns_hash[colname],
+          "Column name #{colname.inspect} was not found in these columns #{SSTestCustomersView.columns.map(&:name).inspect}"
+      end
+    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?
+    end
+
+    it 'find default values' do
+      assert_equal 0, SSTestCustomersView.new.balance
+    end
+
+    it 'respond true to table_exists?' do
+      assert SSTestCustomersView.table_exists?
+    end
+
+    # With aliased column names
+
+    it 'have matching column objects' do
+      columns = ['id','pretend_null']
+      assert !SSTestStringDefaultsView.columns.blank?
+      assert_equal columns.size, SSTestStringDefaultsView.columns.size
+      columns.each do |colname|
+        assert_instance_of ActiveRecord::ConnectionAdapters::SQLServerColumn,
+          SSTestStringDefaultsView.columns_hash[colname],
+          "Column name #{colname.inspect} was not found in these columns #{SSTestStringDefaultsView.columns.map(&:name).inspect}"
+      end
+    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?
+    end
+
+    it 'find default values' do
+      assert_equal 'null', SSTestStringDefaultsView.new.pretend_null,
+        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)
+    end
+
+    # That have more than 4000 chars for their defintion
+
+    it 'cope with null returned for the defintion' do
+      assert_nothing_raised() { SSTestStringDefaultsBigView.columns }
+    end
+
+    it 'using alternate view defintion still be able to find real default' do
+      assert_equal 'null', SSTestStringDefaultsBigView.new.pretend_null,
+        SSTestStringDefaultsBigView.columns_hash['pretend_null'].inspect
+    end
+
+  end
+
+end
+

data/test/cases/coerced_tests.rb

@@ -0,0 +1,642 @@
+require 'cases/helper_sqlserver'
+
+
+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
+
+  end
+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')
+    topic = Topic.all.merge!(:select => "topics.*, IIF (1 = 2, 1, 0) as is_test").first
+    assert !topic.is_test?
+  end
+
+  coerce_tests! :test_typecast_attribute_from_select_to_true
+  def test_typecast_attribute_from_select_to_true_coerced
+    Topic.create(:title => 'Budget')
+    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
+  end
+
+  # 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. Second, since we allow the DB to win at casting for TinyTDS,
+  # it always comes back as a BigDecimal.
+  coerce_tests! :test_numeric_fields
+
+  # Just like PostgreSQLAdapter does.
+  coerce_tests! :test_respect_internal_encoding
+
+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
+
+  coerce_tests! :test_belongs_to_with_primary_key_joins_on_correct_column
+  def test_belongs_to_with_primary_key_joins_on_correct_column_coerced
+    sql = Client.joins(:firm_with_primary_key).to_sql
+    assert_no_match(/\[firm_with_primary_keys_companies\]\.\[id\]/, sql)
+    assert_match(/\[firm_with_primary_keys_companies\]\.\[name\]/, sql)
+  end
+
+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
+
+  end
+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
+    value = Account.average(:id)
+    assert_equal BigDecimal('3.0').to_s, BigDecimal(value).to_s
+  end
+
+  coerce_tests! :test_limit_is_kept
+  def test_limit_is_kept_coerced
+    queries = assert_sql { 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}
+  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 }
+    assert_equal 1, queries.length
+    queries.first.must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET 1 ROWS FETCH NEXT 1 ROWS ONLY}
+  end
+
+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
+  end
+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
+        add_column :test_models, :description, :string, limit: nil
+        TestModel.reset_column_information
+        TestModel.columns_hash["description"].limit.must_equal 4000
+      end
+
+    end
+  end
+end
+
+
+
+
+module ActiveRecord
+  class Migration
+    class ColumnsTest
+
+      # Our defaults are reall 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"
+        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
+      end
+
+      # Dropping the column removes the single index.
+      coerce_tests! :test_remove_column_with_multi_column_index
+      def test_remove_column_with_multi_column_index_coerced
+        add_column "test_models", :hat_size, :integer
+        add_column "test_models", :hat_style, :string, :limit => 100
+        add_index "test_models", ["hat_style", "hat_size"], :unique => true
+        assert_equal 1, connection.indexes('test_models').size
+        remove_column("test_models", "hat_size")
+        assert_equal [], connection.indexes('test_models').map(&:name)
+      end
+
+    end
+  end
+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
+
+
+
+
+module ActiveRecord
+  module ConnectionAdapters
+
+    # Just like PostgreSQLAdapter does.
+    TypeLookupTest.coerce_all_tests! if defined?(TypeLookupTest)
+
+    # All sorts of errors due to how we test. Even setting ENV['RAILS_ENV'] to
+    # 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
+
+
+
+
+class DefaultScopingTest < ActiveRecord::TestCase
+
+  # We are not doing order duplicate removal anymore.
+  coerce_tests! :test_order_in_default_scope_should_not_prevail
+
+end
+
+
+
+
+require 'models/post'
+require 'models/subscriber'
+class EachTest < ActiveRecord::TestCase
+
+  coerce_tests! :test_find_in_batches_should_quote_batch_order
+  def test_find_in_batches_should_quote_batch_order_coerced
+    c = Post.connection
+    assert_sql(/ORDER BY \[posts\]\.\[id\]/) do
+      Post.find_in_batches(:batch_size => 1) do |batch|
+        assert_kind_of Array, batch
+        assert_kind_of Post, batch.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
+    assert_equal 3, authors(:david).posts_with_comments.where("LEN(comments.body) > 15").references(:comments).count
+  end
+
+  # 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
+
+
+
+
+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
+      Topic.exists?
+    end
+  end
+
+  coerce_tests! :test_string_sanitation
+  def test_string_sanitation_coerced
+    assert_not_equal "'something ' 1=1'", ActiveRecord::Base.sanitize("something ' 1=1")
+    assert_equal "N'something; select table'", ActiveRecord::Base.sanitize("something; select table")
+  end
+
+  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 }
+  end
+
+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
+
+
+
+
+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
+      Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
+    end
+    assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
+  end
+
+  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
+      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
+
+  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
+    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
+    # SQLServer: We rock and cast during assignment.
+    assert_kind_of BigDecimal, b.world_population
+    assert_equal BigDecimal('6000000000'), b.world_population
+    # TODO: Our trust the DB policy breaks this expectation. Review SQLServer::Type::Castable module.
+    skip
+    assert_kind_of Fixnum, 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
+    assert_kind_of BigDecimal, b.value_of_e
+    assert_equal BigDecimal("2.7182818284590452353602875"), b.value_of_e
+    GiveMeBigNumbers.down
+    assert_raise(ActiveRecord::StatementInvalid) { BigNumber.first }
+  end
+
+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
+      Developer.limit(10).scoping do
+        devs = Developer.all
+        sql = devs.to_sql
+        assert_match '(salary = 80000)', sql
+        assert_match 'FETCH NEXT 10 ROWS ONLY', sql
+      end
+    end
+  end
+
+end
+
+
+
+
+require 'models/topic'
+class PersistenceTest < ActiveRecord::TestCase
+
+  # We can not UPDATE identity columns.
+  coerce_tests! :test_update_columns_changing_id
+
+  # Previous test required updating a identity column.
+  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
+    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'
+  end
+
+  # We can not UPDATE identity columns.
+  coerce_tests! :test_update_attributes
+  def test_update_attributes_coerced
+    topic = Topic.find(1)
+    assert !topic.approved?
+    assert_equal "The First Topic", topic.title
+    topic.update_attributes("approved" => true, "title" => "The First Topic Updated")
+    topic.reload
+    assert topic.approved?
+    assert_equal "The First Topic Updated", topic.title
+    topic.update_attributes(approved: false, title: "The First Topic")
+    topic.reload
+    assert !topic.approved?
+    assert_equal "The First Topic", topic.title
+    # SQLServer: Here is where it breaks down. No exceptions.
+    # assert_raise(ActiveRecord::RecordNotUnique, ActiveRecord::StatementInvalid) do
+    #   topic.update_attributes(id: 3, title: "Hm is it possible?")
+    # end
+    # assert_not_equal "Hm is it possible?", Topic.find(3).title
+    # topic.update_attributes(id: 1234)
+    # assert_nothing_raised { topic.reload }
+    # assert_equal topic.title, Topic.find(1234).title
+  end
+
+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|
+        Arel::Nodes::InfixOperation.new('~', column, Arel.sql(value.source))
+      end)
+      assert_match %r{\[topics\]\.\[title\] ~ rails}i, Topic.where(title: /rails/).to_sql
+    end
+
+  end
+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
+
+
+
+
+require 'models/post'
+class RelationTest < ActiveRecord::TestCase
+
+  # We have implicit ordering, via FETCH.
+  coerce_tests! %r{doesn't have implicit ordering}
+
+  # 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
+
+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
+      def self.search(term)
+        where("title LIKE ?", sanitize_sql_like(term, '!'))
+      end
+    end
+    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
+    output = standard_dump
+    assert_match %r{t.decimal\s+"atoms_in_universe",\s+precision: 38}, output
+  end
+
+  # This accidently returns the wrong number because of our tables too.
+  coerce_tests! :test_types_line_up
+
+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
+
+
+
+
+require 'models/topic'
+class TransactionTest < ActiveRecord::TestCase
+
+  coerce_tests! :test_releasing_named_savepoints
+  def test_releasing_named_savepoints_coerced
+    Topic.transaction do
+      Topic.connection.create_savepoint("another")
+      Topic.connection.release_savepoint("another")
+      # We do not have a notion of releasing, so this does nothing vs raise an error.
+      Topic.connection.release_savepoint("another")
+    end
+  end
+
+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}
+  test "read committed coerced" do
+    Tag.transaction(isolation: :read_committed) do
+      assert_equal 0, Tag.count
+      Tag2.transaction do
+        Tag2.create
+        assert_equal 0, Tag.lock('WITH(READPAST)').count
+      end
+    end
+    assert_equal 1, Tag.count
+  end
+
+  # 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
+
+
+
+
+class ViewWithPrimaryKeyTest < ActiveRecord::TestCase
+
+  # We do better than ActiveRecord and find the views PK.
+  coerce_tests! :test_does_not_assume_id_column_as_primary_key
+
+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
+    dumped = YAML.load(YAML.dump(author))
+    assert_equal 5, author.posts_count
+    assert_equal 5, dumped.posts_count
+  end
+
+end
+