ibm_db 5.6.1 → 5.7.0

data/test/cases/calculations_test.rb

@@ -12,6 +12,7 @@ require "models/author"
 require "models/topic"
 require "models/reply"
 require "models/numeric_data"
+require "models/need_quoting"
 require "models/minivan"
 require "models/speedometer"
 require "models/ship_part"
@@ -20,27 +21,74 @@ require "models/developer"
 require "models/post"
 require "models/comment"
 require "models/rating"
+require "models/too_long_table_name"
 require "support/stubs/strong_parameters"
+require "support/async_helper"
+require "models/cpk"
 
 class CalculationsTest < ActiveRecord::TestCase
-  fixtures :companies, :accounts, :authors, :author_addresses, :topics, :speedometers, :minivans, :books, :posts, :comments
+  include AsyncHelper
+
+  fixtures :companies, :accounts, :authors, :author_addresses, :topics, :speedometers, :minivans, :books, :posts, :comments, :cpk_books
 
   def test_should_sum_field
     assert_equal 318, Account.sum(:credit_limit)
+    assert_async_equal 318, Account.async_sum(:credit_limit)
   end
 
   def test_should_sum_arel_attribute
     assert_equal 318, Account.sum(Account.arel_table[:credit_limit])
+    assert_async_equal 318, Account.async_sum(Account.arel_table[:credit_limit])
+  end
+
+  def test_should_sum_with_qualified_name_on_loaded
+    accounts = Account.all
+
+    assert_not_predicate accounts, :loaded?
+    assert_equal 318, accounts.sum("accounts.credit_limit")
+
+    accounts.load
+
+    assert_predicate accounts, :loaded?
+    if current_adapter?(:IBM_DBAdapter)
+      assert_equal 318, accounts.to_a.sum(&:credit_limit)
+    else
+      assert_equal 318, accounts.sum("accounts.credit_limit")
+    end
+  end
+
+  def test_should_count_with_group_by_qualified_name_on_loaded
+    accounts = if current_adapter?(:IBM_DBAdapter)
+      # DB2 requires selected columns to be grouped; select only id for this grouped-count path.
+      Account.select(:id).group("accounts.id")
+    else
+      Account.group("accounts.id")
+    end
+
+    expected = { 1 => 1, 2 => 1, 3 => 1, 4 => 1, 5 => 1, 6 => 1 }
+
+    assert_not_predicate accounts, :loaded?
+    assert_equal expected, accounts.count
+
+    accounts.load
+
+    assert_predicate accounts, :loaded?
+    if current_adapter?(:IBM_DBAdapter)
+      loaded_grouped_counts = accounts.to_a.group_by(&:id).transform_values(&:size)
+      assert_equal expected, loaded_grouped_counts
+    else
+      assert_equal expected, accounts.count
+    end
   end
 
   def test_should_average_field
-    value = Account.average(:credit_limit)
-    assert_equal 53.0, value
+    assert_equal 53.0, Account.average(:credit_limit)
+    assert_async_equal 53.0, Account.async_average(:credit_limit)
   end
 
   def test_should_average_arel_attribute
-    value = Account.average(Account.arel_table[:credit_limit])
-    assert_equal 53.0, value
+    assert_equal 53.0, Account.average(Account.arel_table[:credit_limit])
+    assert_async_equal 53.0, Account.async_average(Account.arel_table[:credit_limit])
   end
 
   def test_should_resolve_aliased_attributes
@@ -49,14 +97,40 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_return_decimal_average_of_integer_field
     value = Account.average(:id)
+
     assert_equal 3.5, value
+    assert_instance_of BigDecimal, value
   end
 
   def test_should_return_integer_average_if_db_returns_such
-    ShipPart.delete_all
-    ShipPart.create!(id: 3, name: "foo")
-    value = ShipPart.average(:id)
-    assert_equal 3, value
+    value = Book.average(:status)
+
+    assert_equal 1.0, value
+    assert_instance_of BigDecimal, value
+  end
+
+  def test_should_return_float_average_if_db_returns_such
+    NumericData.create!(temperature: 37.5)
+    value = NumericData.average(:temperature)
+
+    assert_equal 37.5, value
+    assert_instance_of Float, value
+
+    if current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
+      NumericData.create!(temperature: "Infinity")
+      value = NumericData.average(:temperature)
+
+      assert_equal Float::INFINITY, value
+      assert_instance_of Float, value
+    end
+  end
+
+  def test_should_return_decimal_average_if_db_returns_such
+    NumericData.create!([{ bank_balance: 37.50 }, { bank_balance: 37.45 }])
+    value = NumericData.average(:bank_balance)
+
+    assert_equal 37.475, value
+    assert_instance_of BigDecimal, value
   end
 
   def test_should_return_nil_as_average
@@ -65,14 +139,18 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_get_maximum_of_field
     assert_equal 60, Account.maximum(:credit_limit)
+    assert_async_equal 60, Account.async_maximum(:credit_limit)
   end
 
   def test_should_get_maximum_of_arel_attribute
     assert_equal 60, Account.maximum(Account.arel_table[:credit_limit])
+    assert_async_equal 60, Account.async_maximum(Account.arel_table[:credit_limit])
   end
 
   def test_should_get_maximum_of_field_with_include
