activerecord-refined 0.3.3 → 0.5.0

data/test/test_block_syntax.rb

@@ -2,11 +2,11 @@ require_relative 'test_helper'
 
 class TestBlockSyntax < Minitest::Test
   def test_equal
-    assert_sql(/WHERE "users"."name" = 'matz'/, User.where { :name == 'matz' }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'alice'/, User.where { :name == 'alice' }.to_sql)
   end
 
   def test_not_equal
-    assert_sql(/WHERE "users"."name" != 'nobu'/, User.where { :name != 'nobu' }.to_sql)
+    assert_sql(/WHERE "users"."name" != 'bob'/, User.where { :name != 'bob' }.to_sql)
   end
 
   def test_greater_than
@@ -34,23 +34,23 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_and
-    assert_sql(/WHERE "users"."name" = 'matz' AND "users"."age" > 18/,
-      User.where { (:name == 'matz') & (:age > 18) }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'alice' AND "users"."age" > 18/,
+      User.where { (:name == 'alice') & (:age > 18) }.to_sql)
   end
 
   def test_or
-    assert_sql(/WHERE \(?\"users\".\"name\" = 'matz' OR \"users\".\"name\" = 'nobu'\)?/,
-      User.where { (:name == 'matz') | (:name == 'nobu') }.to_sql)
+    assert_sql(/WHERE \(?\"users\".\"name\" = 'alice' OR \"users\".\"name\" = 'bob'\)?/,
+      User.where { (:name == 'alice') | (:name == 'bob') }.to_sql)
   end
 
   def test_not
-    assert_sql(/WHERE NOT \(?\"users\".\"name\" = 'matz'\)?/,
-      User.where { !(:name == 'matz') }.to_sql)
+    assert_sql(/WHERE NOT \(?\"users\".\"name\" = 'alice'\)?/,
+      User.where { !(:name == 'alice') }.to_sql)
   end
 
   def test_complex_combination
-    sql = User.where { ((:name == 'matz') & (:age > 18)) | !(:name == 'nobu') }.to_sql
-    assert_sql(/"users"."name" = 'matz'/, sql)
+    sql = User.where { ((:name == 'alice') & (:age > 18)) | !(:name == 'bob') }.to_sql
+    assert_sql(/"users"."name" = 'alice'/, sql)
     assert_sql(/"users"."age" > 18/, sql)
     assert_sql(/NOT/, sql)
     assert_sql(/OR/, sql)
@@ -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\('Alice'\)/,
+      User.where { :name.casecmp?('Alice') }.to_sql)
+  end
+
+  def test_casecmp_qualified
+    assert_sql(/WHERE LOWER\("users"."name"\) = LOWER\('Alice'\)/,
+      User.where { :users[:name].casecmp?('Alice') }.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: 'Alice')
+    User.create!(name: 'bob')
+    assert_equal(['Alice'], User.where { :name.casecmp?('aLiCe') }.pluck(:name))
+  end
+
   def test_not_like
     assert_sql(/WHERE NOT \("users"."name" LIKE 'tender%'\)/,
       User.where { !:name.like?('tender%') }.to_sql)
@@ -85,8 +115,8 @@ class TestBlockSyntax < Minitest::Test
   # 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)
+      /WHERE \("users"."name" LIKE 'al%' ESCAPE '\\' OR "users"."name" LIKE 'bo%' ESCAPE '\\'\)/,
+      User.where { :name.start_with?('al', 'bo') }.to_sql)
   end
 
   def test_end_with_multiple
@@ -98,8 +128,8 @@ class TestBlockSyntax < Minitest::Test
   # 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)
+      /WHERE \("users"."name" LIKE 'al%' ESCAPE '\\' OR "users"."name" LIKE 'bo%' ESCAPE '\\'\) AND "users"."age" > 18/,
+      User.where { :name.start_with?('al', 'bo') & (:age > 18) }.to_sql)
   end
 
   def test_start_with_no_arguments
@@ -135,9 +165,52 @@ class TestBlockSyntax < Minitest::Test
       User.where { !:tags.member?('ruby') }.to_sql)
   end
 
