activerecord-refined 0.3.2 → 0.4.0

data/test/test_block_syntax.rb

@@ -61,6 +61,36 @@ class TestBlockSyntax < Minitest::Test
       User.where { :users[:name].like?('tender%') }.to_sql)
   end
 
+  # ILIKE is PostgreSQL's; elsewhere Arel emits LIKE, which those adapters
+  # already match case-insensitively by default.
+  def test_ilike
+    expected = ADAPTER == 'postgresql' ? 'ILIKE' : 'LIKE'
+    assert_sql(/WHERE "users"."name" #{expected} 'ma%'/,
+      User.where { :name.ilike?('ma%') }.to_sql)
+  end
+
+  def test_casecmp
+    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Matz'\)/,
+      User.where { :name.casecmp?('Matz') }.to_sql)
+  end
+
+  def test_casecmp_qualified
+    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Matz'\)/,
+      User.where { :users[:name].casecmp?('Matz') }.to_sql)
+  end
+
+  def test_casecmp_nil_is_rejected
+    e = assert_raises(ArgumentError) { User.where { :name.casecmp?(nil) } }
+    assert_match(/null\?/, e.message)
+  end
+
+  def test_casecmp_execution
+    User.delete_all
+    User.create!(name: 'Matz')
+    User.create!(name: 'nobu')
+    assert_equal(['Matz'], User.where { :name.casecmp?('mAtZ') }.pluck(:name))
+  end
+
   def test_not_like
     assert_sql(/WHERE NOT \("users"."name" LIKE 'tender%'\)/,
       User.where { !:name.like?('tender%') }.to_sql)
@@ -81,6 +111,35 @@ class TestBlockSyntax < Minitest::Test
       User.where { :name.include?('der') }.to_sql)
   end
 
+  # Like their String namesakes, start_with? and end_with? take any number
+  # of literals; matching any one of them is enough.
+  def test_start_with_multiple
+    assert_sql(
+      /WHERE \("users"."name" LIKE 'ma%' ESCAPE '\\' OR "users"."name" LIKE 'no%' ESCAPE '\\'\)/,
+      User.where { :name.start_with?('ma', 'no') }.to_sql)
+  end
+
+  def test_end_with_multiple
+    assert_sql(
+      /WHERE \("users"."name" LIKE '%z' ESCAPE '\\' OR "users"."name" LIKE '%love' ESCAPE '\\'\)/,
+      User.where { :name.end_with?('z', 'love') }.to_sql)
+  end
+
+  # The OR arrives grouped, so a following & applies to the whole list.
+  def test_start_with_multiple_combined
+    assert_sql(
+      /WHERE \("users"."name" LIKE 'ma%' ESCAPE '\\' OR "users"."name" LIKE 'no%' ESCAPE '\\'\) AND "users"."age" > 18/,
+      User.where { :name.start_with?('ma', 'no') & (:age > 18) }.to_sql)
+  end
+
+  def test_start_with_no_arguments
+    assert_raises(ArgumentError) { User.where { :name.start_with? } }
+  end
+
+  def test_end_with_no_arguments
+    assert_raises(ArgumentError) { User.where { :name.end_with? } }
+  end
+
   def test_start_with_escapes_wildcards
     assert_sql(/WHERE "users"."name" LIKE '100\\%\\_%' ESCAPE '\\'/,
       User.where { :name.start_with?('100%_') }.to_sql)
@@ -91,6 +150,99 @@ class TestBlockSyntax < Minitest::Test
       User.where { :name.include?('100%') }.to_sql)
   end
 