-    assert_equal 55, Account.where("companies.name != 'Summit'").references(:companies).includes(:firm).maximum(:credit_limit)
+    relation = Account.where("companies.name != 'Summit'").references(:companies).includes(:firm)
+    assert_equal 55, relation.maximum(:credit_limit)
+    assert_async_equal 55, relation.async_maximum(:credit_limit)
   end
 
   def test_should_get_maximum_of_arel_attribute_with_include
@@ -81,10 +159,12 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_get_minimum_of_field
     assert_equal 50, Account.minimum(:credit_limit)
+    assert_async_equal 50, Account.async_minimum(:credit_limit)
   end
 
   def test_should_get_minimum_of_arel_attribute
     assert_equal 50, Account.minimum(Account.arel_table[:credit_limit])
+    assert_async_equal 50, Account.async_minimum(Account.arel_table[:credit_limit])
   end
 
   def test_should_group_by_field
@@ -92,6 +172,7 @@ class CalculationsTest < ActiveRecord::TestCase
     [1, 6, 2].each do |firm_id|
       assert_includes c.keys, firm_id, "Group #{c.inspect} does not contain firm_id #{firm_id}"
     end
+    assert_async_equal c, Account.group(:firm_id).async_sum(:credit_limit)
   end
 
   def test_should_group_by_arel_attribute
@@ -106,6 +187,19 @@ class CalculationsTest < ActiveRecord::TestCase
     [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert_includes c.keys, firm_and_limit }
   end
 
+  def test_should_group_by_multiple_fields_when_table_name_is_too_long
+    2.times do
+      TooLongTableName.create!(
+        toooooooo_long_a_id: 1,
+        toooooooo_long_b_id: 2
+      )
+    end
+
+    res = TooLongTableName.group(:toooooooo_long_a_id, :toooooooo_long_b_id).count
+
+    assert_equal({ [1, 2] => 2 }, res)
+  end
+
   def test_should_group_by_multiple_fields_having_functions
     c = Topic.group(:author_name, "COALESCE(type, title)").count(:all)
     assert_equal 1, c[["Carl", "The Third Topic of the day"]]
@@ -133,36 +227,24 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal expected, accounts.merge!(accounts).uniq!(:group).sum(:credit_limit)
 
     expected = {
-      [nil, nil] => 50,
-      [1, 1] => 50,
-      [2, 2] => 60,
-      [6, 6] => 55,
-      [9, 9] => 53
+      nil => 50,
+      1 => 50,
+      2 => 60,
+      6 => 55,
+      9 => 53
     }
-    message = <<-MSG.squish
-      `maximum` with group by duplicated fields does no longer affect to result in Rails 7.0.
-      To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields
-      (`accounts.uniq!(:group).maximum(:credit_limit)`).
-    MSG
-    assert_deprecated(message) do
-      assert_equal expected, accounts.merge!(accounts).maximum(:credit_limit)
-    end
+
+    assert_equal expected, accounts.merge!(accounts).maximum(:credit_limit)
 
     expected = {
-      [nil, nil, nil, nil] => 50,
-      [1, 1, 1, 1] => 50,
-      [2, 2, 2, 2] => 60,
-      [6, 6, 6, 6] => 50,
-      [9, 9, 9, 9] => 53
+      nil => 50,
+      1 => 50,
+      2 => 60,
+      6 => 50,
+      9 => 53
     }
-    message = <<-MSG.squish
-      `minimum` with group by duplicated fields does no longer affect to result in Rails 7.0.
-      To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields
-      (`accounts.uniq!(:group).minimum(:credit_limit)`).
-    MSG
-    assert_deprecated(message) do
-      assert_equal expected, accounts.merge!(accounts).minimum(:credit_limit)
-    end
+
+    assert_equal expected, accounts.merge!(accounts).minimum(:credit_limit)
   end
 
   def test_should_generate_valid_sql_with_joins_and_group
