activerecord-jdbcsqlserver-adapter 50.0.0 → 52.0.0

data/test/bin/setup.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -x
+set -e
+
+tag=2017-GA
+
+docker pull metaskills/mssql-server-linux-rails:$tag
+
+container=$(docker ps -a -q --filter ancestor=metaskills/mssql-server-linux-rails:$tag)
+if [[ -z $container ]]; then
+  docker run -p 1433:1433 -d metaskills/mssql-server-linux-rails:$tag && sleep 10
+  exit
+fi
+
+container=$(docker ps -q --filter ancestor=metaskills/mssql-server-linux-rails:$tag)
+if [[ -z $container ]]; then
+  docker start $container && sleep 10
+fi

data/test/cases/adapter_test_sqlserver.rb

@@ -13,16 +13,17 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
   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
+  it 'has basic and non-sensitive information in the adapters 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|jdbc)}
-    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|jdbc)}
+    _(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
@@ -37,10 +38,6 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     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
@@ -145,12 +142,12 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     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)
+      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
@@ -166,7 +163,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
@@ -236,6 +233,11 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       end
     end
 
+    it 'not disable referential integrity for the same table twice' do
+      tables = SSTestHasPk.connection.tables_with_referential_integrity
+      assert_equal tables.size, tables.uniq.size
+    end
+
   end
 
   describe 'database statements' do
@@ -266,23 +268,26 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
     end
 
     it 'create integers when limit is 4' do
-      assert_equal 'integer', connection.type_to_sql(:integer, 4)
+      assert_equal 'integer', connection.type_to_sql(:integer, limit: 4)
     end
 
     it 'create integers when limit is 3' do
-      assert_equal 'integer', connection.type_to_sql(:integer, 3)
+      assert_equal 'integer', connection.type_to_sql(:integer, limit: 3)
+    end
+
+    it 'create smallints when limit is 2' do
+      assert_equal 'smallint', connection.type_to_sql(:integer, limit: 2)
     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)
+    it 'create tinyints when limit is 1' do
+      assert_equal 'tinyint', connection.type_to_sql(:integer, limit: 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)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 5)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 6)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 7)
+      assert_equal 'bigint', connection.type_to_sql(:integer, limit: 8)
     end
 
     it 'create floats when no limit supplied' do
@@ -300,7 +305,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
@@ -341,9 +346,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
@@ -368,9 +373,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
@@ -419,12 +424,11 @@ 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
   end
 
 end
-

data/test/cases/change_column_null_test_sqlserver.rb

@@ -0,0 +1,42 @@
+require 'cases/helper_sqlserver'
+require 'migrations/create_clients_and_change_column_null'
+
+class ChangeColumnNullTestSqlServer < ActiveRecord::TestCase
+  before do
+    @old_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+    CreateClientsAndChangeColumnNull.new.up
+  end
+
+  after do
+    CreateClientsAndChangeColumnNull.new.down
+    ActiveRecord::Migration.verbose = @old_verbose
+  end
+
+  def find_column(table, name)
+    table.find { |column| column.name == name }
+  end
+
+  let(:clients_table) { connection.columns('clients') }
+  let(:name_column) { find_column(clients_table, 'name') }
+  let(:code_column) { find_column(clients_table, 'code') }
+  let(:value_column) { find_column(clients_table, 'value') }
+
+  describe '#change_column_null' do
+    it 'does not change the column limit' do
+      _(name_column.limit).must_equal 15
+    end
+
+    it 'does not change the column default' do
+      _(code_column.default).must_equal 'n/a'
+    end
+
+    it 'does not change the column precision' do
+      _(value_column.precision).must_equal 32
+    end
+
+    it 'does not change the column scale' do
+      _(value_column.scale).must_equal 8
+    end
+  end
+end

data/test/cases/coerced_tests.rb

@@ -31,6 +31,10 @@ end
 require 'models/event'
 module ActiveRecord
   class AdapterTest < ActiveRecord::TestCase