-  def test_member_multiple_elements
+  # 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.member?(%w[ruby rails]) }.to_sql)
+      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,
@@ -265,6 +338,56 @@ 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: 'alice')
+    User.create!(name: nil)
+    assert_equal(['alice'], User.where { :name.not_distinct_from?('alice') }.pluck(:name))
+    # Unlike !=, this keeps the NULL row.
+    assert_equal([nil], User.where { :name.distinct_from?('alice') }.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'\)/,
@@ -298,8 +421,8 @@ class TestBlockSyntax < Minitest::Test
 
   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)
+      /WHERE "authors"."name" = 'alice' AND EXISTS \(SELECT "posts"\.\* FROM "posts" WHERE "posts"."title" = 'pub'\)/,
+      Author.where { (:name == 'alice') & exists?(Post.where(title: 'pub')) }.to_sql)
   end
 
   def test_exists_execution
@@ -354,8 +477,8 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_qualified_column
-    assert_sql(/WHERE "users"."name" = 'matz'/,
-      User.where { :users[:name] == 'matz' }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'alice'/,
+      User.where { :users[:name] == 'alice' }.to_sql)
   end
 
   def test_column_to_column_comparison
@@ -373,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)
@@ -424,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] }.
@@ -482,6 +710,331 @@ 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: 'alice')
+    User.create!(name: 'bob')
+    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: 'alice', age: 60)
+    assert_equal(['ALICE-x'], User.select { concat(upper(:name), '-x').as(:v) }.map(&:v))
+    assert_equal([5], 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: 'alice')
+      assert_equal(['alice!'], 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
+
+  # CURRENT_TIMESTAMP and its relatives are grammar rather than calls, so
+  # they come out without the parentheses PostgreSQL and SQLite reject.
+  def test_datetime_value_functions_are_emitted_bare
+    assert_sql(/SELECT CURRENT_TIMESTAMP FROM/,
+      User.select { current_timestamp }.to_sql)
+    assert_sql(/SELECT CURRENT_DATE FROM/, User.select { current_date }.to_sql)
+    assert_sql(/SELECT CURRENT_TIME FROM/, User.select { current_time }.to_sql)
+  end
+
+  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/,
+      User.select { current_timestamp.as(:ts) }.to_sql)
+  end
+
+  def test_current_timestamp_runs
+    User.delete_all
+    User.create!(name: 'alice')
+    refute_nil(User.select { current_timestamp.as(:v) }.sole.v)
+  end
+
+  # The one thing that does go into the parentheses is a precision, which
+  # current_date never takes and SQLite never accepts.
+  def test_datetime_value_function_with_precision
+    if ADAPTER == 'sqlite3'
+      e = assert_raises(NotImplementedError) { User.select { current_timestamp(3) } }
+      assert_match(/precision/, e.message)
+    else
+      assert_sql(/SELECT CURRENT_TIMESTAMP\(3\) FROM/,
+        User.select { current_timestamp(3) }.to_sql)
+      assert_sql(/SELECT CURRENT_TIME\(0\) FROM/,
+        User.select { current_time(0) }.to_sql)
+      User.delete_all
+      User.create!(name: 'alice')
+      refute_nil(User.select { current_timestamp(0).as(:v) }.sole.v)
+    end
+  end
+
+  def test_current_date_takes_no_precision
+    assert_raises(ArgumentError) { User.select { current_date(0) } }
+  end
+
+  # The precision is written into the SQL as given, so only an Integer is
+  # accepted there.
+  def test_precision_must_be_an_integer
+    assert_raises(ArgumentError) do
+      User.select { current_timestamp(:'3); DROP TABLE users --') }
+    end
+  end
+
+  def test_localtime_is_unsupported_on_sqlite
+    if ADAPTER == 'sqlite3'
+      assert_raises(NotImplementedError) { User.select { localtime } }
+      assert_raises(NotImplementedError) { User.select { localtimestamp } }
+    else
+      assert_sql(/SELECT LOCALTIME FROM/, User.select { localtime }.to_sql)
+      assert_sql(/SELECT LOCALTIMESTAMP FROM/,
+        User.select { localtimestamp }.to_sql)
+    end
+  end
+
+  def test_math_functions
+    assert_sql(/SELECT SIGN\("users"."age"\)/, User.select { sign(:age) }.to_sql)
+    assert_sql(/SELECT ATAN2\("users"."age", 2\)/,
+      User.select { atan2(:age, 2) }.to_sql)
+    assert_sql(/SELECT PI\(\)/, User.select { pi }.to_sql)
+    assert_sql(/SELECT DEGREES\(RADIANS\("users"."age"\)\)/,
+      User.select { degrees(radians(:age)) }.to_sql)
+  end
+
+  def test_math_functions_run
+    User.delete_all
+    User.create!(name: 'alice', age: 60)
+    assert_equal(1, User.select { sign(:age).as(:v) }.sole.v.to_i)
+    assert_equal(60,
+      User.select { round(degrees(radians(:age))).as(:v) }.sole.v.to_i)
+  end
+
+  # PostgreSQL spells log2(x) as log(2, x), which no renaming carries.
+  def test_log2_is_unsupported_on_postgresql
+    if ADAPTER == 'postgresql'
+      assert_raises(NotImplementedError) { User.select { log2(:age) } }
+    else
+      assert_sql(/SELECT LOG2\("users"."age"\)/, User.select { log2(:age) }.to_sql)
+    end
+  end
+
+  # MySQL spells trunc TRUNCATE, and insists on the second argument the
+  # others default to zero.
+  def test_trunc
+    expected = ADAPTER == 'mysql2' ? 'TRUNCATE' : 'TRUNC'
+    assert_sql(/SELECT #{expected}\("users"."age", 0\)/,
+      User.select { trunc(:age, 0) }.to_sql)
+  end
+
+  # EXTRACT(field FROM expr): the field is a keyword rather than a value.
+  # SQLite spells all of this as strftime formats, which no renaming
+  # carries.
+  def test_extract
+    if ADAPTER == 'sqlite3'
+      e = assert_raises(NotImplementedError) { User.select { extract(:year, :name) } }
+      assert_match(/extract/, e.message)
+    else
+      assert_sql(/SELECT EXTRACT\(YEAR FROM "users"."name"\)/,
+        User.select { extract(:year, :name) }.to_sql)
+      assert_sql(/WHERE EXTRACT\(YEAR FROM "users"."name"\) = 2026/,
+        User.where { extract(:year, :name) == 2026 }.to_sql)
+    end
+  end
+
+  # A bad field is an ArgumentError on every adapter, before SQLite gets to
+  # say it has no extract at all.
+  def test_extract_rejects_an_injected_field
+    assert_raises(ArgumentError) { User.select { extract(INJECTION.to_sym, :name) } }
+  end
+
+  def test_extract_runs
+    skip "#{ADAPTER} has no extract" if ADAPTER == 'sqlite3'
+    User.delete_all
+    User.create!(name: 'alice')
+    assert_equal(2026,
+      User.select { extract(:year, cast('2026-01-05', :date)).as(:v) }.sole.v.to_i)
+  end
+
+  def test_cast
+    assert_sql(/SELECT CAST\("users"."age" AS text\)/,
+      User.select { cast(:age, :text) }.to_sql)
+  end
+
+  def test_cast_runs
+    User.delete_all
+    User.create!(name: 'alice')
+    assert_equal(12.5,
+      User.select { cast('12.5', 'decimal(10,2)').as(:v) }.sole.v.to_f)
+  end
+
+  # The type is written into the SQL as given, so it has to look like one:
+  # a plain name, at most parenthesized with lengths.  The adapters' own
+  # spellings with a space in them pass too.
+  def test_cast_type_names
+    assert_sql(/AS double precision\)/,
+      User.select { cast(:age, 'double precision') }.to_sql)
+    assert_sql(/AS decimal\(10,2\)\)/,
+      User.select { cast(:age, 'decimal(10,2)') }.to_sql)
+    assert_raises(ArgumentError) { User.select { cast(:age, INJECTION.to_sym) } }
+    assert_raises(ArgumentError) do
+      User.select { cast(:age, 'integer); DROP TABLE users --') }
+    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)
@@ -572,6 +1125,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)