activerecord-refined 0.5.0 → 0.6.0

data/test/test_block_syntax.rb

@@ -91,11 +91,22 @@ class TestBlockSyntax < Minitest::Test
     assert_equal(['Alice'], User.where { :name.casecmp?('aLiCe') }.pluck(:name))
   end
 
-  def test_not_like
+  def test_bang_negates_like
     assert_sql(/WHERE NOT \("users"."name" LIKE 'tender%'\)/,
       User.where { !:name.like?('tender%') }.to_sql)
   end
 
+  def test_not_like
+    assert_sql(/WHERE "users"."name" NOT LIKE 'tender%'/,
+      User.where { :name.not_like?('tender%') }.to_sql)
+  end
+
+  def test_not_ilike
+    expected = ADAPTER == 'postgresql' ? 'ILIKE' : 'LIKE'
+    assert_sql(/WHERE "users"."name" NOT #{expected} 'tender%'/,
+      User.where { :name.not_ilike?('tender%') }.to_sql)
+  end
+
   def test_start_with
     assert_sql(/WHERE "users"."name" LIKE 'tender%' ESCAPE '\\'/,
       User.where { :name.start_with?('tender') }.to_sql)
@@ -298,11 +309,23 @@ class TestBlockSyntax < Minitest::Test
       User.where { :age.in?(18...65) }.to_sql)
   end
 
-  def test_not_between
+  def test_bang_negates_between
     assert_sql(/WHERE NOT \("users"."age" BETWEEN 18 AND 65\)/,
       User.where { !:age.between?(18, 65) }.to_sql)
   end
 
+  # Arel spells the negation as the two comparisons rather than NOT BETWEEN,
+  # which is the same set of rows, NULLs included.
+  def test_not_between
+    assert_sql(/WHERE \("users"."age" < 18 OR "users"."age" > 65\)/,
+      User.where { :age.not_between?(18, 65) }.to_sql)
+  end
+
+  def test_not_in_range
+    assert_sql(/WHERE \("users"."age" < 18 OR "users"."age" > 65\)/,
+      User.where { :age.not_in?(18..65) }.to_sql)
+  end
+
   def test_is_null
     assert_sql(/WHERE "users"."name" IS NULL/,
       User.where { :name.null? }.to_sql)
@@ -313,6 +336,237 @@ class TestBlockSyntax < Minitest::Test
       User.where { :users[:name].null? }.to_sql)
   end
 