+    # I really dont think we can support legacy binds.
+    coerce_tests! :test_select_all_with_legacy_binds
+    coerce_tests! :test_insert_update_delete_with_legacy_binds
+
     # As far as I can tell, SQL Server does not support null bytes in strings.
     coerce_tests! :test_update_prepared_statement
     coerce_tests! :test_log_invalid_encoding if defined? JRUBY_VERSION # JRuby just happily converts the encoding
@@ -53,14 +57,14 @@ end
 
 require 'models/topic'
 class AttributeMethodsTest < ActiveRecord::TestCase
-  coerce_tests! :test_typecast_attribute_from_select_to_false
+  coerce_tests! %r{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
+  coerce_tests! %r{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
@@ -69,7 +73,11 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 end
 
 
-
+class NumericDataTest < ActiveRecord::TestCase
+  # We do not have do the DecimalWithoutScale type.
+  coerce_tests! :test_numeric_fields
+  coerce_tests! :test_numeric_fields_with_scale
+end
 
 class BasicsTest < ActiveRecord::TestCase
   coerce_tests! :test_column_names_are_escaped
@@ -78,16 +86,44 @@ class BasicsTest < ActiveRecord::TestCase
     assert_equal '[t]]]', conn.quote_column_name('t]')
   end
 
-  # We do not have do the DecimalWithoutScale type.
-  coerce_tests! :test_numeric_fields
-  coerce_tests! :test_numeric_fields_with_scale
-
   # Just like PostgreSQLAdapter does.
   coerce_tests! :test_respect_internal_encoding
 
   # 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
+
+  def test_update_date_time_attributes
+    Time.use_zone("Eastern Time (US & Canada)") do
+      topic = Topic.find(1)
+      time = Time.zone.parse("2017-07-17 10:56")
+      topic.update_attributes!(written_on: time)
+      assert_equal(time, topic.written_on)
+    end
+  end
+
+  def test_update_date_time_attributes_with_default_timezone_local
+    with_env_tz 'America/New_York' do
+      with_timezone_config default: :local do
+        Time.use_zone("Eastern Time (US & Canada)") do
+          topic = Topic.find(1)
+          time = Time.zone.parse("2017-07-17 10:56")
+          topic.update_attributes!(written_on: time)
+          assert_equal(time, topic.written_on)
+        end
+      end
+    end
+  end
+
+  # Need to escape `quoted_id` once it contains brackets
+  coerce_tests! %r{column names are quoted when using #from clause and model has ignored columns}
+  test "column names are quoted when using #from clause and model has ignored columns coerced" do
+    refute_empty Developer.ignored_columns
+    query = Developer.from("developers").to_sql
+    quoted_id = "#{Developer.quoted_table_name}.#{Developer.quoted_primary_key}"
+
+    assert_match(/SELECT #{Regexp.escape(quoted_id)}.* FROM developers/, query)
+  end
 end
 
 
@@ -108,17 +144,63 @@ end
 
 
 
+# module ActiveRecord
+#   class BindParameterTest < ActiveRecord::TestCase
+#     # 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
+
+
 module ActiveRecord
-  class BindParameterTest < ActiveRecord::TestCase
-    # Never finds `sql` since we use `EXEC sp_executesql` wrappers.
-    coerce_tests! :test_binds_are_logged
+  class InstrumentationTest < ActiveRecord::TestCase
+    # This fails randomly due to schema cache being lost?
+    coerce_tests! :test_payload_name_on_load
+    def test_payload_name_on_load_coerced
+      Book.create(name: "test book")
+      Book.first
+      subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        if event.payload[:sql].match "SELECT"
+          assert_equal "Book Load", event.payload[:name]
+        end
+      end
+      Book.first
+    ensure
+      ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+    end
   end
 end
 
-
-
-
 class CalculationsTest < ActiveRecord::TestCase
+  # This fails randomly due to schema cache being lost?
+  coerce_tests! :test_offset_is_kept
+  def test_offset_is_kept_coerced
+    Account.first
+    queries = assert_sql { Account.offset(1).count }
+    assert_equal 1, queries.length
+    assert_match(/OFFSET/, queries.first)
+  end
+
   # Are decimal, not integer.
   coerce_tests! :test_should_return_decimal_average_of_integer_field
   def test_should_return_decimal_average_of_integer_field_coerced
@@ -130,28 +212,36 @@ 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 unless defined? JRUBY_VERSION
 
   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 \? ROWS ONLY}
+    _(queries.first).must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET 0 ROWS FETCH NEXT \? ROWS ONLY}
   end if defined? JRUBY_VERSION
 
   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 unless defined? JRUBY_VERSION
 
   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 \? ROWS FETCH NEXT \? ROWS ONLY}
+    _(queries.first).must_match %r{ORDER BY \[accounts\]\.\[id\] ASC OFFSET \? ROWS FETCH NEXT \? ROWS ONLY}
   end if defined? JRUBY_VERSION
 
+  # SQL Server needs an alias for the calculated column
+  coerce_tests! :test_distinct_count_all_with_custom_select_and_order
+  def test_distinct_count_all_with_custom_select_and_order_coerced
+    accounts = Account.distinct.select("credit_limit % 10 AS the_limit").order(Arel.sql("credit_limit % 10"))
+    assert_queries(1) { assert_equal 3, accounts.count(:all) }
+    assert_queries(1) { assert_equal 3, accounts.load.size }
+  end
+
   # Leave it up to users to format selects/functions so HAVING works correctly.
   coerce_tests! :test_having_with_strong_parameters
 end
@@ -165,6 +255,7 @@ module ActiveRecord
       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
@@ -174,6 +265,29 @@ end
 
 
 
+module ActiveRecord
+  module ConnectionAdapters
+    class QuoteARBaseTest < ActiveRecord::TestCase
+
+      # Use our date format.
+      coerce_tests! :test_quote_ar_object
+      def test_quote_ar_object_coerced
+        value = DatetimePrimaryKey.new(id: @time)
+        assert_equal "'02-14-2017 12:34:56.789'",  @connection.quote(value)
+      end
+
+      # Use our date format.
+      coerce_tests! :test_type_cast_ar_object
+      def test_type_cast_ar_object_coerced
+        value = DatetimePrimaryKey.new(id: @time)
+        assert_equal "02-14-2017 12:34:56.789",  @connection.type_cast(value)
+      end
+
+    end
+  end
+end
+
+
 
 module ActiveRecord
   class Migration
@@ -183,7 +297,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
@@ -269,7 +383,7 @@ class MigrationTest < ActiveRecord::TestCase
   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_when_other_data_exists
   coerce_tests! :test_internal_metadata_stores_environment
 end
 
@@ -295,6 +409,7 @@ 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)
+    ConnectionHandlerTest.coerce_all_tests! if defined?(ConnectionHandlerTest)
   end
 end
 