+  def test_member
+    assert_sql(/WHERE "users"."tags" @> '\{ruby\}'/,
+      User.where { :tags.member?('ruby') }.to_sql)
+  end
+
+  def test_member_qualified
+    assert_sql(/WHERE "users"."tags" @> '\{ruby\}'/,
+      User.where { :users[:tags].member?('ruby') }.to_sql)
+  end
+
+  def test_member_negated
+    assert_sql(/WHERE NOT \("users"."tags" @> '\{ruby\}'\)/,
+      User.where { !:tags.member?('ruby') }.to_sql)
+  end
+
+  # Ruby's [1, 2].member?([1]) is false: member? tests one element, and an
+  # Array argument would have to mean something the namesake does not.
+  def test_member_array_is_rejected
+    e = assert_raises(ArgumentError) { User.where { :tags.member?(%w[ruby rails]) } }
+    assert_match(/superset\?/, e.message)
+  end
+
+  def test_superset
+    assert_sql(/WHERE "users"."tags" @> '\{ruby,rails\}'/,
+      User.where { :tags.superset?(%w[ruby rails]) }.to_sql)
+  end
+
+  def test_superset_takes_a_set
+    assert_sql(/WHERE "users"."tags" @> '\{ruby,rails\}'/,
+      User.where { :tags.superset?(Set['ruby', 'rails']) }.to_sql)
+  end
+
+  def test_superset_rejects_a_scalar
+    assert_raises(ArgumentError) { User.where { :tags.superset?('ruby') } }
+  end
+
+  def test_subset
+    assert_sql(/WHERE "users"."tags" <@ '\{ruby,rails,go\}'/,
+      User.where { :tags.subset?(%w[ruby rails go]) }.to_sql)
+  end
+
+  def test_intersect
+    assert_sql(/WHERE "users"."tags" && '\{ruby,go\}'/,
+      User.where { :tags.intersect?(%w[ruby go]) }.to_sql)
+  end
+
+  def test_intersect_negated
+    assert_sql(/WHERE NOT \("users"."tags" && '\{ruby,go\}'\)/,
+      User.where { !:tags.intersect?(%w[ruby go]) }.to_sql)
+  end
+
+  def test_array_comparisons_execution
+    skip_without_array_columns
+    User.delete_all
+    User.create!(name: 'both', tags: %w[ruby rails])
+    User.create!(name: 'one', tags: %w[ruby go])
+    User.create!(name: 'neither', tags: %w[python])
+    assert_equal(['both'], User.where { :tags.superset?(%w[ruby rails]) }.pluck(:name))
+    assert_equal(['neither'], User.where { :tags.subset?(%w[python js]) }.pluck(:name))
+    assert_equal(%w[both one],
+      User.where { :tags.intersect?(%w[ruby js]) }.pluck(:name).sort)
+  end
+
+  # MySQL additionally escapes the double quotes inside its string literal,
+  # so the exact spelling is only asserted where the operator is real.
+  def test_member_quotes_special_elements
+    skip_without_array_columns
+    assert_sql(/WHERE "users"."tags" @> '\{"with,comma"\}'/,
+      User.where { :tags.member?('with,comma') }.to_sql)
+  end
+
+  # include? is a substring match even on an array column; only member?
+  # means containment.
+  def test_include_is_like_even_on_array_columns
+    skip_without_array_columns
+    assert_sql(/WHERE "users"."tags" LIKE '%ruby%' ESCAPE '\\'/,
+      User.where { :tags.include?('ruby') }.to_sql)
+  end
+
+  # Elements survive the trip through the array literal: % is an ordinary
+  # character there, a comma stays inside its element, and quotes and
+  # backslashes are escaped.
+  def test_member_matches_elements_literally
+    skip_without_array_columns
+    User.delete_all
+    User.create!(name: 'literal', tags: ['100%', 'with,comma', 'q"uote', 'back\\slash'])
+    User.create!(name: 'lookalike', tags: ['100200', 'with', 'comma'])
+    assert_equal(['literal'], User.where { :tags.member?('100%') }.pluck(:name))
+    assert_equal(['literal'], User.where { :tags.member?('with,comma') }.pluck(:name))
+    assert_equal(['literal'], User.where { :tags.member?('q"uote') }.pluck(:name))
+    assert_equal(['literal'], User.where { :tags.member?('back\\slash') }.pluck(:name))
+  end
+
   def test_regexp
     skip_without_regexp_support
     assert_sql(/WHERE "users"."name" #{regexp_operator} '\^ma'/,
@@ -161,6 +313,16 @@ class TestBlockSyntax < Minitest::Test
       User.where { :users[:name].null? }.to_sql)
   end
 
+  def test_equal_nil_is_rejected
+    e = assert_raises(ArgumentError) { User.where { :name == nil } }
+    assert_match(/null\?/, e.message)
+  end
+
+  def test_not_equal_nil_is_rejected
+    e = assert_raises(ArgumentError) { User.where { :name != nil } }
+    assert_match(/null\?/, e.message)
+  end
+
   def test_in
     assert_sql(/WHERE "users"."age" IN \(1, 2, 3\)/,
       User.where { :age.in?([1, 2, 3]) }.to_sql)