+  def test_is_not_null
+    assert_sql(/WHERE "users"."name" IS NOT NULL/,
+      User.where { :name.not_null? }.to_sql)
+  end
+
+  def test_is_not_null_qualified
+    assert_sql(/WHERE "users"."name" IS NOT NULL/,
+      User.where { :users[:name].not_null? }.to_sql)
+  end
+
+  # CASE has two shapes, and so does the block: an operand to compare each
+  # `when` against, or a condition on every `when`.
+  def test_case_with_an_operand
+    assert_sql(/SELECT CASE "users"."age" WHEN 10 THEN 'ten' ELSE 'other' END AS "v"/,
+      User.select { self.case(:age).when(10).then('ten').else('other').as(:v) }.to_sql)
+  end
+
+  def test_when_on_a_column_is_the_same_case
+    assert_equal(
+      User.select { self.case(:age).when(10).then('ten').else('other').as(:v) }.to_sql,
+      User.select { :age.when(10).then('ten').else('other').as(:v) }.to_sql)
+  end
+
+  def test_searched_case
+    assert_sql(/SELECT CASE WHEN "users"."age" >= 60 THEN 'senior' ELSE 'other' END AS "v"/,
+      User.select { case_when { :age >= 60 }.then('senior').else('other').as(:v) }.to_sql)
+  end
+
+  def test_case_when_is_the_same_as_case_with_no_operand
+    assert_equal(
+      User.select { self.case.when { :age >= 60 }.then(1).else(0).as(:v) }.to_sql,
+      User.select { case_when { :age >= 60 }.then(1).else(0).as(:v) }.to_sql)
+  end
+
+  # A value and a block say the same thing; the block is there to read like
+  # the blocks around it.
+  def test_a_condition_reads_the_same_either_way
+    assert_equal(
+      User.select { case_when(:age >= 60).then(1).else(0).as(:v) }.to_sql,
+      User.select { case_when { :age >= 60 }.then(1).else(0).as(:v) }.to_sql)
+  end
+
+  def test_case_with_several_whens
+    assert_sql(
+      /CASE WHEN "users"."age" < 18 THEN 'minor' WHEN "users"."age" >= 60 THEN 'senior' ELSE 'adult' END/,
+      User.select {
+        case_when { :age < 18 }.then('minor').
+          when { :age >= 60 }.then('senior').
+          else('adult').as(:v)
+      }.to_sql)
+  end
+
+  # Leaving the ELSE off is SQL's own default rather than an omission.
+  def test_case_without_an_else
+    sql = User.select { case_when { :age >= 60 }.then('senior').as(:v) }.to_sql
+    assert_sql(/CASE WHEN "users"."age" >= 60 THEN 'senior' END/, sql)
+    refute_match(/ELSE/, sql)
+  end
+
+  def test_case_takes_expressions_and_columns
+    assert_sql(/THEN \("users"."age" - 60\)/,
+      User.select { case_when { :age >= 60 }.then { :age - 60 }.else(0).as(:v) }.to_sql)
+    assert_sql(/THEN "users"."name"/,
+      User.select { case_when { :age >= 60 }.then(:name).else('x').as(:v) }.to_sql)
+  end
+
+  def test_case_is_an_expression_like_any_other
+    assert_sql(/SUM\(CASE WHEN/,
+      User.select { sum(case_when { :age >= 60 }.then(1).else(0)).as(:v) }.to_sql)
+    assert_sql(/WHERE CASE "users"."age" WHEN 10 THEN 1 ELSE 2 END = 1/,
+      User.where { self.case(:age).when(10).then(1).else(2) == 1 }.to_sql)
+  end
+
+  def test_case_execution
+    User.delete_all
+    User.create!(name: 'senior', age: 70)
+    User.create!(name: 'adult', age: 30)
+    User.create!(name: 'minor', age: 10)
+    assert_equal(%w[adult minor senior],
+      User.select {
+        case_when { :age < 18 }.then('minor').
+          when { :age >= 60 }.then('senior').
+          else('adult').as(:v)
+      }.map(&:v).sort)
+  end
+
+  # One case finished two ways: the methods return new nodes rather than
+  # adding to the one they were called on.
+  def test_a_case_is_not_added_to_in_place
+    sql = User.select {
+      started = case_when { :age >= 60 }.then(1)
+      [started.else(0).as(:a), started.else(9).as(:b)]
+    }.to_sql
+    assert_sql(/THEN 1 ELSE 0 END AS "a"/, sql)
+    assert_sql(/THEN 1 ELSE 9 END AS "b"/, sql)
+  end
+
+  def test_when_needs_a_value_or_a_block
+    assert_raises(ArgumentError) { User.select { case_when.then(1) } }
+    e = assert_raises(ArgumentError) { User.select { case_when(1) { 2 }.then(1) } }
+    assert_match(/not both/, e.message)
+  end
+
+  def test_when_needs_a_matching_then
+    e = assert_raises(ArgumentError) { User.select { :age.when(10) }.to_sql }
+    assert_match(/matching then/, e.message)
+  end
+
+  # Kernel#then would otherwise answer this one, with no block and no noise.
+  def test_then_without_a_when_says_so
+    e = assert_raises(ArgumentError) { User.select { self.case(:age).then(1) } }
+    assert_match(/follows a when/, e.message)
+  end
+
+  # A window is built by chaining, the way Arel's own is.
+  def test_over_with_no_window
+    assert_sql(/SELECT AVG\("users"."age"\) OVER \(\) AS "v"/,
+      User.select { avg(:age).over.as(:v) }.to_sql)
+  end
+
+  def test_over_partition_and_order
+    assert_sql(
+      /AVG\("users"."age"\) OVER \(PARTITION BY "users"."name" ORDER BY "users"."age" DESC\)/,
+      User.select { avg(:age).over.partition(:name).order(:age.desc).as(:v) }.to_sql)
+  end
+
+  def test_over_takes_several_expressions
+    assert_sql(/PARTITION BY "users"."name", "users"."age"/,
+      User.select { count(:*).over.partition(:name, :age).as(:v) }.to_sql)
+  end
+
+  # The window-only functions, which the adapters that have them at all spell
+  # the same way.
+  def test_window_functions
+    assert_sql(/ROW_NUMBER\(\) OVER \(ORDER BY "users"."age"\)/,
+      User.select { row_number.over.order(:age).as(:v) }.to_sql)
+    assert_sql(/RANK\(\) OVER/, User.select { rank.over.order(:age).as(:v) }.to_sql)
+    assert_sql(/NTILE\(2\) OVER/, User.select { ntile(2).over.order(:age).as(:v) }.to_sql)
+    assert_sql(/LAG\("users"."age", 1\) OVER/,
+      User.select { lag(:age).over.order(:age).as(:v) }.to_sql)
+    assert_sql(/LAG\("users"."age", 2, 0\) OVER/,
+      User.select { lag(:age, 2, 0).over.order(:age).as(:v) }.to_sql)
+  end
+
+  # A frame is a range of rows counted from the current one: negative before
+  # it, positive after, 0 the row itself, an open end for unbounded.
+  def test_window_frames
+    assert_sql(/ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW/,
+      User.select { sum(:age).over.order(:age).rows(..0).as(:v) }.to_sql)
+    assert_sql(/ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING/,
+      User.select { sum(:age).over.order(:age).rows(-1..1).as(:v) }.to_sql)
+    assert_sql(/ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING/,
+      User.select { sum(:age).over.order(:age).rows(0..).as(:v) }.to_sql)
+    assert_sql(/RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW/,
+      User.select { sum(:age).over.order(:age).range(..0).as(:v) }.to_sql)
+  end
+
+  def test_over_is_an_expression_like_any_other
+    assert_sql(/\(RANK\(\) OVER \(ORDER BY "users"."age"\) \+ 1\) AS "v"/,
+      User.select { (rank.over.order(:age) + 1).as(:v) }.to_sql)
+  end
+
+  def test_window_execution
+    User.delete_all
+    User.create!(name: 'a', age: 20)
+    User.create!(name: 'b', age: 30)
+    User.create!(name: 'c', age: 40)
+    assert_equal([1, 2, 3],
+      User.select { row_number.over.order(:age).as(:v) }.map {|u| u.v.to_i })
+    assert_equal([20, 50, 90],
+      User.select { sum(:age).over.order(:age).rows(..0).as(:v) }.map {|u| u.v.to_i })
+  end
+
+  # One window finished two ways: the methods return new nodes.
+  def test_a_window_is_not_added_to_in_place
+    sql = User.select {
+      started = sum(:age).over.order(:age)
+      [started.partition(:name).as(:a), started.as(:b)]
+    }.to_sql
+    assert_sql(/PARTITION BY "users"."name" ORDER BY "users"."age"\) AS "a"/, sql)
+    assert_sql(/SUM\("users"."age"\) OVER \(ORDER BY "users"."age"\) AS "b"/, sql)
+  end
+
+  def test_a_window_function_needs_over
+    e = assert_raises(ArgumentError) { User.select { row_number.as(:v) }.to_sql }
+    assert_match(/needs over/, e.message)
+  end
+
+  def test_a_window_has_one_frame
+    assert_raises(ArgumentError) { User.select { sum(:age).over.rows(..0).range(..0) } }
+  end
+
+  def test_a_frame_is_a_range_of_rows
+    assert_raises(ArgumentError) { User.select { sum(:age).over.rows(3) } }
+    assert_raises(ArgumentError) { User.select { sum(:age).over.rows('a'..'b') } }
+    e = assert_raises(ArgumentError) { User.select { sum(:age).over.rows(-2...0) } }
+    assert_match(/ends on a row/, e.message)
+  end
+
+  def test_partition_needs_an_expression
+    assert_raises(ArgumentError) { User.select { sum(:age).over.partition } }
+    assert_raises(ArgumentError) { User.select { sum(:age).over.order } }
+  end
+
+  def test_case_needs_a_when
+    e = assert_raises(ArgumentError) { User.select { self.case(:age).else(1) }.to_sql }
+    assert_match(/needs a when/, e.message)
+  end
+
+  # The claim these methods rest on: the direct spelling is the same rows as
+  # negating the positive one, which is where a NULL would show a difference
+  # if there were one.
+  def test_the_negations_match_what_bang_selects
+    User.delete_all
+    User.create!(name: 'alice', age: 60, active: true)
+    User.create!(name: 'bob', age: 20, active: false)
+    User.create!(name: nil, age: 40)
+    [
+      [-> { :name.not_null? },          -> { !:name.null? }],
+      [-> { :age.not_in?([20, 30]) },   -> { !:age.in?([20, 30]) }],
+      [-> { :age.not_between?(20, 30) }, -> { !:age.between?(20, 30) }],
+      [-> { :name.not_like?('a%') },    -> { !:name.like?('a%') }],
+      [-> { :active.not_true? },        -> { !:active.true? }],
+      [-> { :active.not_false? },       -> { !:active.false? }],
+    ].each do |direct, negated|
+      assert_equal(User.where(&negated).pluck(:id).sort,
+                   User.where(&direct).pluck(:id).sort,
+                   "#{direct.source_location} did not match the ! form")
+    end
+  end
+
   def test_equal_nil_is_rejected
     e = assert_raises(ArgumentError) { User.where { :name == nil } }
     assert_match(/null\?/, e.message)
@@ -323,6 +577,44 @@ class TestBlockSyntax < Minitest::Test
     assert_match(/null\?/, e.message)
   end
 
+  def test_is_true
+    assert_sql(/WHERE "users"."active" IS TRUE/, User.where { :active.true? }.to_sql)
+  end
+
+  def test_is_not_true
+    assert_sql(/WHERE "users"."active" IS NOT TRUE/, User.where { :active.not_true? }.to_sql)
+  end
+
+  def test_is_false
+    assert_sql(/WHERE "users"."active" IS FALSE/, User.where { :active.false? }.to_sql)
+  end
+
+  def test_is_not_false
+    assert_sql(/WHERE "users"."active" IS NOT FALSE/, User.where { :active.not_false? }.to_sql)
+  end
+
+  # The four are spelled and answered the same way by every adapter, NULL
+  # included, which is what makes them worth having over = TRUE.
+  def test_truth_values_execution
+    User.delete_all
+    User.create!([{name: 'yes', active: true}, {name: 'no', active: false},
+                  {name: 'unset', active: nil}])
+    order = ->(relation) { relation.order(:name).pluck(:name) }
+    assert_equal(['yes'], order.(User.where { :active.true? }))
+    assert_equal(%w[no unset], order.(User.where { :active.not_true? }))
+    assert_equal(['no'], order.(User.where { :active.false? }))
+    assert_equal(%w[unset yes], order.(User.where { :active.not_false? }))
+  end
+
+  # Where the difference from a comparison against the literal shows: = TRUE
+  # is NULL for a NULL row, and negating it leaves that row out.
+  def test_not_true_keeps_the_nulls_equality_drops
+    User.delete_all
+    User.create!([{name: 'no', active: false}, {name: 'unset', active: nil}])
+    assert_equal(%w[no unset], User.where { :active.not_true? }.order(:name).pluck(:name))
+    assert_equal(['no'], User.where { !(:active == true) }.order(:name).pluck(:name))
+  end
+
   def test_in
     assert_sql(/WHERE "users"."age" IN \(1, 2, 3\)/,
       User.where { :age.in?([1, 2, 3]) }.to_sql)