@@ -302,6 +417,10 @@ end
 
 
 module ActiveRecord
+  class DatabaseTasksDumpSchemaCacheTest < ActiveRecord::TestCase
+    # Skip this test with /tmp/my_schema_cache.yml path on Windows.
+    coerce_tests! :test_dump_schema_cache if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+  end
   class DatabaseTasksCreateAllTest < ActiveRecord::TestCase
     # We extend `local_database?` so that common VM IPs can be used.
     coerce_tests! :test_ignores_remote_databases, :test_warning_for_remote_databases
@@ -395,12 +514,6 @@ class FinderTest < ActiveRecord::TestCase
     end
   end if defined? JRUBY_VERSION
 
-  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 @0 ROWS ONLY.* @0 = 3/) { Topic.take(3).entries }
@@ -485,7 +598,7 @@ 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\] = 1/) do
+    assert_sql(/\[companies\]\.\[id\] = \?/) do
       Account.all.merge!(:includes => :firm).find(1)
     end
   end
@@ -538,6 +651,7 @@ end
 
 
 
+require 'models/parrot'
 require 'models/topic'
 class PersistenceTest < ActiveRecord::TestCase
   # We can not UPDATE identity columns.
@@ -547,14 +661,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.
@@ -580,6 +694,19 @@ class PersistenceTest < ActiveRecord::TestCase
     # assert_nothing_raised { topic.reload }
     # assert_equal topic.title, Topic.find(1234).title
   end