@@ -185,9 +267,14 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_not_use_alias_for_grouped_field
-    assert_sql(/GROUP BY #{Regexp.escape(Account.connection.quote_table_name("accounts.firm_id"))}/i) do
+    if current_adapter?(:IBM_DBAdapter)
       c = Account.group(:firm_id).order("accounts_firm_id").sum(:credit_limit)
       assert_equal [1, 2, 6, 9], c.keys.compact
+    else
+      assert_queries_match(/GROUP BY #{Regexp.escape(quote_table_name("accounts.firm_id"))}/i) do
+        c = Account.group(:firm_id).order("accounts_firm_id").sum(:credit_limit)
+        assert_equal [1, 2, 6, 9], c.keys.compact
+      end
     end
   end
 
@@ -213,6 +300,13 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [2, 6], c.keys.compact
   end
 
+  def test_order_should_apply_before_count
+    accounts = Account.order(id: :desc).limit(4)
+
+    assert_equal 4, accounts.count(:firm_id)
+    assert_equal 4, accounts.select(:firm_id).count
+  end
+
   def test_limit_should_apply_before_count
     accounts = Account.order(:id).limit(4)
 
@@ -235,44 +329,44 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_limit_is_kept
-    return if current_adapter?(:OracleAdapter)
-
     queries = capture_sql { Account.limit(1).count }
     assert_equal 1, queries.length
-    assert_match(/FETCH FIRST/, queries.first)
+    assert_match(/LIMIT/, queries.first)
   end
 
   def test_offset_is_kept
-    return if current_adapter?(:OracleAdapter)
-
     queries = capture_sql { Account.offset(1).count }
     assert_equal 1, queries.length
     assert_match(/OFFSET/, queries.first)
   end
 
   def test_limit_with_offset_is_kept
-    return if current_adapter?(:OracleAdapter)
-
     queries = capture_sql { Account.limit(1).offset(1).count }
     assert_equal 1, queries.length
-    assert_match(/FETCH FIRST/, queries.first)
+    assert_match(/LIMIT/, queries.first)
     assert_match(/OFFSET/, queries.first)
   end
 
   def test_no_limit_no_offset
     queries = capture_sql { Account.count }
     assert_equal 1, queries.length
-    assert_no_match(/FETCH FIRST/, queries.first)
+    assert_no_match(/LIMIT/, queries.first)
     assert_no_match(/OFFSET/, queries.first)
   end
 
+  def test_no_order_by_when_counting_all
+    queries = capture_sql { Account.order(id: :desc).limit(10).count }
+    assert_equal 1, queries.length
+    assert_no_match(/ORDER BY/, queries.first)
+  end
+
   def test_count_on_invalid_columns_raises
-    e = assert_raises(ActiveRecord::StatementInvalid) {
+    error = assert_raises(ActiveRecord::StatementInvalid) do
       Account.select("credit_limit, firm_name").count
-    }
+    end
 
-    assert_match %r{accounts}i, e.sql
-    assert_match "credit_limit, firm_name", e.sql
+    assert_match %r{accounts}i, error.sql
+    assert_match "credit_limit, firm_name", error.sql
   end
 
   def test_apply_distinct_in_count
@@ -288,26 +382,26 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_count_with_eager_loading_and_custom_order
     posts = Post.includes(:comments).order("comments.id")
-    assert_queries(1) { assert_equal 11, posts.count }
-    assert_queries(1) { assert_equal 11, posts.count(:all) }
+    assert_queries_count(1) { assert_equal 11, posts.count }
+    assert_queries_count(1) { assert_equal 11, posts.count(:all) }
   end
 
   def test_count_with_eager_loading_and_custom_select_and_order
     posts = Post.includes(:comments).order("comments.id").select(:type)
-    assert_queries(1) { assert_equal 11, posts.count }
-    assert_queries(1) { assert_equal 11, posts.count(:all) }
+    assert_queries_count(1) { assert_equal 11, posts.count }
+    assert_queries_count(1) { assert_equal 11, posts.count(:all) }
   end
 
   def test_count_with_eager_loading_and_custom_order_and_distinct
     posts = Post.includes(:comments).order("comments.id").distinct
-    assert_queries(1) { assert_equal 11, posts.count }
-    assert_queries(1) { assert_equal 11, posts.count(:all) }
+    assert_queries_count(1) { assert_equal 11, posts.count }
+    assert_queries_count(1) { assert_equal 11, posts.count(:all) }
   end
 
   def test_distinct_count_all_with_custom_select_and_order
     accounts = Account.distinct.select("credit_limit % 10").order(Arel.sql("credit_limit % 10"))
-    assert_queries(1) { assert_equal 3, accounts.count(:all) }
-    assert_queries(1) { assert_equal 3, accounts.load.size }
+    assert_queries_count(1) { assert_equal 3, accounts.count(:all) }
+    assert_queries_count(1) { assert_equal 3, accounts.load.size }
   end
 
   def test_distinct_count_with_order_and_limit
@@ -350,6 +444,21 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal({ 6 => 2 }, Account.group(:firm_id).distinct.order("1 DESC").limit(1).count)
   end
 
+  def test_count_for_a_composite_primary_key_model
+    book = cpk_books(:cpk_great_author_first_book)
+    assert_equal(1, Cpk::Book.where(author_id: book.author_id, id: book.id).count)
+  end
+
+  def test_group_by_count_for_a_composite_primary_key_model
+    book = cpk_books(:cpk_great_author_first_book)
+    expected = { book.author_id => Cpk::Book.where(author_id: book.author_id).count }
+    assert_equal(expected, Cpk::Book.where(author_id: book.author_id).group(:author_id).count)
+  end
+
+  def test_count_for_a_composite_primary_key_model_with_includes_and_references
+    assert_equal Cpk::Book.count, Cpk::Book.includes(:chapters).references(:chapters).count
+  end
+
   def test_should_group_by_summed_field_having_condition
     c = Account.group(:firm_id).having("sum(credit_limit) > 50").sum(:credit_limit)
     assert_nil        c[1]
@@ -358,7 +467,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_field_having_condition_from_select
-    skip unless current_adapter?(:Mysql2Adapter, :SQLite3Adapter)
+    skip unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter, :SQLite3Adapter)
     c = Account.select("MIN(credit_limit) AS min_credit_limit").group(:firm_id).having("min_credit_limit > 50").sum(:credit_limit)
     assert_nil       c[1]
     assert_equal 60, c[2]
@@ -398,11 +507,13 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_summed_field_with_conditions_and_having
-    c = Account.where("firm_id > 1").group(:firm_id).
-     having("sum(credit_limit) > 60").sum(:credit_limit)
+    relation = Account.where("firm_id > 1").group(:firm_id).having("sum(credit_limit) > 60")
+    c = relation.sum(:credit_limit)
     assert_nil        c[1]
     assert_equal 105, c[6]
     assert_nil        c[2]
+
+    assert_async_equal c, relation.async_sum(:credit_limit)
   end
 
   def test_should_group_by_fields_with_table_alias
@@ -413,7 +524,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_calculate_grouped_with_longer_field
-    field = "a" * Account.connection.max_identifier_length
+    field = "a" * Account.lease_connection.max_identifier_length
 
     Account.update_all("#{field} = credit_limit")
 
@@ -477,7 +588,15 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_not_overshadow_enumerable_sum
+    some_companies = companies(:rails_core).companies.order(:id)
+
     assert_equal 6, [1, 2, 3].sum(&:abs)
+    assert_equal 15, some_companies.sum(&:id)
+    assert_equal 25, some_companies.sum(10, &:id)
+    assert_raises(TypeError) do
+      some_companies.sum(&:name)
+    end
+    assert_equal "companies: LeetsoftJadedpixel", some_companies.sum("companies: ", &:name)
   end
 
   def test_should_sum_scoped_field
@@ -562,6 +681,13 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 4, Account.distinct.select(Account.arel_table[:firm_id]).count
   end
 
+  def test_count_selected_arel_attributes
+    # Only MySQL supports COUNT with multiple columns, and only with DISTINCT.
+    skip unless current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
+
+    assert_equal 5, Account.distinct.select(Account.arel_table[:id], Account.arel_table[:firm_id]).count
+  end
+
   def test_count_with_column_parameter
     assert_equal 5, Account.count(:firm_id)
   end
@@ -607,6 +733,14 @@ class CalculationsTest < ActiveRecord::TestCase
     [1, 6, 2, 9].each { |firm_id| assert_includes c.keys, firm_id }
   end
 
+  def test_should_count_field_in_joined_table_with_group_by_when_tables_share_column_names
+    assert Company.columns_hash.key?("status")
+    assert Account.columns_hash.key?("status")
+
+    counts = Company.joins(:account).group("accounts.status").count
+    assert_equal({ "active" => 2, "trial" => 2, "suspended" => 1 }, counts)
+  end
+
   def test_should_count_field_of_root_table_with_conflicting_group_by_column
     expected = { 1 => 2, 2 => 1, 4 => 5, 5 => 3, 7 => 1 }
     assert_equal expected, Post.joins(:comments).group(:post_id).count
@@ -615,7 +749,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_no_parameters_isnt_deprecated
-    assert_not_deprecated { Account.count }
+    assert_not_deprecated(ActiveRecord.deprecator) { Account.count }
   end
 
   def test_count_with_too_many_parameters_raises
@@ -640,6 +774,13 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 4, Account.count { |account| account.credit_limit.modulo(10).zero? }
   end
 
+  def test_count_with_empty_in
+    assert_queries_count(0) do
+      assert_equal 0, Topic.where(id: []).count
+      assert_async_equal 0, Topic.where(id: []).async_count
+    end
+  end
+
   def test_should_sum_expression
     assert_equal 636, Account.sum("2 * credit_limit")
   end
@@ -680,6 +821,36 @@ class CalculationsTest < ActiveRecord::TestCase
         Account.where("credit_limit > 50").from("accounts").maximum(:credit_limit)
   end
 
+  def test_no_queries_for_empty_relation_on_count
+    assert_queries_count(0) do
+      assert_equal 0, Post.where(id: []).count
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_sum
+    assert_queries_count(0) do
+      assert_equal 0, Post.where(id: []).sum(:tags_count)
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_average
+    assert_queries_count(0) do
+      assert_nil Post.where(id: []).average(:tags_count)
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_minimum
+    assert_queries_count(0) do
+      assert_nil Account.where(id: []).minimum(:id)
+    end
+  end
+
+  def test_no_queries_for_empty_relation_on_maximum
+    assert_queries_count(0) do
+      assert_nil Account.where(id: []).maximum(:id)
+    end
+  end
+
   def test_maximum_with_not_auto_table_name_prefix_if_column_included
     Company.create!(name: "test", contracts: [Contract.new(developer_id: 7)])
 
@@ -698,6 +869,16 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 7, Company.includes(:contracts).sum(:developer_id)
   end
 
+  def test_sum_with_grouped_calculation
+    expected = { 0 => 0, 1 => 0, 3 => 0 }
+
+    if current_adapter?(:IBM_DBAdapter)
+      assert_equal(expected, Post.group(:tags_count).sum(Arel.sql("0")))
+    else
+      assert_equal(expected, Post.group(:tags_count).sum)
+    end
+  end
+
   def test_from_option_with_specified_index
     edges = Edge.from("edges /*! USE INDEX(unique_edge_index) */")
     assert_equal Edge.count(:all), edges.count(:all)
@@ -711,28 +892,35 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_distinct_is_honored_when_used_with_count_operation_after_group
     # Count the number of authors for approved topics
     approved_topics_count = Topic.group(:approved).count(:author_name)[true]
-    assert_equal approved_topics_count, 4
+    assert_equal 4, approved_topics_count
     # Count the number of distinct authors for approved Topics
     distinct_authors_for_approved_count = Topic.group(:approved).distinct.count(:author_name)[true]
-    assert_equal distinct_authors_for_approved_count, 3
+    assert_equal 3, distinct_authors_for_approved_count
   end
 
   def test_pluck
     assert_equal [1, 2, 3, 4, 5], Topic.order(:id).pluck(:id)
+    assert_async_equal [1, 2, 3, 4, 5], Topic.order(:id).async_pluck(:id)
+  end
+
+  def test_async_pluck_on_loaded_relation
+    relation = Topic.order(:id).load
+    assert_async_equal relation.pluck(:id), relation.async_pluck(:id)
+  end
+
+  def test_async_pluck_none_relation
+    assert_async_equal [], Topic.none.async_pluck(:id)
   end
 
   def test_pluck_with_empty_in
-    assert_queries(0) do
+    assert_queries_count(0) do
       assert_equal [], Topic.where(id: []).pluck(:id)
     end
+    assert_async_equal [], Topic.where(id: []).async_pluck(:id)
   end
 
   def test_pluck_without_column_names
-    if current_adapter?(:OracleAdapter)
-      assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, nil]], Company.order(:id).limit(1).pluck
-    else
-      assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, ""]], Company.order(:id).limit(1).pluck
-    end
+    assert_equal [[1, "Firm", 1, nil, "37signals", nil, 1, nil, "", "active"]], Company.order(:id).limit(1).pluck
   end
 
   def test_pluck_type_cast