@@ -176,6 +338,120 @@ class TestBlockSyntax < Minitest::Test
       User.where { !:age.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
+    User.delete_all
+    User.create!(name: 'named')
+    User.create!(name: nil)
+    assert_equal([nil], User.where { :name.not_distinct_from?(nil) }.pluck(:name))
+    assert_equal(['named'], User.where { :name.distinct_from?(nil) }.pluck(:name))
+  end
+
+  def test_not_distinct_from_a_value_execution
+    User.delete_all
+    User.create!(name: 'matz')
+    User.create!(name: nil)
+    assert_equal(['matz'], User.where { :name.not_distinct_from?('matz') }.pluck(:name))
+    # Unlike !=, this keeps the NULL row.
+    assert_equal([nil], User.where { :name.distinct_from?('matz') }.pluck(:name))
+  end
+
+  def test_distinct_from_postgresql_syntax
+    skip "#{ADAPTER} spells it differently" unless ADAPTER == 'postgresql'
+    assert_sql(/WHERE "users"."name" IS NOT DISTINCT FROM 'x'/,
+      User.where { :name.not_distinct_from?('x') }.to_sql)
+    assert_sql(/WHERE "users"."name" IS DISTINCT FROM 'x'/,
+      User.where { :name.distinct_from?('x') }.to_sql)
+  end
+
+  def test_comparison_with_scalar_subquery
+    assert_sql(/WHERE "users"."age" >= \(SELECT AVG\("users"."age"\) FROM "users"\)/,
+      User.where { :age >= User.select { avg(:age) } }.to_sql)
+  end
+
+  def test_equality_with_scalar_subquery
+    assert_sql(/WHERE "users"."age" = \(SELECT MAX\("users"."age"\) FROM "users"\)/,
+      User.where { :age == User.select { max(:age) } }.to_sql)
+  end
+
+  # A scalar comparison has no sensible default select list, unlike in?.
+  def test_scalar_subquery_without_select_is_rejected
+    e = assert_raises(ArgumentError) { User.where { :age >= User.all } }
+    assert_match(/select/, e.message)
+  end
+
+  def test_scalar_subquery_execution
+    User.delete_all
+    User.create!(name: 'young', age: 20)
+    User.create!(name: 'old', age: 60)
+    assert_equal(['old'], User.where { :age >= User.select { avg(:age) } }.pluck(:name))
+  end
+
+  def test_in_subquery
+    assert_sql(
+      /WHERE "authors"."id" IN \(SELECT "posts"."author_id" FROM "posts" WHERE "posts"."title" = 'pub'\)/,
+      Author.where { :id.in?(Post.where(title: 'pub').select(:author_id)) }.to_sql)
+  end
+
+  # A relation without an explicit select list selects its primary key, the
+  # same way ActiveRecord's own where(id: relation) does.
+  def test_in_subquery_selects_primary_key_by_default
+    assert_sql(/WHERE "authors"."id" IN \(SELECT "posts"."id" FROM "posts"\)/,
+      Author.where { :id.in?(Post.all) }.to_sql)
+  end
+
+  def test_not_in_subquery
+    assert_sql(/WHERE NOT \("authors"."id" IN \(SELECT "posts"."author_id" FROM "posts"\)\)/,
+      Author.where { !:id.in?(Post.select(:author_id)) }.to_sql)
+  end
+
+  # The subquery correlates with the outer table through qualified columns,
+  # and its own where block goes through the DSL too.
+  def test_exists
+    assert_sql(
+      /WHERE EXISTS \(SELECT "posts"\.\* FROM "posts" WHERE "posts"."author_id" = "authors"."id"\)/,
+      Author.where { exists?(Post.where { :posts[:author_id] == :authors[:id] }) }.to_sql)
+  end
+
+  def test_not_exists
+    assert_sql(/WHERE NOT \(EXISTS \(SELECT "posts"\.\* FROM "posts"\)\)/,
+      Author.where { !exists?(Post.all) }.to_sql)
+  end
+
+  def test_exists_combined
+    assert_sql(
+      /WHERE "authors"."name" = 'matz' AND EXISTS \(SELECT "posts"\.\* FROM "posts" WHERE "posts"."title" = 'pub'\)/,
+      Author.where { (:name == 'matz') & exists?(Post.where(title: 'pub')) }.to_sql)
+  end
+
+  def test_exists_execution
+    Author.delete_all
+    Post.delete_all
+    with_post = Author.create!(name: 'with_post')
+    Author.create!(name: 'without')
+    Post.create!(title: 'pub', author_id: with_post.id)
+    correlated = -> { Post.where { :posts[:author_id] == :authors[:id] } }
+    assert_equal(['with_post'],
+      Author.where { exists?(correlated.call) }.pluck(:name))
+    assert_equal(['without'],
+      Author.where { !exists?(correlated.call) }.pluck(:name))
+  end
+
+  def test_in_subquery_execution
+    Author.delete_all
+    Post.delete_all
+    published = Author.create!(name: 'published')
+    drafting = Author.create!(name: 'drafting')
+    Post.create!(title: 'pub', author_id: published.id)
+    Post.create!(title: 'draft', author_id: drafting.id)
+    subquery = -> { Post.where(title: 'pub').select(:author_id) }
+    assert_equal(['published'],
+      Author.where { :id.in?(subquery.call) }.pluck(:name))
+    assert_equal(['drafting'],
+      Author.where { !:id.in?(subquery.call) }.pluck(:name))
+  end
+
   # == passes a Range or an Array through as a value rather than expanding it,
   # so that it compares against a PostgreSQL range or array column. The SQL
   # literal depends on the column type, so assert on the Arel node instead.
@@ -220,6 +496,84 @@ class TestBlockSyntax < Minitest::Test
     assert_sql(/LEFT OUTER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
   end
 
+  # The alias is what the block's qualified columns name, which is what makes
+  # a self join expressible at all.  Adapters differ on writing the AS
+  # keyword, so the assertions allow either.
+  def test_joins_with_alias
+    assert_sql(
+      /INNER JOIN "authors" (?:AS )?"mentors" ON "mentors"."id" = "authors"."id"/,
+      Author.joins(:authors, as: :mentors) { :mentors[:id] == :authors[:id] }.to_sql)
+  end
+
+  def test_left_outer_joins_with_alias
+    assert_sql(
+      /LEFT OUTER JOIN "authors" (?:AS )?"mentors" ON "mentors"."id" = "authors"."id"/,
+      Author.left_outer_joins(:authors, as: :mentors) { :mentors[:id] == :authors[:id] }.to_sql)
+  end
+
+  def test_joins_alias_needs_a_block
+    assert_raises(ArgumentError) { Author.joins(:posts, as: :p) }
+    assert_raises(ArgumentError) { Author.left_outer_joins(:posts, as: :p) }
+  end
+
+  def test_joins_without_alias_still_delegates
+    assert_sql(/INNER JOIN "posts" ON "posts"."author_id" = "authors"."id"/,
+      Author.joins(:posts).to_sql)
+  end
+
+  def test_self_join_execution
+    Author.delete_all
+    Author.create!(name: 'shared')
+    Author.create!(name: 'other')
+    assert_equal(%w[other shared],
+      Author.joins(:authors, as: :mentors) { :mentors[:name] == :authors[:name] }.
+        pluck(:name).sort)
+  end
+
+  # ActiveRecord's from only takes a table name as a string.
+  def test_from_symbol
+    assert_sql(/FROM "tree"/, Node.from(:tree).to_sql)
+  end
+
+  def test_from_symbol_with_alias
+    assert_sql(/FROM "tree" (?:AS )?"nodes"/, Node.from(:tree, as: :nodes).to_sql)
+  end
+
+  def test_from_string_still_delegates
+    assert_sql(/FROM subq/, Node.from('subq').to_sql)
+  end
+
+  def test_from_alias_needs_a_symbol
+    assert_raises(ArgumentError) { Node.from('tree', as: :nodes) }
+  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
+    Node.delete_all
+    root = Node.create!(name: 'root')
+    child = Node.create!(name: 'child', parent_id: root.id)
+    Node.create!(name: 'grandchild', parent_id: child.id)
+    Node.create!(name: 'unrelated', parent_id: nil)
+    descendants = Node.with_recursive(
+      tree: [
+        Node.where { :id == root.id },
+        Node.joins(:tree) { :nodes[:parent_id] == :tree[:id] },
+      ]
+    ).from(:tree, as: :nodes)
+    assert_equal(%w[child grandchild root], descendants.pluck(:name).sort)
+  end
+
+  def test_cte_joined_by_name
+    Node.delete_all
+    root = Node.create!(name: 'root')
+    Node.create!(name: 'child', parent_id: root.id)
+    Node.create!(name: 'orphan', parent_id: nil)
+    q = Node.with(roots: Node.where { :parent_id.null? }).
+      joins(:roots) { :roots[:id] == :nodes[:parent_id] }
+    assert_equal(['child'], q.pluck(:name))
+  end
+
   def test_select_aggregate
     assert_sql(/SELECT SUM\("users"."age"\)/,
       User.select { :age.sum }.to_sql)
@@ -271,6 +625,33 @@ class TestBlockSyntax < Minitest::Test
       User.select { count(:*).as(:cnt) }.to_sql)
   end
 
+  def test_count_distinct
+    assert_sql(/SELECT COUNT\(DISTINCT "users"."name"\)/,
+      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)
+  end
+
+  def test_count_distinct_in_having
+    assert_sql(/HAVING COUNT\(DISTINCT "users"."name"\) > 1/,
+      User.group(:age).having { count(:name, distinct: true) > 1 }.to_sql)
+  end
+
+  # DISTINCT is Arel's only aggregate modifier, and COUNT(DISTINCT *) is not
+  # valid SQL.
+  def test_distinct_is_rejected_for_other_aggregates
+    assert_raises(ArgumentError) do
+      ActiveRecord::Refined::AST::Aggregate.new(:age, :sum, distinct: true)
+    end
+  end
+
+  def test_count_star_distinct_is_rejected
+    assert_raises(ArgumentError) { User.select { count(:*, distinct: true) } }
+  end
+
   def test_having_count_star
     sql = Author.joins(:posts) { :posts[:author_id] == :authors[:id] }.
       group { :authors[:id] }.
@@ -329,6 +710,180 @@ class TestBlockSyntax < Minitest::Test
       User.where { length(:name) > 3 }.to_sql)
   end
 