@@ -333,11 +625,21 @@ class TestBlockSyntax < Minitest::Test
       User.where { :users[:age].in?([1, 2, 3]) }.to_sql)
   end
 
-  def test_not_in
+  def test_bang_negates_in
     assert_sql(/WHERE NOT \("users"."age" IN \(1, 2, 3\)\)/,
       User.where { !:age.in?([1, 2, 3]) }.to_sql)
   end
 
+  def test_not_in
+    assert_sql(/WHERE "users"."age" NOT IN \(1, 2, 3\)/,
+      User.where { :age.not_in?([1, 2, 3]) }.to_sql)
+  end
+
+  def test_not_in_qualified
+    assert_sql(/WHERE "users"."age" NOT IN \(1, 2, 3\)/,
+      User.where { :users[:age].not_in?([1, 2, 3]) }.to_sql)
+  end
+
   # Spelled IS [NOT] DISTINCT FROM on PostgreSQL, IS / IS NOT on SQLite and
   # <=> on MySQL, so only the resulting rows are portable.
   def test_not_distinct_from_execution
@@ -406,6 +708,66 @@ class TestBlockSyntax < Minitest::Test
       Author.where { !:id.in?(Post.select(:author_id)) }.to_sql)
   end
 
+  def test_any_subquery
+    skip_without_quantifiers
+    assert_sql(
+      /WHERE "users"."age" > ANY\(SELECT "users"."age" FROM "users" WHERE "users"."name" = 'alice'\)/,
+      User.where { :age > any(User.where(name: 'alice').select(:age)) }.to_sql)
+  end
+
+  def test_all_subquery
+    skip_without_quantifiers
+    assert_sql(/WHERE "users"."age" >= ALL\(SELECT "users"."age" FROM "users"\)/,
+      User.where { :age >= all(User.select(:age)) }.to_sql)
+  end
+
+  # The same default in? has, since both take the relation for a set of rows.
+  def test_quantifier_selects_primary_key_by_default
+    skip_without_quantifiers
+    assert_sql(/WHERE "authors"."id" > ANY\(SELECT "posts"."id" FROM "posts"\)/,
+      Author.where { :id > any(Post.all) }.to_sql)
+  end
+
+  # A list is what in? takes; ANY of one is what a plain comparison says.
+  def test_quantifier_without_a_relation_is_rejected
+    skip_without_quantifiers
+    e = assert_raises(ArgumentError) { User.where { :age > any([20, 30]) } }
+    assert_match(/relation/, e.message)
+  end
+
+  def test_quantifier_is_unsupported_on_sqlite
+    if ADAPTER == 'sqlite3'
+      e = assert_raises(NotImplementedError) { User.where { :age > any(User.select(:age)) } }
+      assert_match(/ANY/, e.message)
+    else
+      assert_sql(/> ANY\(SELECT/, User.where { :age > any(User.select(:age)) }.to_sql)
+    end
+  end
+
+  # ANY is satisfied by one row of the subquery and ALL by every row, so the
+  # two pick out the ends of the range the subquery covers.
+  def test_quantifier_execution
+    skip_without_quantifiers
+    User.delete_all
+    User.create!([{name: 'young', age: 20}, {name: 'middle', age: 40},
+                  {name: 'old', age: 60}])
+    ages = -> { User.select(:age) }
+    assert_equal(%w[middle old], User.where { :age > any(ages.call) }.order(:age).pluck(:name))
+    assert_equal(['old'], User.where { :age >= all(ages.call) }.pluck(:name))
+    assert_equal(['young'], User.where { :age <= all(ages.call) }.pluck(:name))
+  end
+
+  # = ANY is IN and != ALL is NOT IN, which is worth a test because it is the
+  # part of the quantifiers the gem already had another spelling for.
+  def test_quantifier_equality_execution
+    skip_without_quantifiers
+    User.delete_all
+    User.create!([{name: 'young', age: 20}, {name: 'old', age: 60}])
+    young = -> { User.where(name: 'young').select(:age) }
+    assert_equal(['young'], User.where { :age == any(young.call) }.pluck(:name))
+    assert_equal(['old'], User.where { :age != all(young.call) }.pluck(:name))
+  end
+
   # The subquery correlates with the outer table through qualified columns,
   # and its own where block goes through the DSL too.
   def test_exists
@@ -457,21 +819,21 @@ class TestBlockSyntax < Minitest::Test
   # literal depends on the column type, so assert on the Arel node instead.
   def test_equal_range_is_an_equality
     node = ActiveRecord::Refined::AST::Comparison.new(:period, :==, 18..65).
-      to_arel(User.arel_table)
+      to_arel(User.arel_table, User)
     assert_instance_of(Arel::Nodes::Equality, node)
     assert_equal(18..65, node.right.value)
   end
 
   def test_equal_array_is_an_equality
     node = ActiveRecord::Refined::AST::Comparison.new(:tags, :==, [1, 2, 3]).
-      to_arel(User.arel_table)
+      to_arel(User.arel_table, User)
     assert_instance_of(Arel::Nodes::Equality, node)
     assert_equal([1, 2, 3], node.right.value)
   end
 
   def test_not_equal_array_is_an_inequality
     node = ActiveRecord::Refined::AST::Comparison.new(:tags, :!=, [1, 2, 3]).
-      to_arel(User.arel_table)
+      to_arel(User.arel_table, User)
     assert_instance_of(Arel::Nodes::NotEqual, node)
     assert_equal([1, 2, 3], node.right.value)
   end
@@ -547,6 +909,65 @@ class TestBlockSyntax < Minitest::Test
     assert_raises(ArgumentError) { Node.from('tree', as: :nodes) }
   end
 
+  def test_from_cte_takes_the_alias_from_the_model
+    declared = Node.with(tree: Node.all)
+    assert_sql(/FROM "tree" (?:AS )?"nodes"/, declared.from_cte(:tree).to_sql)
+    assert_equal(declared.from(:tree, as: :nodes).to_sql,
+                 declared.from_cte(:tree).to_sql)
+  end
+
+  def test_from_cte_needs_a_symbol
+    assert_raises(ArgumentError) { Node.from_cte('tree') }
+  end
+
+  # The name has to be one `with` declares, or the query is against a table
+  # nobody has -- which the database would say much later and less clearly.
+  def test_from_cte_needs_a_cte_of_that_name
+    e = assert_raises(ArgumentError) do
+      Node.with(tree: Node.all).from_cte(:tre).to_sql
+    end
+    assert_match(/names no CTE/, e.message)
+    assert_match(/:tree/, e.message)
+
+    e = assert_raises(ArgumentError) { Node.from_cte(:tree).to_sql }
+    assert_match(/declares none/, e.message)
+  end
+
+  # Checked when the SQL is built, so where the CTE is declared in the chain
+  # does not matter.
+  def test_from_cte_takes_a_cte_declared_later
+    assert_sql(/FROM "tree" (?:AS )?"nodes"/,
+      Node.from_cte(:tree).with(tree: Node.all).to_sql)
+    assert_sql(/FROM "tree" (?:AS )?"nodes"/,
+      Node.from_cte(:tree).merge(Node.with(tree: Node.all)).to_sql)
+  end
+
+  # from itself says nothing about CTEs and goes on taking any table.
+  def test_from_with_an_alias_is_not_checked
+    assert_sql(/FROM "tree" (?:AS )?"nodes"/, Node.from(:tree, as: :nodes).to_sql)
+  end
+
+  # The alias is what lets a where find its column, which is the whole reason
+  # from_cte exists; without it the SQL names a table the query does not have.
+  def test_from_cte_leaves_where_able_to_qualify
+    Node.delete_all
+    root = Node.create!(name: 'root')
+    Node.create!(name: 'child', parent_id: root.id)
+    other = Node.create!(name: 'other root')
+    Node.create!(name: 'other child', parent_id: other.id)
+    forest = Node.with_recursive(
+      tree: [
+        Node.where { :parent_id.null? }.
+          select { [:id, :name, :parent_id, :id.as(:root_id)] },
+        Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] }.
+          select { [:nodes[:id], :nodes[:name], :nodes[:parent_id],
+                    :tree[:root_id]] },
+      ]
+    ).from_cte(:tree)
+    assert_equal(%w[child root],
+      forest.where { :root_id == root.id }.pluck(:name).sort)
+  end
+
   # A CTE is joined by name like any other table, so the recursive member's
   # ON clause is a block rather than the string join Rails' own docs use.
   def test_recursive_cte