@@ -741,6 +929,10 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [ topic.approved ], relation.pluck(:approved)
     assert_equal [ topic.last_read ], relation.pluck(:last_read)
     assert_equal [ topic.written_on ], relation.pluck(:written_on)
+    assert_equal(
+      [[topic.written_on, topic.replies_count]],
+      relation.pluck("min(written_on)", "min(replies_count)")
+    )
   end
 
   def test_pluck_type_cast_with_conflict_column_names
@@ -785,7 +977,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pluck_with_type_cast_does_not_corrupt_the_query_cache
     topic = topics(:first)
     relation = Topic.where(id: topic.id)
-    assert_queries 1 do
+    assert_queries_count 1 do
       Topic.cache do
         kind = relation.select(:written_on).load.first.read_attribute_before_type_cast(:written_on).class
         relation.pluck(:written_on)
@@ -809,8 +1001,8 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_with_serialization
-    t = Topic.create!(content: { foo: :bar })
-    assert_equal [{ foo: :bar }], Topic.where(id: t.id).pluck(:content)
+    t = Topic.create!(content: { "foo" => "bar" })
+    assert_equal [{ "foo" => "bar" }], Topic.where(id: t.id).pluck(:content)
   end
 
   def test_pluck_with_qualified_column_name
@@ -840,8 +1032,174 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [50 + 53 + 55 + 60], Account.pluck(Arel.sql("SUM(DISTINCT(credit_limit))"))
   end
 