+
+  coerce_tests! :test_delete_new_record
+  def test_delete_new_record_coerced
+    client = Client.new(name: "37signals")
+    client.delete
+    assert_predicate client, :frozen?
+
+    assert_not client.save
+    assert_raise(ActiveRecord::RecordNotSaved) { client.save! }
+
+    assert_predicate client, :frozen?
+    assert_raise(FrozenError) { client.name = "something else" } # For some reason we get a FrozenError instead of a RuntimeError here
+  end
 end
 
 
@@ -603,10 +730,19 @@ end
 
 
 
+class PrimaryKeysTest < ActiveRecord::TestCase
+  # Gonna trust Rails core for this. We end up with 2 querys vs 3 asserted
+  # but as far as I can tell, this is only one for us anyway.
+  coerce_tests! :test_create_without_primary_key_no_extra_query
+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
+  coerce_tests! :test_cache_does_not_wrap_results_in_arrays
+  def test_cache_does_not_wrap_results_in_arrays_coerced
     Task.cache do
       assert_kind_of Numeric, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
     end
@@ -621,16 +757,16 @@ 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
+    topics = Topic.order(Arel.sql("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
+    topics = Topic.order(Arel.sql("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
+    topics = Topic.order(Arel.sql("LEN(author_name), id, LEN(title)")).reverse_order
     assert_equal topics(:fifth).title, topics.first.title
   end
 
@@ -646,6 +782,60 @@ class RelationTest < ActiveRecord::TestCase
   # 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
+
+  # Find any limit via our expression.
+  coerce_tests! %r{relations don't load all records in #inspect}
+  def test_relations_dont_load_all_records_in_inspect_coerced
+    assert_sql(/NEXT \? ROWS ONLY/) do
+      Post.all.inspect
+    end
+  end
+
+  # I wanted to add `.order("author_id")` scope to avoid error: Column "posts.id" is invalid in the ORDER BY
+  # However, this pull request on Rails core drops order on exists relation. https://github.com/rails/rails/pull/28699
+  # so we are skipping all together.
+  coerce_tests! :test_empty_complex_chained_relations
+
+  # Can't apply offset withour ORDER
+  coerce_tests! %r{using a custom table affects the wheres}
+  test 'using a custom table affects the wheres coerced' do
+    post = posts(:welcome)
+
+    assert_equal post, custom_post_relation.where!(title: post.title).order(:id).take
+  end
+
+  # Can't apply offset withour ORDER
+  coerce_tests! %r{using a custom table with joins affects the joins}
+  test 'using a custom table with joins affects the joins coerced' do
+    post = posts(:welcome)
+
+    assert_equal post, custom_post_relation.joins(:author).where!(title: post.title).order(:id).take
+  end
+
+  # Use LEN() vs length() function.
+  coerce_tests! :test_reverse_arel_assoc_order_with_function
+  def test_reverse_arel_assoc_order_with_function_coerced
+    topics = Topic.order(Arel.sql("LEN(title)") => :asc).reverse_order
+    assert_equal topics(:second).title, topics.first.title
+  end
+end
+
+class ActiveRecord::RelationTest < ActiveRecord::TestCase
+  coerce_tests! :test_relation_merging_with_merged_symbol_joins_is_aliased
+  def test_relation_merging_with_merged_symbol_joins_is_aliased__coerced
+    categorizations_with_authors = Categorization.joins(:author)
+    queries = capture_sql { Post.joins(:author, :categorizations).merge(Author.select(:id)).merge(categorizations_with_authors).to_a }
+
+    nb_inner_join = queries.sum { |sql| sql.scan(/INNER\s+JOIN/i).size }
+    assert_equal 3, nb_inner_join, "Wrong amount of INNER JOIN in query"
+
+    # using `\W` as the column separator
+    query_matches = queries.any? do |sql|
+      %r[INNER\s+JOIN\s+#{Regexp.escape(Author.quoted_table_name)}\s+\Wauthors_categorizations\W]i.match?(sql)
+    end
+
+    assert query_matches, "Should be aliasing the child INNER JOINs in query"
+  end
 end
 
 
@@ -677,9 +867,6 @@ class SchemaDumperTest < ActiveRecord::TestCase
     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
-
   # This is a poorly written test and really does not catch the bottom'ness it is meant too. Ours throw it off.
   coerce_tests! :test_foreign_keys_are_dumped_at_the_bottom_to_circumvent_dependency_issues
 
@@ -803,10 +990,55 @@ class DateTimePrecisionTest < ActiveRecord::TestCase
       end
     end
   end
+
+  unless defined? JRUBY_VERSION
+    # datetime is rounded to increments of .000, .003, or .007 seconds
+    coerce_tests! :test_datetime_precision_is_truncated_on_assignment
+    def test_datetime_precision_is_truncated_on_assignment_coerced
+      @connection.create_table(:foos, force: true)
+      @connection.add_column :foos, :created_at,  :datetime, precision: 0
+      @connection.add_column :foos, :updated_at, :datetime, precision: 6
+
+      time = ::Time.now.change(nsec: 123456789)
+      foo = Foo.new(created_at: time, updated_at: time)
+
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123457000, foo.updated_at.nsec
+
+      foo.save!
+      foo.reload
+
+      assert_equal 0, foo.created_at.nsec
+      assert_equal 123457000, foo.updated_at.nsec
+    end
+  end
 end
 
 
 
+class TimePrecisionTest < ActiveRecord::TestCase
+  # datetime is rounded to increments of .000, .003, or .007 seconds
+  coerce_tests! :test_time_precision_is_truncated_on_assignment
+  def test_time_precision_is_truncated_on_assignment_coerced
+    @connection.create_table(:foos, force: true)
+    @connection.add_column :foos, :start,  :time, precision: 0
+    @connection.add_column :foos, :finish, :time, precision: 6
+
+    time = ::Time.now.change(nsec: 123456789)
+    foo = Foo.new(start: time, finish: time)
+
+    assert_equal 0, foo.start.nsec
+    assert_equal 123457000, foo.finish.nsec
+
+    foo.save!
+    foo.reload
+
+    assert_equal 0, foo.start.nsec
+    assert_equal 123457000, foo.finish.nsec
+  end
+end unless defined? JRUBY_VERSION
+
+
 
 class DefaultNumbersTest < ActiveRecord::TestCase
   # We do better with native types and do not return strings for everything.
@@ -843,3 +1075,151 @@ module ActiveRecord
     #coerce_tests! :test_find_does_not_use_statement_cache_if_table_name_is_changed
   end
 end
+
+
+
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SchemaCacheTest < ActiveRecord::TestCase
+      private
+      # We need to give the full path for this to work.
+      def schema_dump_path
+        File.join ARTest::SQLServer.root_activerecord, 'test/assets/schema_dump_5_1.yml'
+      end
+    end
+  end
+end
+
+class UnsafeRawSqlTest < ActiveRecord::TestCase
+  coerce_tests! %r{always allows Arel}
+  test 'order: always allows Arel' do
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(Arel.sql("len(title)")).pluck(:title) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(Arel.sql("len(title)")).pluck(:title) }
+
+    assert_equal ids_depr, ids_disabled
+  end
+
+  test "pluck: always allows Arel" do
+    values_depr     = with_unsafe_raw_sql_deprecated { Post.includes(:comments).pluck(:title, Arel.sql("len(title)")) }
+    values_disabled = with_unsafe_raw_sql_disabled   { Post.includes(:comments).pluck(:title, Arel.sql("len(title)")) }
+
+    assert_equal values_depr, values_disabled
+  end
+
+
+  coerce_tests! %r{order: disallows invalid Array arguments}
+  test "order: disallows invalid Array arguments" do
+    with_unsafe_raw_sql_disabled do
+      assert_raises(ActiveRecord::UnknownAttributeReference) do
+        Post.order(["author_id", "len(title)"]).pluck(:id)
+      end
+    end
+  end
+
+  coerce_tests! %r{order: allows valid Array arguments}
+  test "order: allows valid Array arguments" do
+    ids_expected = Post.order(Arel.sql("author_id, len(title)")).pluck(:id)
+
+    ids_depr     = with_unsafe_raw_sql_deprecated { Post.order(["author_id", Arel.sql("len(title)")]).pluck(:id) }
+    ids_disabled = with_unsafe_raw_sql_disabled   { Post.order(["author_id", Arel.sql("len(title)")]).pluck(:id) }
+
+    assert_equal ids_expected, ids_depr
+    assert_equal ids_expected, ids_disabled
+  end
+
+  coerce_tests! %r{order: logs deprecation warning for unrecognized column}
+  test "order: logs deprecation warning for unrecognized column" do
+    with_unsafe_raw_sql_deprecated do
+      assert_deprecated(/Dangerous query method/) do
+        Post.order("len(title)")
+      end
+    end
+  end
+
+  coerce_tests! %r{pluck: disallows invalid column name}
+  test "pluck: disallows invalid column name" do
+     with_unsafe_raw_sql_disabled do
+       assert_raises(ActiveRecord::UnknownAttributeReference) do
+         Post.pluck("len(title)")
+       end
+     end
+   end
+
+   coerce_tests! %r{pluck: disallows invalid column name amongst valid names}
+   test "pluck: disallows invalid column name amongst valid names" do
+     with_unsafe_raw_sql_disabled do
+       assert_raises(ActiveRecord::UnknownAttributeReference) do
+         Post.pluck(:title, "len(title)")
+       end
+     end
+   end
+
+   coerce_tests! %r{pluck: disallows invalid column names with includes}
+   test "pluck: disallows invalid column names with includes" do
+     with_unsafe_raw_sql_disabled do
+       assert_raises(ActiveRecord::UnknownAttributeReference) do
+         Post.includes(:comments).pluck(:title, "len(title)")
+       end
+     end
+   end
+
+   coerce_tests! %r{pluck: logs deprecation warning}
+   test "pluck: logs deprecation warning" do
+     with_unsafe_raw_sql_deprecated do
+       assert_deprecated(/Dangerous query method/) do
+         Post.includes(:comments).pluck(:title, "len(title)")
+       end
+     end
+   end
+end
+
+
+class ReservedWordTest < ActiveRecord::TestCase
+  coerce_tests! :test_change_columns
+  def test_change_columns_coerced
+    assert_nothing_raised { @connection.change_column_default(:group, :order, "whatever") }
+    assert_nothing_raised { @connection.change_column("group", "order", :text) }
+    assert_nothing_raised { @connection.change_column_null("group", "order", true) }
+    assert_nothing_raised { @connection.rename_column(:group, :order, :values) }
+  end
+end
+
+
+
+class OptimisticLockingTest < ActiveRecord::TestCase
+  # We do not allow updating identities, but we can test using a non-identity key
+  coerce_tests! :test_update_with_dirty_primary_key
+  def test_update_with_dirty_primary_key_coerced
+    assert_raises(ActiveRecord::RecordNotUnique) do
+      record = StringKeyObject.find('record1')
+      record.id = 'record2'
+      record.save!
+    end
+
+    record = StringKeyObject.find('record1')
+    record.id = 'record42'
+    record.save!
+
+    assert StringKeyObject.find('record42')
+    assert_raises(ActiveRecord::RecordNotFound) do
+      StringKeyObject.find('record1')
+    end
+  end
+end
+
+
+
+class RelationMergingTest < ActiveRecord::TestCase
+  coerce_tests! :test_merging_with_order_with_binds
+  def test_merging_with_order_with_binds_coerced
+    relation = Post.all.merge(Post.order([Arel.sql("title LIKE ?"), "%suffix"]))
+    assert_equal ["title LIKE N'%suffix'"], relation.order_values
+  end
+end
+
+
+class EagerLoadingTooManyIdsTest < ActiveRecord::TestCase
+  # Temporarily coerce this test due to https://github.com/rails/rails/issues/34945
+  coerce_tests! :test_eager_loading_too_may_ids
+end