@@ -574,33 +995,29 @@ class TestBlockSyntax < Minitest::Test
     assert_equal(['child'], q.pluck(:name))
   end
 
-  def test_select_aggregate
-    assert_sql(/SELECT SUM\("users"."age"\)/,
-      User.select { :age.sum }.to_sql)
+  def test_select_sum
+    assert_sql(/SELECT SUM\("users"."age"\)/, User.select { sum(:age) }.to_sql)
   end
 
-  def test_select_aggregate_qualified
+  def test_select_aggregate_of_qualified_column
     assert_sql(/SELECT COUNT\("users"."id"\)/,
-      User.select { :users[:id].count }.to_sql)
+      User.select { count(:users[:id]) }.to_sql)
   end
 
-  def test_select_average
-    assert_sql(/SELECT AVG\("users"."age"\)/,
-      User.select { :age.average }.to_sql)
+  def test_select_max_and_min
+    assert_sql(/SELECT MAX\("users"."age"\)/, User.select { max(:age) }.to_sql)
+    assert_sql(/SELECT MIN\("users"."age"\)/, User.select { min(:age) }.to_sql)
   end
 
-  def test_select_maximum
-    assert_sql(/SELECT MAX\("users"."age"\)/,
-      User.select { :age.maximum }.to_sql)
-  end
-
-  def test_select_minimum
-    assert_sql(/SELECT MIN\("users"."age"\)/,
-      User.select { :age.minimum }.to_sql)
+  # An aggregate is written as a call, the way SQL writes it; a column has no
+  # method of its own for one.
+  def test_aggregates_have_no_postfix_form
+    assert_raises(NoMethodError) { User.select { :age.sum } }
+    assert_raises(NoMethodError) { User.select { :age.average } }
   end
 
   def test_having_aggregate
-    sql = User.group(:name).having { :age.sum > 100 }.to_sql
+    sql = User.group(:name).having { sum(:age) > 100 }.to_sql
     assert_sql(/GROUP BY "users"."name"/, sql)
     assert_sql(/HAVING SUM\("users"."age"\) > 100/, sql)
   end
@@ -621,7 +1038,7 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_select_count_star_alias
-    assert_sql(/SELECT COUNT\(\*\) AS cnt/,
+    assert_sql(/SELECT COUNT\(\*\) AS "cnt"/,
       User.select { count(:*).as(:cnt) }.to_sql)
   end
 
@@ -630,9 +1047,9 @@ class TestBlockSyntax < Minitest::Test
       User.select { count(:name, distinct: true) }.to_sql)
   end
 
-  def test_count_distinct_as_method
-    assert_sql(/SELECT COUNT\(DISTINCT "users"."name"\) AS n/,
-      User.select { :name.count(distinct: true).as(:n) }.to_sql)
+  def test_count_distinct_aliased
+    assert_sql(/SELECT COUNT\(DISTINCT "users"."name"\) AS "n"/,
+      User.select { count(:name, distinct: true).as(:n) }.to_sql)
   end
 
   def test_count_distinct_in_having
@@ -690,11 +1107,6 @@ class TestBlockSyntax < Minitest::Test
     assert_sql(/HAVING SUM\("users"."age"\) > 100/, sql)
   end
 
-  def test_function_and_method_syntax_match
-    assert_equal User.select { :age.average }.to_sql,
-      User.select { avg(:age) }.to_sql
-  end
-
   def test_upper_function
     assert_sql(/SELECT UPPER\("users"."name"\)/,
       User.select { upper(:name) }.to_sql)