-  def test_plucks_with_ids
-    assert_equal Company.all.map(&:id).sort, Company.ids.sort
+  def test_pluck_with_hash_argument
+    expected = [
+      [1, "The First Topic"],
+      [2, "The Second Topic of the day"],
+      [3, "The Third Topic of the day"]
+    ]
+    assert_equal expected, Topic.order(:id).limit(3).pluck(:id, topics: :title)
+    assert_equal expected, Topic.order(:id).limit(3).pluck("id", "topics" => "title")
+    assert_equal expected, Topic.order(:id).limit(3).pluck(:id, topics: [:title])
+    assert_equal expected, Topic.order(:id).limit(3).pluck("id", "topics" => ["title"])
+  end
+
+  def test_pluck_with_hash_argument_with_multiple_tables
+    expected = [
+      [1, 1, "Thank you for the welcome"],
+      [1, 2, "Thank you again for the welcome"],
+      [2, 3, "Don't think too hard"]
+    ]
+    assert_equal expected, Post.joins(:comments).order(posts: { id: :asc }, comments: { id: :asc }).limit(3).pluck(:id, comments: [:id, :body])
+    assert_equal expected, Post.joins(:comments).order(posts: { id: :asc }, comments: { id: :asc }).limit(3).pluck(posts: :id, comments: [:id, :body])
+    assert_equal expected, Post.joins(:comments).order(posts: { id: :asc }, comments: { id: :asc }).limit(3).pluck(posts: [:id], comments: [:id, :body])
+  end
+
+  def test_pluck_with_hash_argument_containing_non_existent_field
+    assert_raises(ActiveRecord::StatementInvalid) do
+      Topic.pluck(topics: [:non_existent])
+    end
+  end
+
+  def test_ids
+    assert_equal Company.all.map(&:id).sort, Company.all.ids.sort
+  end
+
+  def test_ids_for_a_composite_primary_key
+    assert_equal Cpk::Book.all.map(&:id).sort, Cpk::Book.all.ids.sort
+  end
+
+  def test_pluck_for_a_composite_primary_key
+    assert_equal Cpk::Book.all.pluck([:author_id, :id]).sort, Cpk::Book.all.ids.sort
+  end
+
+  def test_ids_for_a_composite_primary_key_with_scope
+    book = cpk_books(:cpk_great_author_first_book)
+
+    assert_equal [book.id], Cpk::Book.all.where(title: book.title).ids
+  end
+
+  def test_ids_for_a_composite_primary_key_on_loaded_relation
+    book = cpk_books(:cpk_great_author_first_book)
+    relation = Cpk::Book.where(title: book.title)
+    relation.to_a
+
+    assert_predicate relation, :loaded?
+    assert_equal [book.id], relation.ids
+  end
+
+  def test_ids_with_scope
+    scoped_ids = [1, 2]
+    assert_equal Company.where(id: scoped_ids).map(&:id).sort, Company.where(id: scoped_ids).ids.sort
+  end
+
+  def test_ids_on_relation
+    company = Company.first
+    contract = company.contracts.create!
+    assert_equal [contract.id], company.contracts.ids
+  end
+
+  def test_ids_on_loaded_relation
+    loaded_companies = Company.all.load
+    company_ids = Company.all.map(&:id)
+    assert_queries_count(0) do
+      assert_equal company_ids.sort, loaded_companies.ids.sort
+    end
+  end
+
+  def test_ids_on_loaded_relation_with_scope
+    scoped_ids = [1, 2]
+    loaded_companies = Company.where(id: scoped_ids).load
+    company_ids = Company.where(id: scoped_ids).map(&:id)
+    assert_queries_count(0) do
+      assert_equal company_ids.sort, loaded_companies.ids.sort
+    end
+  end
+
+  def test_ids_async_on_loaded_relation
+    loaded_companies = Company.all.order(:id).load
+    assert_async_equal loaded_companies.ids, loaded_companies.async_ids
+  end
+
+  def test_ids_with_contradicting_scope
+    empty_scope_ids = []
+    company_ids = Company.where(id: empty_scope_ids).map(&:id)
+    assert_predicate company_ids, :empty?
+    assert_queries_count(0) do
+      assert_equal company_ids, Company.where(id: empty_scope_ids).ids
+    end
+  end
+
+  def test_ids_with_join
+    company = Company.first
+    company.contracts.create!
+    assert_equal [company.id], Company.joins(:contracts).where("contracts.id" => company.contracts.first).ids
+  end
+
+  def test_ids_with_polymorphic_relation_join
+    part = ShipPart.create!(name: "has trinket")
+    part.trinkets.create!
+
+    assert_equal [part.id], ShipPart.joins(:trinkets).ids
+    assert_async_equal [part.id], ShipPart.joins(:trinkets).async_ids
+  end
+
+  def test_ids_with_eager_load
+    company = Company.first
+    5.times { company.contracts.create! }
+    assert_equal Company.all.map(&:id).sort, Company.all.eager_load(:contracts).ids.sort
+  end
+
+  def test_ids_with_preload
+    company = Company.first
+    5.times { company.contracts.create! }
+    assert_equal Company.all.map(&:id).sort, Company.all.preload(:contracts).ids.sort
+  end
+
+  def test_ids_with_includes
+    company = Company.first
+    5.times { company.contracts.create! }
+    assert_equal Company.all.map(&:id).sort, Company.all.includes(:contracts).ids.sort
+  end
+
+  def test_ids_with_includes_and_non_primary_key_order
+    rating = 1
+    Company.all.each { |company| company.update!(rating: rating += 1) }
+    relation = Company.includes(:comments).order(:rating)
+    relation = relation.group(:id, :rating) if current_adapter?(:IBM_DBAdapter)
+    assert_equal Company.all.sort_by(&:rating).map(&:id), relation.ids
+  end
+
+  def test_ids_with_includes_and_scope
+    scoped_ids = [1, 2]
+    company = Company.where(id: scoped_ids).first
+    5.times { company.contracts.create! }
+    assert_equal Company.where(id: scoped_ids).map(&:id).sort, Company.includes(:contracts).where(id: scoped_ids).ids.sort
+  end
+
+  def test_ids_with_includes_and_table_scope
+    company = Company.first
+    company.contracts.create!
+    assert_equal [company.id], Company.includes(:contracts).where("contracts.id" => company.contracts.first).ids
+  end
+
+  def test_ids_on_loaded_relation_with_includes_and_table_scope
+    company = Company.first
+    company.contracts.create!
+    loaded_companies = Company.includes(:contracts).where("contracts.id" => company.contracts.first).load
+    assert_queries_count(0) do
+      assert_equal [company.id], loaded_companies.ids
+    end
+  end
+
+  def test_ids_with_includes_limit_and_empty_result
+    assert_equal [], Topic.includes(:replies).limit(0).ids
+    assert_equal [], Topic.includes(:replies).limit(1).where("0 = 1").ids
+  end
+
+  def test_ids_with_includes_offset
+    assert_equal [5], Topic.includes(:replies).order(:id).offset(4).ids
+    assert_equal [], Topic.includes(:replies).order(:id).offset(5).ids
   end
 
   def test_pluck_with_includes_limit_and_empty_result