+  # fn emits the name as written, so a case-sensitive one can be spelled
+  # exactly.
+  def test_fn
+    assert_sql(/SELECT date_trunc\('day', "users"."name"\)/,
+      User.select { fn(:date_trunc, 'day', :name) }.to_sql)
+  end
+
+  def test_fn_is_comparable
+    assert_sql(/WHERE char_length\("users"."name"\) > 3/,
+      User.where { fn(:char_length, :name) > 3 }.to_sql)
+  end
+
+  def test_fn_alias
+    assert_sql(/SELECT date_trunc\('day', "users"."name"\) AS d/,
+      User.select { fn(:date_trunc, 'day', :name).as(:d) }.to_sql)
+  end
+
+  # Aliases and function names are written into the SQL where a value would
+  # have been quoted, so a name that is not plain is refused rather than
+  # 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') } }
+  end
+
+  def test_fn_rejects_an_injected_name
+    assert_raises(ArgumentError) { User.select { fn(INJECTION.to_sym, :name) } }
+  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(/SELECT myFunc\(/, User.select { fn(:myFunc, :name) }.to_sql)
+    assert_sql(/SELECT pg_catalog.upper\(/,
+      User.select { fn(:'pg_catalog.upper', :name) }.to_sql)
+  end
+
+  # Values go through the adapter's quoting, which each spells its own way,
+  # so what is asserted is that the payload stays a value: it matches no row
+  # rather than opening the condition up.
+  def test_values_are_quoted
+    User.delete_all
+    User.create!(name: 'matz')
+    User.create!(name: 'nobu')
+    payload = "x' OR 1=1 --"
+    assert_empty(User.where { :name == payload }.pluck(:name))
+    assert_empty(User.where { :name.like?(payload) }.pluck(:name))
+    assert_empty(User.where { :name.in?([payload]) }.pluck(:name))
+    assert_empty(User.where { :name.include?(payload) }.pluck(:name))
+  end
+
+  # Likewise for column names: the payload becomes one identifier, so the
+  # database rejects it as an unknown column instead of running it.
+  def test_column_names_are_quoted
+    assert_raises(ActiveRecord::StatementInvalid) do
+      User.where { :users[INJECTION.to_sym] == 1 }.to_a
+    end
+  end
+
+  def test_scalar_functions_shared_by_every_adapter
+    assert_sql(/SELECT CONCAT\(UPPER\("users"."name"\), 'x'\)/,
+      User.select { concat(upper(:name), 'x') }.to_sql)
+    assert_sql(/WHERE MOD\("users"."age", 7\) = 0/,
+      User.where { mod(:age, 7) == 0 }.to_sql)
+  end
+
+  # SQLite has no CHAR_LENGTH, GREATEST or LEAST, but LENGTH, MAX and MIN
+  # mean the same thing there.
+  def test_scalar_functions_spelled_differently_on_sqlite
+    expected = ADAPTER == 'sqlite3' ? %w[LENGTH MAX MIN] : %w[CHAR_LENGTH GREATEST LEAST]
+    assert_sql(/SELECT #{expected[0]}\("users"."name"\)/,
+      User.select { char_length(:name) }.to_sql)
+    assert_sql(/SELECT #{expected[1]}\("users"."age", 18\)/,
+      User.select { greatest(:age, 18) }.to_sql)
+    assert_sql(/SELECT #{expected[2]}\("users"."age", 99\)/,
+      User.select { least(:age, 99) }.to_sql)
+  end
+
+  def test_scalar_functions_run
+    User.delete_all
+    User.create!(name: 'matz', age: 60)
+    assert_equal(['MATZ-x'], User.select { concat(upper(:name), '-x').as(:v) }.map(&:v))
+    assert_equal([4], User.select { char_length(:name).as(:v) }.map(&:v))
+    assert_equal([60], User.select { greatest(:age, 18).as(:v) }.map(&:v))
+  end
+
+  # rand takes the name back from Kernel#rand, which would otherwise answer
+  # inside the block and never reach the database.
+  def test_rand
+    expected = ADAPTER == 'mysql2' ? 'RAND' : 'RANDOM'
+    assert_sql(/ORDER BY #{expected}\(\)/, User.order { rand }.to_sql)
+  end
+
+  # Where an adapter has no equivalent, the block raises instead of leaving
+  # the database to reject the SQL.
+  def test_unsupported_function_raises
+    if ADAPTER == 'postgresql'
+      assert_sql(/SELECT DATE_TRUNC\('day', "users"."name"\)/,
+        User.select { date_trunc('day', :name) }.to_sql)
+    else
+      e = assert_raises(NotImplementedError) { User.select { date_trunc('day', :name) } }
+      assert_match(/date_trunc/, e.message)
+    end
+  end
+
+  # MySQL's FORMAT is a different function that happens to share the name,
+  # and reads a printf template as the number zero rather than complaining,
+  # so the name carries the printf one and MySQL raises.
+  def test_format_is_printf_and_unsupported_on_mysql
+    if ADAPTER == 'mysql2'
+      assert_raises(NotImplementedError) { User.select { format('%s!', :name) } }
+    else
+      User.delete_all
+      User.create!(name: 'matz')
+      assert_equal(['matz!'], User.select { format('%s!', :name).as(:v) }.map(&:v))
+    end
+  end
+
+  # MySQL's own is still reachable, spelled as the different thing it is.
+  def test_mysql_format_through_fn
+    assert_sql(/SELECT format\(1234.5678, 2\)/,
+      User.select { fn(:format, 1234.5678, 2) }.to_sql)
+  end
+
+  def test_now_is_unsupported_on_sqlite
+    if ADAPTER == 'sqlite3'
+      assert_raises(NotImplementedError) { User.select { now } }
+    else
+      assert_sql(/SELECT NOW\(\)/, User.select { now }.to_sql)
+    end
+  end
+
+  # A name with no method of its own is still a NoMethodError, not a
+  # function call the database has to reject.
+  def test_unknown_function_is_a_no_method_error
+    assert_raises(NoMethodError) { User.select { uppr(:name) } }
+  end
+
+  def test_arithmetic_multiplication
+    assert_sql(/SELECT "users"."age" \* 2 AS dbl/,
+      User.select { (:age * 2).as(:dbl) }.to_sql)
+  end
+
+  # Ruby puts * above >, so the expression groups the way it reads.
+  def test_arithmetic_in_where_without_parentheses
+    assert_sql(/WHERE "users"."age" \* 2 > 100/,
+      User.where { :age * 2 > 100 }.to_sql)
+  end
+
+  def test_arithmetic_between_columns
+    assert_sql(/WHERE \("users"."age" \+ "users"."id"\) \/ 2 <= 30/,
+      User.where { (:age + :id) / 2 <= 30 }.to_sql)
+  end
+
+  def test_arithmetic_inside_aggregate
+    assert_sql(/SELECT SUM\("users"."age" \* 2\)/,
+      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
+    assert_sql(/SELECT \("users"."age" - 1\)/,
+      User.select { :users[:age] - 1 }.to_sql)
+  end
+
   def test_coalesce_function_with_literal
     assert_sql(/SELECT COALESCE\("users"."name", 'unknown'\)/,
       User.select { coalesce(:name, 'unknown') }.to_sql)
@@ -419,6 +974,30 @@ class TestBlockSyntax < Minitest::Test
       User.order { [:age.desc, :name.asc] }.to_sql)
   end
 
+  def test_order_nulls_first
+    skip_without_nulls_ordering_syntax
+    assert_sql(/ORDER BY "users"."age" ASC NULLS FIRST/,
+      User.order { :age.asc.nulls_first }.to_sql)
+  end
+
+  def test_order_nulls_last
+    skip_without_nulls_ordering_syntax
+    assert_sql(/ORDER BY "users"."age" DESC NULLS LAST, "users"."name" ASC/,
+      User.order { [:age.desc.nulls_last, :name.asc] }.to_sql)
+  end
+
+  # The order itself is portable even where the syntax is not.
+  def test_order_nulls_execution
+    User.delete_all
+    User.create!(name: 'null_age', age: nil)
+    User.create!(name: 'young', age: 20)
+    User.create!(name: 'old', age: 60)
+    assert_equal(%w[null_age young old],
+      User.order { :age.asc.nulls_first }.pluck(:name))
+    assert_equal(%w[young old null_age],
+      User.order { :age.asc.nulls_last }.pluck(:name))
+  end
+
   def test_order_qualified_column
     assert_sql(/ORDER BY "users"."name" DESC/,
       User.order { :users[:name].desc }.to_sql)

data/test/test_helper.rb

@@ -62,6 +62,16 @@ module SqlAssertions
     skip "#{ADAPTER} has no regexp operator" unless REGEXP_OPERATORS.key?(ADAPTER)
   end
 
+  def skip_without_array_columns
+    skip "#{ADAPTER} has no array columns" unless ADAPTER == 'postgresql'
+  end
+
+  # MySQL has no NULLS FIRST/LAST; Arel emulates it with a leading IS NULL
+  # ordering, so only the resulting order is portable, not the SQL.
+  def skip_without_nulls_ordering_syntax
+    skip "#{ADAPTER} emulates NULLS FIRST/LAST" if ADAPTER == 'mysql2'
+  end
+
   def regexp_operator
     Regexp.escape(REGEXP_OPERATORS.fetch(ADAPTER).first)
   end
@@ -100,14 +110,24 @@ class Post < ActiveRecord::Base
   belongs_to :author
 end
 
+# Self-referencing, for the recursive CTE tests.
+class Node < ActiveRecord::Base
+end
+
 class CreateAllTables < ActiveRecord::Migration[8.1]
   def up
     drop_table(:users, if_exists: true)
     drop_table(:authors, if_exists: true)
     drop_table(:posts, if_exists: true)
-    create_table(:users) {|t| t.string :name; t.integer :age}
+    drop_table(:nodes, if_exists: true)
+    create_table(:users) do |t|
+      t.string :name
+      t.integer :age
+      t.string :tags, array: true if ADAPTER == 'postgresql'
+    end
     create_table(:authors) {|t| t.string :name}
     create_table(:posts) {|t| t.string :title; t.integer :author_id}
+    create_table(:nodes) {|t| t.string :name; t.integer :parent_id}
   end
 end
 ActiveRecord::Migration.verbose = false