@@ -723,7 +1135,7 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_fn_alias
-    assert_sql(/SELECT date_trunc\('day', "users"."name"\) AS d/,
+    assert_sql(/SELECT date_trunc\('day', "users"."name"\) AS "d"/,
       User.select { fn(:date_trunc, 'day', :name).as(:d) }.to_sql)
   end
 
@@ -732,10 +1144,46 @@ class TestBlockSyntax < Minitest::Test
   # given the chance to close the identifier and carry on.
   INJECTION = %q{a" AS x, (SELECT 1) AS "y}
 
-  def test_alias_rejects_an_injected_name
-    assert_raises(ArgumentError) { User.select { :name.as(INJECTION.to_sym) } }
-    assert_raises(ArgumentError) { User.select { count(:*).as(INJECTION.to_sym) } }
-    assert_raises(ArgumentError) { User.select { :name.as(:'a; DROP TABLE users') } }
+  # An alias that is not a plain name is quoted by the adapter rather than
+  # refused, so an injected one becomes an alias with a strange name and
+  # nothing else.  Each spells the quoting its own way, so what is asserted is
+  # that the payload arrived as the name of the column it labelled.
+  def test_an_injected_alias_is_quoted_rather_than_refused
+    User.delete_all
+    User.create!(name: 'alice')
+    payload = 'a" FROM users; --'
+    row = User.select { :name.as(payload.to_sym) }.first
+    assert_equal('alice', row[payload])
+    assert_equal(1, User.count)
+  end
+
+  def test_an_alias_that_needs_quoting_gets_it
+    assert_sql(/AS "total sales"/, User.select { :name.as(:'total sales') }.to_sql)
+    assert_sql(/AS "select"/, User.select { :name.as(:select, quote: true) }.to_sql)
+    assert_sql(/AS "up per"/, User.select { upper(:name).as(:'up per') }.to_sql)
+    assert_sql(/AS "d epth"/, User.select { 0.as(:'d epth') }.to_sql)
+  end
+
+  # Quoted, the name asked for is the name that comes back.  Unquoted,
+  # PostgreSQL would fold the capital away and the other two would keep it.
+  def test_an_alias_keeps_the_name_as_written
+    assert_sql(/AS "postCount"/, User.select { :name.as(:postCount) }.to_sql)
+    User.delete_all
+    User.create!(name: 'alice')
+    assert_equal('alice', User.select { :name.as(:postCount) }.first['postCount'])
+  end
+
+  def test_quote_false_asks_for_the_name_as_it_is
+    assert_sql(/AS post_count/, User.select { :name.as(:post_count, quote: false) }.to_sql)
+    refute_match(/"post_count"/,
+      normalize_sql(User.select { :name.as(:post_count, quote: false) }.to_sql))
+  end
+
+  # Nothing quotes it, so a name that would be SQL has to be refused.
+  def test_quote_false_refuses_a_name_that_is_not_plain
+    e = assert_raises(ArgumentError) { User.select { :name.as(:'total sales', quote: false) } }
+    assert_match(/plain column alias/, e.message)
+    assert_raises(ArgumentError) { User.select { :name.as(INJECTION.to_sym, quote: false) } }
   end
 
   def test_fn_rejects_an_injected_name
@@ -743,8 +1191,8 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_plain_names_are_still_accepted
-    assert_sql(/AS post_count/, User.select { :name.as(:post_count) }.to_sql)
-    assert_sql(/AS 名前/, User.select { :name.as(:名前) }.to_sql)
+    assert_sql(/AS "post_count"/, User.select { :name.as(:post_count) }.to_sql)
+    assert_sql(/AS "名前"/, User.select { :name.as(:名前) }.to_sql)
     assert_sql(/SELECT myFunc\(/, User.select { fn(:myFunc, :name) }.to_sql)
     assert_sql(/SELECT pg_catalog.upper\(/,
       User.select { fn(:'pg_catalog.upper', :name) }.to_sql)
@@ -857,7 +1305,7 @@ class TestBlockSyntax < Minitest::Test
   def test_datetime_value_function_in_comparison_and_alias
     assert_sql(/WHERE "users"."name" < CURRENT_TIMESTAMP/,
       User.where { :name < current_timestamp }.to_sql)
-    assert_sql(/SELECT CURRENT_TIMESTAMP AS ts FROM/,
+    assert_sql(/SELECT CURRENT_TIMESTAMP AS "ts" FROM/,
       User.select { current_timestamp.as(:ts) }.to_sql)
   end
 
@@ -1003,7 +1451,7 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_arithmetic_multiplication
-    assert_sql(/SELECT "users"."age" \* 2 AS dbl/,
+    assert_sql(/SELECT "users"."age" \* 2 AS "dbl"/,
       User.select { (:age * 2).as(:dbl) }.to_sql)
   end
 
@@ -1023,11 +1471,6 @@ class TestBlockSyntax < Minitest::Test
       User.select { sum(:age * 2) }.to_sql)
   end
 
-  def test_aggregate_on_arithmetic
-    assert_sql(/SELECT SUM\(\("users"."age" \+ 1\)\) AS s/,
-      User.select { (:age + 1).sum.as(:s) }.to_sql)
-  end
-
   # Arel groups + and - but not * and /, which is how SQL precedence works
   # out anyway.
   def test_arithmetic_on_qualified_column
@@ -1035,6 +1478,110 @@ class TestBlockSyntax < Minitest::Test
       User.select { :users[:age] - 1 }.to_sql)
   end
 
+  def test_bitwise_and_or
+    assert_sql(/SELECT \("users"."flags" & 4\) AS "masked"/,
+      User.select { (:flags & 4).as(:masked) }.to_sql)
+    assert_sql(/SELECT \("users"."flags" \| 4\) AS "set"/,
+      User.select { (:flags | 4).as(:set) }.to_sql)
+  end
+
+  # Ruby puts & above >, so this groups the way it reads, and the node
+  # parenthesises itself so that the adapter's own precedence cannot regroup
+  # it -- PostgreSQL gives & and | the same one.
+  def test_bitwise_in_where_without_parentheses
+    assert_sql(/WHERE \("users"."flags" & 4\) > 0/,
+      User.where { :flags & 4 > 0 }.to_sql)
+  end
+
+  def test_bitwise_shifts
+    assert_sql(/SELECT \("users"."flags" << 2\)/, User.select { :flags << 2 }.to_sql)
+    assert_sql(/SELECT \("users"."flags" >> 1\)/, User.select { :flags >> 1 }.to_sql)
+  end
+
+  def test_bitwise_not
+    assert_sql(/SELECT \( ~ "users"."flags"\)/, User.select { ~:flags }.to_sql)
+  end
+
+  # The one operator the three do not share: PostgreSQL's # is where a comment
+  # starts on MySQL, MySQL's ^ is exponentiation to PostgreSQL, and SQLite has
+  # neither, so it gets the two operations XOR is made of.
+  def test_bitwise_xor_is_spelled_per_adapter
+    sql = User.select { :flags ^ 10 }.to_sql
+    case ADAPTER
+    when 'postgresql' then assert_sql(/SELECT \("users"."flags" # 10\)/, sql)
+    when 'mysql2' then assert_sql(/SELECT \("users"."flags" \^ 10\)/, sql)
+    else assert_sql(
+      /SELECT \(\("users"."flags" \| 10\) - \("users"."flags" & 10\)\)/, sql)
+    end
+  end
+
+  # Whatever the spelling, the answers agree.
+  def test_bitwise_execution
+    User.delete_all
+    User.create!(name: 'a', flags: 12)
+    assert_equal(8, User.select { (:flags & 10).as(:v) }.take.v.to_i)
+    assert_equal(14, User.select { (:flags | 10).as(:v) }.take.v.to_i)
+    assert_equal(6, User.select { (:flags ^ 10).as(:v) }.take.v.to_i)
+    assert_equal(48, User.select { (:flags << 2).as(:v) }.take.v.to_i)
+    assert_equal(6, User.select { (:flags >> 1).as(:v) }.take.v.to_i)
+    # MariaDB reads ~ back as the unsigned 64-bit number where the others give
+    # a negative one, so the assertion is on the bits rather than the value.
+    assert_equal(243, User.select { (~:flags & 255).as(:v) }.take.v.to_i)
+  end
+
+  # AND and OR are the conditions' own & and |, and an operand that is a
+  # condition means one of the two was meant.
+  def test_bitwise_refuses_a_condition
+    e = assert_raises(ArgumentError) { User.where { :flags & (:age == 1) } }
+    assert_match(/AND and OR/, e.message)
+  end
+
+  # MySQL and SQLite would take a boolean for the bit it is stored as and
+  # quietly answer as AND would; PostgreSQL has no such operator.
+  def test_bitwise_refuses_a_boolean_column
+    e = assert_raises(ArgumentError) { User.where { (:active & :active) > 0 }.to_sql }
+    assert_match(/true\?/, e.message)
+    assert_raises(ArgumentError) { User.select { ~:active }.to_sql }
+  end
+
+  def test_conditions_still_and_with_the_same_operators
+    assert_sql(/WHERE "users"."age" = 1 AND "users"."name" = 'a'/,
+      User.where { (:age == 1) & (:name == 'a') }.to_sql)
+  end
+
+  def test_bit_aggregates
+    skip_without_bit_aggregates
+    User.delete_all
+    User.create!([{name: 'a', flags: 12}, {name: 'b', flags: 10}, {name: 'c', flags: 3}])
+    assert_equal(0, User.select { bit_and(:flags).as(:v) }.take.v.to_i)
+    assert_equal(15, User.select { bit_or(:flags).as(:v) }.take.v.to_i)
+    assert_equal(5, User.select { bit_xor(:flags).as(:v) }.take.v.to_i)
+  end
+
+  # PostgreSQL counts the bits of a bit string rather than of a number, so the
+  # argument is cast there; bit(64) is what makes a negative answer alike.
+  def test_bit_count
+    if ADAPTER == 'sqlite3'
+      assert_raises(NotImplementedError) { User.select { bit_count(:flags) } }
+      return
+    end
+    User.delete_all
+    User.create!(name: 'a', flags: 12)
+    User.create!(name: 'b', flags: -1)
+    assert_equal([2, 64], User.select { bit_count(:flags).as(:v) }.order(:name).map {|u| u.v.to_i })
+    assert_sql(/BIT_COUNT\(CAST\("users"."flags" AS bit\(64\)\)\)/,
+      User.select { bit_count(:flags) }.to_sql) if ADAPTER == 'postgresql'
+  end
+
+  def test_bit_aggregates_are_unsupported_on_sqlite
+    if ADAPTER == 'sqlite3'
+      e = assert_raises(NotImplementedError) { User.select { bit_or(:flags) } }
+      assert_match(/bit_or/, e.message)
+    else
+      assert_sql(/BIT_OR\("users"."flags"\)/, User.select { bit_or(:flags) }.to_sql)
+    end
+  end
+
   def test_coalesce_function_with_literal
     assert_sql(/SELECT COALESCE\("users"."name", 'unknown'\)/,
       User.select { coalesce(:name, 'unknown') }.to_sql)
@@ -1057,7 +1604,7 @@ class TestBlockSyntax < Minitest::Test
 
   def test_aggregate_in
     assert_sql(/HAVING SUM\("users"."age"\) BETWEEN 1 AND 10/,
-      User.group(:name).having { :age.sum.in?(1..10) }.to_sql)
+      User.group(:name).having { sum(:age).in?(1..10) }.to_sql)
   end
 
   def test_nested_function
@@ -1086,22 +1633,22 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_select_function_with_alias
-    assert_sql(/SELECT UPPER\("users"."name"\) AS upper_name, "users"."age"/,
+    assert_sql(/SELECT UPPER\("users"."name"\) AS "upper_name", "users"."age"/,
       User.select { [upper(:name).as(:upper_name), :age] }.to_sql)
   end
 
   def test_select_column_alias
-    assert_sql(/SELECT "users"."name" AS n/,
+    assert_sql(/SELECT "users"."name" AS "n"/,
       User.select { :name.as(:n) }.to_sql)
   end
 
   def test_select_qualified_column_alias
-    assert_sql(/SELECT "users"."name" AS n/,
+    assert_sql(/SELECT "users"."name" AS "n"/,
       User.select { :users[:name].as(:n) }.to_sql)
   end
 
   def test_select_aggregate_alias
-    assert_sql(/SELECT COUNT\("users"."id"\) AS cnt/,
+    assert_sql(/SELECT COUNT\("users"."id"\) AS "cnt"/,
       User.select { count(:id).as(:cnt) }.to_sql)
   end
 
@@ -1175,8 +1722,510 @@ class TestBlockSyntax < Minitest::Test
     assert_sql(/HAVING SUM\("users"."age"\) > 100/, sql)
   end
 
+  # update_all's hash reads a symbol as the value it is; the block reads it as
+  # the column it names, which is what lets the new value be built from the old.
+  def test_update_all_from_the_column
+    Tally.delete_all
+    Tally.create!(page: '/a', hits: 1)
+    Tally.create!(page: '/b', hits: 2)
+    Tally.update_all { { hits: :hits + 1 } }
+    assert_equal([2, 3], Tally.order(:page).pluck(:hits))
+  end
+
+  def test_update_all_takes_any_expression
+    Tally.delete_all
+    Tally.create!(page: '/a', hits: 5)
+    Tally.update_all { { hits: case_when { :hits > 4 }.then(0).else(:hits), page: upper(:page) } }
+    assert_equal([['/A', 0]], Tally.pluck(:page, :hits))
+  end
+
+  def test_update_all_within_a_scope
+    Tally.delete_all
+    Tally.create!(page: '/a', hits: 1)
+    Tally.create!(page: '/b', hits: 1)
+    Tally.where { :page == '/a' }.update_all { { hits: 9 } }
+    assert_equal([9, 1], Tally.order(:page).pluck(:hits))
+  end
+
+  def test_update_all_without_a_block_is_unchanged
+    Tally.delete_all
+    Tally.create!(page: '/a', hits: 1)
+    Tally.update_all(hits: 4)
+    assert_equal([4], Tally.pluck(:hits))
+  end
+
+  def test_update_all_takes_updates_or_a_block
+    assert_raises(ArgumentError) { Tally.update_all({hits: 1}) { { hits: 2 } } }
+    e = assert_raises(ArgumentError) { Tally.update_all { :hits + 1 } }
+    assert_match(/hash of column/, e.message)
+  end
+
+  # on_duplicate takes SQL text and nothing else, so the block is compiled to
+  # some.  `excluded` is the row that could not be inserted.
+  def test_upsert_all_adds_to_what_is_there
+    Tally.delete_all
+    Tally.upsert_all([{page: '/a', hits: 1}], **upsert_target)
+    Tally.upsert_all([{page: '/a', hits: 10}], **upsert_target) {
+      { hits: :hits + excluded(:hits) }
+    }
+    assert_equal([11], Tally.pluck(:hits))
+  end
+
+  def test_upsert_all_inserts_when_there_is_no_conflict
+    Tally.delete_all
+    Tally.upsert_all([{page: '/new', hits: 3}], **upsert_target) {
+      { hits: :hits + excluded(:hits) }
+    }
+    assert_equal([3], Tally.pluck(:hits))
+  end
+
+  def test_upsert_all_takes_any_expression
+    Tally.delete_all
+    Tally.upsert_all([{page: '/a', hits: 7}], **upsert_target)
+    Tally.upsert_all([{page: '/a', hits: 2}], **upsert_target) {
+      { hits: greatest(:hits, excluded(:hits)) }
+    }
+    assert_equal([7], Tally.pluck(:hits))
+  end
+
+  def test_upsert_all_without_a_block_is_unchanged
+    Tally.delete_all
+    Tally.upsert_all([{page: '/a', hits: 1}], **upsert_target)
+    Tally.upsert_all([{page: '/a', hits: 6}], **upsert_target)
+    assert_equal([6], Tally.pluck(:hits))
+  end
+
+  def test_upsert_all_takes_on_duplicate_or_a_block
+    assert_raises(ArgumentError) do
+      Tally.upsert_all([{page: '/a', hits: 1}],
+                       on_duplicate: Arel.sql('hits = 1'), **upsert_target) { { hits: 2 } }
+    end
+    e = assert_raises(ArgumentError) do
+      Tally.upsert_all([{page: '/a', hits: 1}], **upsert_target) { {} }
+    end
+    assert_match(/at least one column/, e.message)
+  end
+
+  # Reading inside a JSON document, by the name of what Hash does.  No two
+  # adapters spell it alike, so what the tests assert is the value that comes
+  # back rather than the SQL.
+  def seed_docs
+    Doc.delete_all
+    Doc.create!(name: 'one',
+                meta: json_document({ 'a' => { 'b' => 'deep' }, 'n' => 5,
+                                      'tags' => %w[x y], 'odd key' => 1 }))
+    Doc.create!(name: 'two', meta: json_document({ 'n' => 9 }))
+  end
+
+  def test_dig_a_key
+    seed_docs
+    assert_equal(%w[5 9], Doc.order(:name).select { :meta.dig(:n).as(:v) }.map(&:v))
+  end
+
+  def test_dig_a_path
+    seed_docs
+    assert_equal(['deep', nil],
+      Doc.order(:name).select { :meta.dig(:a, :b).as(:v) }.map(&:v))
+  end
+
+  def test_dig_an_array_index
+    seed_docs
+    assert_equal(['x', nil],
+      Doc.order(:name).select { :meta.dig(:tags, 0).as(:v) }.map(&:v))
+  end
+
+  # A key that is not a plain name travels as itself rather than being refused.
+  def test_dig_a_key_that_needs_quoting
+    seed_docs
+    assert_equal(['1', nil],
+      Doc.order(:name).select { :meta.dig(:'odd key').as(:v) }.map(&:v))
+  end
+
+  # dig gives text on every adapter -- SQLite's ->> would otherwise give the
+  # value with its type -- so a number is compared through a cast.
+  def test_dig_is_text_everywhere
+    seed_docs
+    assert_equal(['one'], Doc.where { :meta.dig(:n) == '5' }.pluck(:name))
+    type = integer_type
+    assert_equal(['two'], Doc.where { cast(:meta.dig(:n), type) > 6 }.pluck(:name))
+  end
+
+  def test_dig_json_keeps_the_json
+    seed_docs
+    value = Doc.where { :name == 'one' }.select { :meta.dig_json(:tags).as(:v) }.first.v
+    assert_equal(%w[x y], value.is_a?(String) ? JSON.parse(value) : value)
+  end
+
+  def test_dig_from_a_qualified_column
+    seed_docs
+    assert_equal(['one'], Doc.where { :docs[:meta].dig(:a, :b) == 'deep' }.pluck(:name))
+  end
+
+  def test_key
+    seed_docs
+    assert_equal(['one'], Doc.where { :meta.key?(:tags) }.pluck(:name))
+    assert_equal(%w[one two], Doc.where { :meta.key?(:n) }.order(:name).pluck(:name))
+  end
+
+  def test_contains
+    skip_without_json_containment
+    seed_docs
+    assert_equal(['one'], Doc.where { :meta.contains?(n: 5) }.pluck(:name))
+    assert_equal([], Doc.where { :meta.contains?(n: 1) }.pluck(:name))
+  end
+
+  def test_contains_says_where_it_cannot_go
+    skip "#{ADAPTER} has JSON containment" unless ADAPTER == 'sqlite3'
+    assert_raises(NotImplementedError) { Doc.where { :meta.contains?(n: 5) }.to_sql }
+  end
+
+  def test_dig_needs_a_path
+    assert_raises(ArgumentError) { Doc.select { :meta.dig } }
+    e = assert_raises(ArgumentError) { Doc.select { :meta.dig(1.5) } }
+    assert_match(/key or an array index/, e.message)
+  end
+
+  # FILTER takes the aggregate over the rows a condition holds for.  MySQL has
+  # no such clause, so what is asserted across adapters is the number that
+  # comes back rather than the SQL.
+  def seed_for_filter
+    User.delete_all
+    User.create!(name: 'a', age: 10)
+    User.create!(name: 'a', age: 20)
+    User.create!(name: 'b', age: 100)
+  end
+
+  def aggregate(&block)
+    User.select(&block).to_a.first.v
+  end
+
+  def test_filter_a_count
+    seed_for_filter
+    assert_equal(2, aggregate { count(:*).filter { :age < 50 }.as(:v) }.to_i)
+  end
+
+  def test_filter_takes_a_value_as_well_as_a_block
+    seed_for_filter
+    assert_equal(2, aggregate { count(:*).filter(:age < 50).as(:v) }.to_i)
+  end
+
+  def test_filter_a_sum_and_an_average
+    seed_for_filter
+    assert_equal(30, aggregate { sum(:age).filter { :age < 50 }.as(:v) }.to_i)
+    assert_equal(15, aggregate { avg(:age).filter { :age < 50 }.as(:v) }.to_i)
+  end
+
+  def test_filter_a_distinct_count
+    seed_for_filter
+    assert_equal(1, aggregate { count(:name, distinct: true).filter { :age < 50 }.as(:v) }.to_i)
+  end
+
+  def test_filter_is_a_clause_where_there_is_one
+    skip "#{ADAPTER} has no FILTER" if ADAPTER == 'mysql2'
+    assert_sql(/COUNT\(\*\) FILTER \(WHERE "users"."age" < 50\)/,
+      User.select { count(:*).filter { :age < 50 } }.to_sql)
+  end
+
+  # Where there is not, the same rows are reached through a case: an aggregate
+  # passes over a NULL, so a row the condition misses is a row it does not see.
+  def test_filter_becomes_a_case_where_there_is_no_clause
+    skip "#{ADAPTER} has FILTER" unless ADAPTER == 'mysql2'
+    assert_sql(/COUNT\(CASE WHEN "users"."age" < 50 THEN 1 END\)/,
+      User.select { count(:*).filter { :age < 50 } }.to_sql)
+    assert_sql(/SUM\(CASE WHEN "users"."age" < 50 THEN "users"."age" END\)/,
+      User.select { sum(:age).filter { :age < 50 } }.to_sql)
+  end
+
+  def test_filter_needs_a_value_or_a_block
+    assert_raises(ArgumentError) { User.select { count(:*).filter } }
+    e = assert_raises(ArgumentError) { User.select { count(:*).filter(1) { 2 } } }
+    assert_match(/not both/, e.message)
+  end
+
+  # DISTINCT ON keeps the first row of each group the order brings up.
+  def seed_for_distinct_on
+    Author.delete_all
+    Author.create!(name: 'a')
+    Author.create!(name: 'a')
+    Author.create!(name: 'b')
+  end
+
+  def test_distinct_on
+    skip_without_distinct_on
+    seed_for_distinct_on
+    assert_sql(/SELECT DISTINCT ON \( "authors"."name" \)/,
+      Author.distinct_on { :name }.to_sql)
+    assert_equal(%w[a b], Author.distinct_on { :name }.order { :name }.pluck(:name))
+  end
+
+  def test_distinct_on_takes_columns_as_well_as_a_block
+    skip_without_distinct_on
+    assert_equal(Author.distinct_on { :name }.to_sql, Author.distinct_on(:name).to_sql)
+  end
+
+  def test_distinct_on_takes_several
+    skip_without_distinct_on
+    assert_sql(/DISTINCT ON \( "authors"."id", "authors"."name" \)/,
+      Author.distinct_on { [:id, :name] }.to_sql)
+  end
+
+  def test_distinct_on_takes_an_expression
+    skip_without_distinct_on
+    assert_sql(/DISTINCT ON \( UPPER\("authors"."name"\) \)/,
+      Author.distinct_on { upper(:name) }.to_sql)
+  end
+
+  # Arel carries the node and refuses to write it elsewhere, as it does a
+  # regexp, so the gem has nothing of its own to say.
+  def test_distinct_on_says_where_it_cannot_go
+    skip "#{ADAPTER} has DISTINCT ON" if ADAPTER == 'postgresql'
+    assert_raises(NotImplementedError) { Author.distinct_on { :name }.to_sql }
+  end
+
+  def test_distinct_on_needs_a_column
+    assert_raises(ArgumentError) { Author.distinct_on }
+  end
+
+  def test_distinct_on_spawns
+    refute_match(/DISTINCT ON/, Author.all.to_sql)
+    Author.distinct_on { :name }
+    refute_match(/DISTINCT ON/, Author.all.to_sql)
+  end
+
+  # A lateral join lets the relation joined see the row being joined to, which
+  # is what makes the top row of each group reachable in one query.
+  def top_post
+    Post.select { :title }.
+      where { :posts[:author_id] == :authors[:id] }.
+      order { :title.desc }.limit(1)
+  end
+
+  def seed_for_lateral
+    Author.delete_all
+    Post.delete_all
+    author = Author.create!(name: 'writes')
+    Author.create!(name: 'does not')
+    Post.create!(author_id: author.id, title: 'a')
+    Post.create!(author_id: author.id, title: 'b')
+  end
+
+  def test_lateral_join
+    skip_without_lateral
+    seed_for_lateral
+    rows = Author.joins(top_post, as: :top, lateral: true).
+      select { [:name, :top[:title].as(:v)] }.map {|r| [r.name, r.v] }
+    assert_equal([['writes', 'b']], rows)
+  end
+
+  # Left, so that a row with nothing to join to is kept.
+  def test_left_outer_lateral_join
+    skip_without_lateral
+    seed_for_lateral
+    rows = Author.left_outer_joins(top_post, as: :top, lateral: true).
+      select { [:name, :top[:title].as(:v)] }.order { :name }.map {|r| [r.name, r.v] }
+    assert_equal([['does not', nil], ['writes', 'b']], rows)
+  end
+
+  # Without a block the join is ON TRUE; what the subquery may see is said
+  # inside it.
+  def test_lateral_join_takes_an_on_clause
+    skip_without_lateral
+    seed_for_lateral
+    assert_equal(0, Author.joins(top_post, as: :top, lateral: true) {
+      :top[:title] == 'nothing'
+    }.count)
+    assert_sql(/ON TRUE/, Author.joins(top_post, as: :top, lateral: true).to_sql)
+  end
+
+  def test_lateral_join_needs_a_relation_and_a_name
+    e = assert_raises(ArgumentError) { Author.joins(:posts, as: :top, lateral: true) }
+    assert_match(/takes a relation/, e.message)
+    e = assert_raises(ArgumentError) { Author.joins(top_post, lateral: true) }
+    assert_match(/needs a name/, e.message)
+  end
+
+  def test_lateral_join_says_where_it_cannot_go
+    skip 'this one has LATERAL' if ADAPTER == 'postgresql' || (ADAPTER == 'mysql2' && !mariadb?)
+    e = assert_raises(NotImplementedError) { Author.joins(top_post, as: :top, lateral: true) }
+    assert_match(/lateral join has no equivalent/, e.message)
+  end
+
+  # Several groupings asked for at once, the totals of each coming back beside
+  # the rows.  What is asserted is the rows, since the point is which totals
+  # arrive rather than how the clause is spelled.
+  def seed_for_grouping
+    Post.delete_all
+    Author.delete_all
+    a = Author.create!(name: 'a')
+    b = Author.create!(name: 'b')
+    Post.create!(author_id: a.id, title: 'x')
+    Post.create!(author_id: a.id, title: 'y')
+    Post.create!(author_id: b.id, title: 'x')
+  end
+
+  def grouped(&block)
+    Post.group(&block).select { [:author_id, :title, count(:*).as(:n)] }.
+      map {|r| [r.author_id, r.title, r.n.to_i] }.sort_by(&:to_s)
+  end
+
+  def test_grouping_sets
+    skip_without_grouping_sets
+    seed_for_grouping
+    rows = grouped { grouping_sets([:author_id], [:title], []) }
+    assert_equal(3, rows.count {|_, title, _| title.nil? })      # by author
+    assert_includes(rows, [nil, 'x', 2])                          # by title
+    assert_includes(rows, [nil, nil, 3])                          # the whole
+  end
+
+  def test_rollup
+    skip_without_grouping_sets
+    seed_for_grouping
+    rows = grouped { rollup(:author_id, :title) }
+    assert_includes(rows, [nil, nil, 3])
+    assert_sql(/GROUP BY ROLLUP\( "posts"."author_id", "posts"."title" \)/,
+      Post.group { rollup(:author_id, :title) }.to_sql)
+  end
+
+  def test_cube
+    skip_without_grouping_sets
+    seed_for_grouping
+    assert_sql(/GROUP BY CUBE\( "posts"."author_id", "posts"."title" \)/,
+      Post.group { cube(:author_id, :title) }.to_sql)
+    # Every combination: by both, by each, and the whole.
+    assert_equal(8, Post.group { cube(:author_id, :title) }.select { count(:*).as(:n) }.to_a.size)
+  end
+
+  def test_grouping_sets_say_where_they_cannot_go
+    skip 'PostgreSQL has them' if ADAPTER == 'postgresql'
+    assert_raises(NotImplementedError) { Post.group { grouping_sets([:title]) } }
+    assert_raises(NotImplementedError) { Post.group { rollup(:title) } }
+    assert_raises(NotImplementedError) { Post.group { cube(:title) } }
+  end
+
+  def test_grouping_sets_need_something_to_group_by
+    assert_raises(ArgumentError) { Post.group { rollup } }
+    assert_raises(ArgumentError) { Post.group { grouping_sets } }
+  end
+
+  # bury sets what dig reads.  The document comes back changed rather than
+  # being written anywhere, so update_all is what makes it stick.
+  def buried(&block)
+    seed_docs
+    Doc.where { :name == 'one' }.update_all(&block)
+    value = Doc.find_by(name: 'one').meta
+    value.is_a?(String) ? JSON.parse(value) : value
+  end
+
+  def test_bury_a_nested_key
+    assert_equal('new', buried { { meta: :meta.bury(:a, :b, 'new') } }.dig('a', 'b'))
+  end
+
+  def test_bury_a_key_that_is_not_there_yet
+    assert_equal(9, buried { { meta: :meta.bury(:fresh, 9) } }['fresh'])
+  end
+
+  # A whole document, which each adapter takes its own way round.
+  def test_bury_an_object_and_an_array
+    assert_equal({ 'x' => 1 }, buried { { meta: :meta.bury(:obj, { 'x' => 1 }) } }['obj'])
+    assert_equal([1, 2], buried { { meta: :meta.bury(:arr, [1, 2]) } }['arr'])
+  end
+
+  def test_bury_an_array_index
+    assert_equal(%w[7 y], buried { { meta: :meta.bury(:tags, 0, '7') } }['tags'])
+  end
+
+  # The value can be read out of the document it is going into.
+  def test_bury_an_expression
+    assert_equal('5', buried { { meta: :meta.bury(:copy, :meta.dig(:n)) } }['copy'].to_s)
+  end
+
+  # It is an expression, so it does not have to be written anywhere.
+  def test_bury_in_a_select
+    seed_docs
+    value = Doc.where { :name == 'one' }.select { :meta.bury(:a, :b, 'x').as(:v) }.first.v
+    assert_equal('x', (value.is_a?(String) ? JSON.parse(value) : value).dig('a', 'b'))
+  end
+
+  def test_bury_needs_a_path
+    assert_raises(ArgumentError) { Doc.select { :meta.bury('v') } }
+    assert_raises(ArgumentError) { Doc.select { :meta.bury(1.5, 'v') } }
+  end
+
   def test_default_where_syntax
     assert_sql(/WHERE "users"."name" = 'Ruby' AND "users"."age" = 19/,
       User.where(name: 'Ruby', age: 19).to_sql)
   end
+
+  def test_value_in_a_select_list
+    assert_sql(/SELECT "users"."name", 0 AS "depth"/,
+      User.select { [:name, value(0).as(:depth)] }.to_sql)
+  end
+
+  # Each adapter escapes the apostrophe its own way, so what is asserted is
+  # that the string stays a value rather than reaching the SQL as written.
+  def test_value_is_quoted
+    User.delete_all
+    User.create!(name: 'alice')
+    payload = "it's a value"
+    assert_sql(/SELECT 'draft' AS "state"/,
+      User.select { value('draft').as(:state) }.to_sql)
+    assert_equal([payload],
+      User.select { value(payload).as(:note) }.map(&:note))
+  end
+
+  def test_a_bare_string_is_still_sql
+    assert_sql(/SELECT "users"."name", 1 \+ 1 AS two/,
+      User.select { [:name, '1 + 1 AS two'] }.to_sql)
+  end
+
+  def test_value_takes_the_predications
+    assert_sql(/WHERE 1 = "users"."age"/, User.where { value(1) == :users[:age] }.to_sql)
+    assert_sql(/WHERE 1 IS NULL/, User.where { value(1).null? }.to_sql)
+  end
+
+  def test_value_takes_the_arithmetics
+    assert_sql(/SELECT \(1 \+ "users"."age"\) AS "next_year"/,
+      User.select { (value(1) + :age).as(:next_year) }.to_sql)
+  end
+
+  def test_value_as_a_function_argument
+    assert_sql(/SELECT COALESCE\("users"."age", 0\)/,
+      User.select { coalesce(:age, value(0)) }.to_sql)
+  end
+
+  def test_integer_shorthand_for_value
+    assert_sql(/SELECT "users"."name", 0 AS "depth"/,
+      User.select { [:name, 0.as(:depth)] }.to_sql)
+  end
+
+  def test_float_shorthand_for_value
+    assert_sql(/SELECT 1\.5 AS "rate"/, User.select { 1.5.as(:rate) }.to_sql)
+  end
+
+  def test_numeric_shorthand_has_no_orderings
+    assert_raises(NoMethodError) { User.order { 1.asc } }
+    assert_raises(NoMethodError) { User.order { 1.desc } }
+  end
+
+  # The alias on a literal is quoted like any other, so a name that is not a
+  # plain one arrives as itself rather than as SQL.
+  def test_a_value_alias_is_quoted_rather_than_refused
+    User.delete_all
+    User.create!(name: 'alice')
+    payload = 'a" FROM users; --'
+    assert_equal(0, User.select { value(0).as(payload.to_sym) }.first[payload].to_i)
+    assert_equal(0, User.select { 0.as(payload.to_sym) }.first[payload].to_i)
+    assert_equal(1, User.count)
+  end
+
+  def test_a_value_selected_reaches_the_row
+    User.delete_all
+    User.create!(name: 'alice', age: 60)
+    assert_equal([['alice', 0]],
+      User.select { [:name, 0.as(:depth)] }.map {|u| [u.name, u.depth] })
+  end
+
+  def test_numeric_shorthand_is_confined_to_the_block
+    assert_raises(NoMethodError) { 0.as(:depth) }
+  end
 end