@@ -855,9 +1213,17 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_with_join
+    assert_equal [[2, 2], [4, 4]], Reply.includes(:topic).order(:id).pluck(:id, topics: [:id])
+    assert_equal [[2, 2], [4, 4]], Reply.includes(:topic).order(:id).pluck(:id, topics: :id)
     assert_equal [[2, 2], [4, 4]], Reply.includes(:topic).order(:id).pluck(:id, :"topics.id")
   end
 
+  def test_pluck_with_join_alias
+    assert_equal [[2, 1], [4, 3]], Reply.includes(:topic).order(:id).pluck(:id, topic: [:id])
+    assert_equal [[2, 1], [4, 3]], Reply.includes(:topic).order(:id).pluck(:id, topic: :id)
+    assert_equal [[2, 1], [4, 3]], Reply.includes(:topic).order(:id).pluck(:id, :"topic.id")
+  end
+
   def test_group_by_with_order_by_virtual_count_attribute
     expected = { "SpecialPost" => 1, "StiPost" => 2 }
     actual = Post.group(:type).order(:count).limit(2).maximum(:comments_count)
@@ -883,9 +1249,9 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_group_by_with_quoted_count_and_order_by_alias
-    quoted_posts_id = Post.connection.quote_table_name("posts.id")
     expected = { "SpecialPost" => 1, "StiPost" => 1, "Post" => 9 }
-    actual = Post.group(:type).order("count_posts_id").count(quoted_posts_id)
+    count_expression = current_adapter?(:IBM_DBAdapter) ? "posts.id" : quote_table_name("posts.id")
+    actual = Post.group(:type).order("count_posts_id").count(count_expression)
     assert_equal expected, actual
   end
 
@@ -914,6 +1280,11 @@ class CalculationsTest < ActiveRecord::TestCase
       Account.order(:id).pluck("id, credit_limit")
   end
 
+  def test_pluck_with_line_endings
+    assert_equal [[1, 50], [2, 50], [3, 50], [4, 60], [5, 55], [6, 53]],
+      Account.order(:id).pluck("id, credit_limit\n")
+  end
+
   def test_pluck_with_multiple_columns_and_includes
     Company.create!(name: "test", contracts: [Contract.new(developer_id: 7)])
     companies_and_developers = Company.order("companies.id").includes(:contracts).pluck(:name, :developer_id)
@@ -930,9 +1301,21 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_replaces_select_clause
-    taks_relation = Topic.select(:approved, :id).order(:id)
-    assert_equal [1, 2, 3, 4, 5], taks_relation.pluck(:id)
-    assert_equal [false, true, true, true, true], taks_relation.pluck(:approved)
+    takes_relation = Topic.select(:approved, :id).order(:id)
+    assert_equal [1, 2, 3, 4, 5], takes_relation.pluck(:id)
+    assert_equal [false, true, true, true, true], takes_relation.pluck(:approved)
+  end
+
+  def test_pluck_with_qualified_name_on_loaded
+    topics = Topic.joins(:replies).order(:id)
+
+    assert_not_predicate topics, :loaded?
+    assert_equal [[1, 2], [3, 4]], topics.pluck("topics.id", "replies.id")
+
+    topics.load
+
+    assert_predicate topics, :loaded?
+    assert_equal [[1, 2], [3, 4]], topics.pluck("topics.id", "replies.id")
   end
 
   def test_pluck_columns_with_same_name
@@ -954,11 +1337,15 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_pluck_functions_without_alias
-    assert_equal [
-      [1, "The First Topic"], [2, "The Second Topic of the day"],
-      [3, "The Third Topic of the day"], [4, "The Fourth Topic of the day"],
+    expected = [
+      [1, "The First Topic"],
+      [2, "The Second Topic of the day"],
+      [3, "The Third Topic of the day"],
+      [4, "The Fourth Topic of the day"],
       [5, "The Fifth Topic of the day"]
-    ], Topic.order(:id).pluck(
+    ]
+
+    assert_equal expected, Topic.order(:id).pluck(
       Arel.sql("COALESCE(id, 0)"),
       Arel.sql("COALESCE(title, 'untitled')")
     )
@@ -969,6 +1356,19 @@ class CalculationsTest < ActiveRecord::TestCase
     part.trinkets.create!
 
     assert_equal part.id, ShipPart.joins(:trinkets).sum(:id)
+    assert_async_equal part.id, ShipPart.joins(:trinkets).async_sum(:id)
+  end
+
+  def test_calculation_with_query_cache
+    ShipPart.cache do
+      count = ShipPart.count
+      assert_async_equal count, ShipPart.async_count
+    end
+
+    ShipPart.cache do
+      count = ShipPart.async_count
+      assert_async_equal count.value, ShipPart.async_count
+    end
   end
 
   def test_pluck_joined_with_polymorphic_relation
@@ -976,12 +1376,13 @@ class CalculationsTest < ActiveRecord::TestCase
     part.trinkets.create!
 
     assert_equal [part.id], ShipPart.joins(:trinkets).pluck(:id)
+    assert_async_equal [part.id], ShipPart.joins(:trinkets).async_pluck(:id)
   end
 
   def test_pluck_loaded_relation
     companies = Company.order(:id).limit(3).load
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       assert_equal ["37signals", "Summit", "Microsoft"], companies.pluck(:name)
     end
   end
@@ -989,7 +1390,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pluck_loaded_relation_multiple_columns
     companies = Company.order(:id).limit(3).load
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       assert_equal [[1, "37signals"], [2, "Summit"], [3, "Microsoft"]], companies.pluck(:id, :name)
     end
   end
@@ -997,7 +1398,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pluck_loaded_relation_sql_fragment
     companies = Company.order(:name).limit(3).load
 
-    assert_queries(1) do
+    assert_queries_count(1) do
       assert_equal ["37signals", "Apex", "Ex Nihilo"], companies.pluck(Arel.sql("DISTINCT name"))
     end
   end
@@ -1005,7 +1406,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pluck_loaded_relation_aliased_attribute
     companies = Company.order(:id).limit(3).load
 
-    assert_queries(0) do
+    assert_queries_count(0) do
       assert_equal ["37signals", "Summit", "Microsoft"], companies.pluck(:new_name)
     end
   end
@@ -1016,6 +1417,8 @@ class CalculationsTest < ActiveRecord::TestCase
       assert_nil Topic.none.pick(:heading)
       assert_nil Topic.where(id: 9999999999999999999).pick(:heading)
     end
+
+    assert_async_equal "The First Topic", Topic.order(:id).async_pick(:heading)
   end
 
   def test_pick_two
@@ -1024,6 +1427,8 @@ class CalculationsTest < ActiveRecord::TestCase
       assert_nil Topic.none.pick(:author_name, :author_email_address)
       assert_nil Topic.where(id: 9999999999999999999).pick(:author_name, :author_email_address)
     end
+
+    assert_async_equal ["David", "david@loudthinking.com"], Topic.order(:id).async_pick(:author_name, :author_email_address)
   end
 
   def test_pick_delegate_to_all
@@ -1050,7 +1455,7 @@ class CalculationsTest < ActiveRecord::TestCase
   def test_pick_loaded_relation_sql_fragment
     companies = Company.order(:name).limit(3).load
 
-    assert_queries 1 do
+    assert_queries_count 1 do
       assert_equal "37signals", companies.pick(Arel.sql("DISTINCT name"))
     end
   end
@@ -1099,15 +1504,27 @@ class CalculationsTest < ActiveRecord::TestCase
       Account.group(:id).having(params)
     end
 
-    result = Account.group(:id, :firm_id, :firm_name, :credit_limit, :AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA).having(params.permit!)
-    assert_equal 50, result[0].credit_limit
-    assert_equal 50, result[1].credit_limit
-    assert_equal 50, result[2].credit_limit
+    if current_adapter?(:IBM_DBAdapter)
+      long_column = "a" * Account.lease_connection.max_identifier_length
+
+      result = Account
+        .select(:id, :firm_id, :firm_name, :credit_limit, long_column)
+        .group(:id, :firm_id, :firm_name, :credit_limit, long_column)
+        .having(params.permit!)
+        .to_a
+
+      assert_equal [50, 50, 50], result.map(&:credit_limit).sort
+    else
+      result = Account.group(:id).having(params.permit!)
+      assert_equal 50, result[0].credit_limit
+      assert_equal 50, result[1].credit_limit
+      assert_equal 50, result[2].credit_limit
+    end
   end
 
   def test_count_takes_attribute_type_precedence_over_database_type
     assert_called(
-      Account.connection, :select_all,
+      Account.lease_connection, :select_all,
       returns: ActiveRecord::Result.new(["count"], [["10"]])
     ) do
       result = Account.count
@@ -1118,7 +1535,7 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_sum_takes_attribute_type_precedence_over_database_type
     assert_called(
-      Account.connection, :select_all,
+      Account.lease_connection, :select_all,
       returns: ActiveRecord::Result.new(["sum"], [[10.to_d]])
     ) do
       result = Account.sum(:credit_limit)
@@ -1273,7 +1690,7 @@ class CalculationsTest < ActiveRecord::TestCase
       INNER JOIN accounts ON companies.id = accounts.firm_id
       WHERE companies.id = ?
       GROUP BY companies.id, companies.type, companies.firm_id, companies.firm_name, companies.name, companies.client_of, companies.rating, companies.account_id,
-      companies.DESCRIPTION
+      companies.description, companies.status
       LIMIT 1
     SQL
 
@@ -1294,7 +1711,7 @@ class CalculationsTest < ActiveRecord::TestCase
       .select("companies.*", "AVG(accounts.credit_limit) AS avg_credit_limit")
       .where(id: rails_core)
       .joins(:account)
-      .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description)
+      .group(:id, :type, :firm_id, :firm_name, :status, :name, :client_of, :rating, :account_id, :description)
       .take!
 
     # all the DependentFirm attributes should be present
@@ -1311,34 +1728,42 @@ class CalculationsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_sum_with_block_and_column_name_raises_an_error
-    assert_raises(ArgumentError) do
-      Account.sum(:firm_id) { 1 }
-    end
-  end
-
   test "#skip_query_cache! for #pluck" do
     Account.cache do
-      assert_queries(1) do
+      assert_queries_count(1) do
         Account.pluck(:credit_limit)
         Account.pluck(:credit_limit)
       end
 
-      assert_queries(2) do
+      assert_queries_count(2) do
         Account.all.skip_query_cache!.pluck(:credit_limit)
         Account.all.skip_query_cache!.pluck(:credit_limit)
       end
     end
   end
 
+  test "#skip_query_cache! for #ids" do
+    Account.cache do
+      assert_queries_count(1) do
+        Account.ids
+        Account.ids
+      end
+
+      assert_queries_count(2) do
+        Account.all.skip_query_cache!.ids
+        Account.all.skip_query_cache!.ids
+      end
+    end
+  end
+
   test "#skip_query_cache! for a simple calculation" do
     Account.cache do
-      assert_queries(1) do
+      assert_queries_count(1) do
         Account.calculate(:sum, :credit_limit)
         Account.calculate(:sum, :credit_limit)
       end
 
-      assert_queries(2) do
+      assert_queries_count(2) do
         Account.all.skip_query_cache!.calculate(:sum, :credit_limit)
         Account.all.skip_query_cache!.calculate(:sum, :credit_limit)
       end
@@ -1347,15 +1772,21 @@ class CalculationsTest < ActiveRecord::TestCase
 
   test "#skip_query_cache! for a grouped calculation" do
     Account.cache do
-      assert_queries(1) do
+      assert_queries_count(1) do
         Account.group(:firm_id).calculate(:sum, :credit_limit)
         Account.group(:firm_id).calculate(:sum, :credit_limit)
       end
 
-      assert_queries(2) do
+      assert_queries_count(2) do
         Account.all.skip_query_cache!.group(:firm_id).calculate(:sum, :credit_limit)
         Account.all.skip_query_cache!.group(:firm_id).calculate(:sum, :credit_limit)
       end
     end
   end
+
+  test "group alias is properly quoted" do
+    assert_nothing_raised do
+      NeedQuoting.group(:name).count
+    end
+  end
 end