activerecord-refined 0.9.0 → 0.10.0

data/lib/active_record/refined/ast.rb

@@ -6,37 +6,28 @@ require "json"
 module ActiveRecord
   module Refined
     module AST
+      # @private
       NAME = /[[:alpha:]_][[:alnum:]_$]*/
+      # @private
       ALIAS_NAME = /\A#{NAME}\z/
+      # @private
       FUNCTION_NAME = /\A#{NAME}(\.#{NAME})?\z/
+      # A collation name where the family writes it bare, as all but PostgreSQL
+      # do.  A plain identifier: a hyphen unquoted would read as the collation
+      # minus a number, `x COLLATE nocase-1` as `(x COLLATE nocase) - 1`, valid
+      # and wrong.  PostgreSQL quotes the name and widens this; see its dialect.
+      # @private
+      COLLATION_NAME = /\A#{NAME}\z/
       # A SQL type as cast writes it: words, at most parenthesized with
       # lengths -- double precision, decimal(10,2).
+      # @private
       TYPE_NAME = /\A[[:alpha:]_][[:alnum:]_ ]*(\(\d+(, ?\d+)?\))?\z/
       # The characters PostgreSQL allows an operator to be made of, the
       # widest operator alphabet of the three; op admits nothing else, so a
       # letter, a space or a quote never reaches the SQL as an operator.
+      # @private
       OPERATOR = %r{\A[+\-*/<>=~!@\#%^&|`?]+\z}
 
-      # Which family of spellings an adapter belongs to.  MariaDB answers to
-      # the mysql2 adapter and is counted with MySQL, though the two part
-      # company over JSON.  An adapter nobody has classified keeps the
-      # standard spellings and is left to say for itself what it cannot do.
-      #
-      # pglite is PostgreSQL itself compiled to WebAssembly, reached through
-      # wasmify-rails' adapter; the server it answers for is the same one.
-      ADAPTER_FAMILIES = {
-        "sqlite3" => :sqlite,
-        "postgresql" => :postgresql,
-        "postgis" => :postgresql,
-        "pglite" => :postgresql,
-        "mysql2" => :mysql,
-        "trilogy" => :mysql,
-      }.freeze
-
-      def self.adapter_family(model)
-        ADAPTER_FAMILIES[model.connection_db_config.adapter] || :unknown
-      end
-
       def self.check_name(name, pattern, what)
         return name if pattern.match?(name.to_s)
         raise ArgumentError, "#{name.inspect} is not a plain #{what}"
@@ -48,19 +39,28 @@ module ActiveRecord
       # functions; the MySQL family, which has no json(), reads it with
       # JSON_EXTRACT.
       def self.json_argument(value, model)
-        json = Arel::Nodes.build_quoted(JSON.generate(value))
-        if adapter_family(model) == :sqlite
-          Arel::Nodes::NamedFunction.new("json", [json])
-        else
-          Arel::Nodes::NamedFunction.new(
-            "JSON_EXTRACT", [json, Arel::Nodes.build_quoted("$")])
-        end
+        Dialect.for(model).json_argument(value, model)
       end
 
+      # The conditions a column or an expression can be put in.  Every one
+      # gives back a condition that combines with `&`, `|` and `!`, and the
+      # comparisons quote a Ruby value on the right the way Active Record
+      # does, or take a column, an expression or a subquery there.
+      #
+      # @example
+      #   Author.where { :age.between?(20, 40) & :name.like?("A%") }
+      #   Author.where { :id.in?(Post.select(:author_id)) }
+      #
       # Predicate builders shared by symbols, qualified columns and
       # expressions. Imported into the Symbol refinement with
       # Refinement#import_methods, so every method must be defined with def.
       module Predications
+        # `=`.  A value, a column, an expression or a scalar subquery on the right; `nil` is refused, since `= NULL` is never true -- {#null?} is the spelling.
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :name == "alice" }
+        #   Author.where { :age == Author.select { max(:age) } }
+        #
         # == and != mean SQL = and <>, and = NULL is never true there, so nil
         # is rejected rather than silently rewritten to IS NULL.  null? builds
         # its node directly and stays clear of this check.
@@ -71,6 +71,8 @@ module ActiveRecord
           Comparison.new(self, :==, other)
         end
 
+        # `!=`; `nil` is refused, as with `==`.
+        # @return [AST::Predicate]
         def !=(other)
           if other.nil?
             raise ArgumentError, "!= does not take nil; use !null? instead"
@@ -78,30 +80,50 @@ module ActiveRecord
           Comparison.new(self, :!=, other)
         end
 
+        # `>`.
+        # @return [AST::Predicate]
         def >(other)
           Comparison.new(self, :>, other)
         end
 
+        # `>=`.
+        # @return [AST::Predicate]
         def >=(other)
           Comparison.new(self, :>=, other)
         end
 
+        # `<`.
+        # @return [AST::Predicate]
         def <(other)
           Comparison.new(self, :<, other)
         end
 
+        # `<=`.
+        # @return [AST::Predicate]
         def <=(other)
           Comparison.new(self, :<=, other)
         end
 
+        # A regular expression match: `~` on PostgreSQL, `REGEXP` on MySQL, and what the adapter has elsewhere.  A Ruby Regexp's source is the pattern.
+        # @param pattern [Regexp, String]
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :name =~ /^A/ }
         def =~(pattern)
           Match.new(self, pattern)
         end
 
+        # The negated regular expression match.
+        # @return [AST::Predicate]
         def !~(pattern)
           Match.new(self, pattern, negated: true)
         end
 
+        # `IS NULL`.
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :country.null? }
+        #
         # `!` negates any predicate, so these are here for the four that SQL
         # spells for itself: IS NOT NULL rather than NOT (... IS NULL), and
         # likewise NOT IN and NOT LIKE.  They mean the same thing either way,
@@ -110,10 +132,17 @@ module ActiveRecord
           Comparison.new(self, :==, nil)
         end
 
+        # `IS NOT NULL`.
+        # @return [AST::Predicate]
         def not_null?
           Comparison.new(self, :!=, nil)
         end
 
+        # `IS TRUE`: true of the rows where the boolean is true, false where it is false or NULL -- where `== true` would be NULL.
+        # @return [AST::Predicate]
+        # @example
+        #   Post.where { :published.true? }
+        #
         # IS TRUE and IS FALSE differ from a comparison against the literal in
         # what they make of NULL: `flag = TRUE` is itself NULL there, and a
         # NULL predicate selects nothing, while these two answer false.  So the
@@ -123,36 +152,62 @@ module ActiveRecord
           TruthValue.new(self, true)
         end
 
+        # `IS NOT TRUE`: keeps the NULL rows that `!(:flag == true)` drops.
+        # @return [AST::Predicate]
         def not_true?
           TruthValue.new(self, true, negated: true)
         end
 
+        # `IS FALSE`.
+        # @return [AST::Predicate]
         def false?
           TruthValue.new(self, false)
         end
 
+        # `IS NOT FALSE`.
+        # @return [AST::Predicate]
         def not_false?
           TruthValue.new(self, false, negated: true)
         end
 
+        # `IN (...)`: an array of values, a range, or a relation as a subquery.
+        # @param values [Array, Range, ActiveRecord::Relation]
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :country.in?(%w[JP US]) }
+        #   Author.where { :id.in?(Post.select(:author_id)) }
         def in?(values)
           In.new(self, values)
         end
 
+        # `NOT IN (...)`.
+        # @return [AST::Predicate]
         def not_in?(values)
           In.new(self, values, negated: true)
         end
 
+        # `BETWEEN min AND max`, with either end a value, a column or an expression.
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :age.between?(20, 40) }
+        #
         # Not min..max: an endpoint may be an expression, which Range would
         # refuse to hold, since expressions do not compare among themselves.
         def between?(min, max)
           In.new(self, In::QuotedRange.new(min, max, false))
         end
 
+        # `NOT BETWEEN min AND max`.
+        # @return [AST::Predicate]
         def not_between?(min, max)
           In.new(self, In::QuotedRange.new(min, max, false), negated: true)
         end
 
+        # `CASE column WHEN value THEN ...`: a CASE with this as the operand, each `when` a value it is compared against, followed by `then` and finally `else`.
+        # @return [AST::Case::When]
+        # @example
+        #   Author.select { :country.when("JP").then("Japan").else("elsewhere").as(:where) }
+        #
         # CASE with this as the operand, compared against each `when`:
         # `:age.when(10).then(1).else(0)`.  The other shape, where each `when`
         # carries its own condition, starts at `case_when`.
@@ -160,22 +215,38 @@ module ActiveRecord
           Case.new(self).when(value, &block)
         end
 
+        # `LIKE pattern`, the pattern as written: `%` and `_` are its wildcards.
+        # @param pattern [String]
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :name.like?("A%") }
         def like?(pattern)
           Like.new(self, pattern)
         end
 
+        # `NOT LIKE pattern`.
+        # @return [AST::Predicate]
         def not_like?(pattern)
           Like.new(self, pattern, negated: true)
         end
 
+        # A case-insensitive `LIKE`: `ILIKE` on PostgreSQL, and `LIKE` over both sides lower-cased elsewhere.
+        # @return [AST::Predicate]
         def ilike?(pattern)
           Like.new(self, pattern, nil, case_sensitive: false)
         end
 
+        # The negated case-insensitive `LIKE`.
+        # @return [AST::Predicate]
         def not_ilike?(pattern)
           Like.new(self, pattern, nil, case_sensitive: false, negated: true)
         end
 
+        # Case-insensitive equality: `LOWER(column) = LOWER(value)`.
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :name.casecmp?("Alice") }
+        #
         # Case-insensitive equality, folded on both sides rather than left to
         # the collation, so it means the same thing on every adapter.
         def casecmp?(value)
@@ -186,16 +257,27 @@ module ActiveRecord
                          Function.new("LOWER", [value]))
         end
 
+        # `IS DISTINCT FROM`: `!=` that treats NULL as a value.  `IS NOT` on SQLite, `NOT <=>` on MySQL.
+        # @return [AST::Predicate]
+        #
         # Null-safe comparison: unlike = and <>, these treat NULL as a value,
         # so not_distinct_from? is the one equality that may take nil.
         def distinct_from?(value)
           DistinctFrom.new(self, value, negated: true)
         end
 
+        # `IS NOT DISTINCT FROM`: `=` that treats NULL as a value, so this is the one equality that takes `nil`.
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :country.not_distinct_from?(nil) }
         def not_distinct_from?(value)
           DistinctFrom.new(self, value)
         end
 
+        # `LIKE 'prefix%'`, the prefix escaped so that a `%` or `_` in it is itself; several prefixes are `OR`ed.
+        # @return [AST::Predicate]
+        # @example
+        #   Author.where { :name.start_with?("A", "B") }
         def start_with?(*prefixes)
           if prefixes.empty?
             raise ArgumentError, "start_with? needs at least one prefix"
@@ -203,6 +285,8 @@ module ActiveRecord
           Like.any(self, prefixes.map { |prefix| "#{Like.escape(prefix)}%" })
         end
 
+        # `LIKE '%suffix'`, escaped as {#start_with?} escapes.
+        # @return [AST::Predicate]
         def end_with?(*suffixes)
           if suffixes.empty?
             raise ArgumentError, "end_with? needs at least one suffix"
@@ -210,10 +294,19 @@ module ActiveRecord
           Like.any(self, suffixes.map { |suffix| "%#{Like.escape(suffix)}" })
         end
 
+        # `LIKE '%substring%'`, escaped as {#start_with?} escapes.
+        # @return [AST::Predicate]
+        # @example
+        #   Post.where { :title.include?("ruby") }
         def include?(substring)
           Like.new(self, "%#{Like.escape(substring)}%", Like::ESCAPE)
         end
 
+        # Whether a PostgreSQL array column holds the element: `@> ARRAY[element]`.
+        # @return [AST::Predicate]
+        # @example
+        #   Post.where { :tags.member?("ruby") }
+        #
         # The array comparisons carry the meaning of their Ruby namesakes.
         # member? is Enumerable's element test, so an Array argument is
         # rejected rather than quietly meaning something Array#member? does
@@ -226,18 +319,32 @@ module ActiveRecord
           ArrayPredicate.new(self, :"@>", [element])
         end
 
+        # Whether an array column holds every element given: `@>`.
+        # @return [AST::Predicate]
         def superset?(elements)
           ArrayPredicate.new(self, :"@>", ArrayPredicate.elements(elements, "superset?"))
         end
 
+        # Whether every element of an array column is among those given: `<@`.
+        # @return [AST::Predicate]
         def subset?(elements)
           ArrayPredicate.new(self, :"<@", ArrayPredicate.elements(elements, "subset?"))
         end
 
+        # Whether an array column and the elements given share any: `&&`.
+        # @return [AST::Predicate]
+        # @example
+        #   Post.where { :tags.intersect?(%w[ruby sql]) }
         def intersect?(elements)
           ArrayPredicate.new(self, :"&&", ArrayPredicate.elements(elements, "intersect?"))
         end
 
+        # The JSON at a path into a JSON column, still JSON -- to be dug further, compared with a Ruby value, or asked {#key?} and the rest.  A string or a symbol steps into an object, an integer into an array.  `#>` on PostgreSQL, `JSON_EXTRACT` on MySQL, `->` on SQLite.
+        # @return [AST::JsonPath]
+        # @example
+        #   Doc.select { :meta.dig(:author).as(:author) }
+        #   Doc.where { :meta.dig(:author).key?(:name) }
+        #
         # Reading inside a JSON document, by the name of what Hash does.  A
         # string or symbol steps into an object, an integer into an array, and
         # what comes back is still JSON, the way Hash#dig hands back the
@@ -248,10 +355,19 @@ module ActiveRecord
           JsonPath.new(self, path)
         end
 
+        # The value at a path as text, which is what a comparison against a string wants where the JSON type would not do: `#>>` on PostgreSQL, `JSON_UNQUOTE(JSON_EXTRACT(...))` on MySQL, `->>` on SQLite.
+        # @return [AST::JsonPath]
+        # @example
+        #   Doc.where { :meta.dig_text(:author, :name) == "alice" }
         def dig_text(*path)
           JsonPath.new(self, path, json_value: false)
         end
 
+        # The document without the keys given, as Hash#except gives it; an expression, for `update_all` to write back.
+        # @return [AST::JsonExcept]
+        # @example
+        #   Doc.update_all { { meta: :meta.except(:draft) } }
+        #
         # Keys taken out of a JSON document, by the name of what Hash does,
         # and taking keys as Hash#except takes them.  Like bury it gives back
         # the document changed rather than writing it anywhere.
@@ -259,6 +375,11 @@ module ActiveRecord
           JsonExcept.new(self, keys)
         end
 
+        # The document with a value set at a path, as {#dig} reads one; an expression, for `update_all` to write back.
+        # @return [AST::JsonSet]
+        # @example
+        #   Doc.update_all { { meta: :meta.bury(:author, :name, "alice") } }
+        #
         # What dig reads, bury sets: the last argument is the value and the
         # rest are the path to it.  The document comes back changed rather
         # than being written anywhere, which update_all is for.
@@ -266,12 +387,22 @@ module ActiveRecord
           JsonSet.new(self, path, value)
         end
 
+        # Whether the document contains the Ruby document given, which SQL calls containment: `@>` on PostgreSQL, `JSON_CONTAINS` on MySQL.  SQLite and MariaDB have none.
+        # @return [AST::Predicate]
+        # @example
+        #   Doc.where { :meta.contains?(author: { name: "alice" }) }
+        #
         # Whether the document holds what is given, which SQL calls
         # containment.  SQLite has no equivalent.
         def contains?(value)
           JsonContains.new(self, value)
         end
 
+        # Whether the object has the key, as Hash#key? asks.
+        # @return [AST::Predicate]
+        # @example
+        #   Doc.where { :meta.key?(:author) }
+        #
         # Whether the key is there at all, as Hash#key? asks.  Hash has
         # has_key? too; one name is enough, and this is the one Ruby's own
         # style prefers.
@@ -279,32 +410,55 @@ module ActiveRecord
           JsonHasKey.new(self, key)
         end
 
+        # The keys of the object as a JSON array, as Hash#keys gives them.  Oracle has none.
+        # @return [AST::JsonKeys]
+        #
         # The keys of the document, as Hash#keys gives them: a JSON array.
         def keys
           JsonKeys.new(self)
         end
       end
 
+      # The arithmetic and the bitwise operators on a column or an
+      # expression.  Ruby puts all of them above the comparisons, so
+      # `:price * :quantity > 100` groups the way it reads, and a number on
+      # the left -- `20 - :quantity` -- builds the same expression.
+      #
+      # @example
+      #   LineItem.where { :price * :quantity > 1000 }
+      #   LineItem.select { (:flags & 4).as(:featured) }
+      #
       # Arithmetic builders shared by symbols, qualified columns and
       # expressions.  Imported into the Symbol refinement like Predications,
       # so every method must be defined with def.
       module Arithmetics
+        # `+`; with an Active Support duration on the right, a date moved: `:due_on + 3.days`.
+        # @return [AST::Arithmetic]
         def +(other)
           Arithmetic.new(self, :+, other)
         end
 
+        # `-`; with a duration on the right, a date moved back.
+        # @return [AST::Arithmetic]
         def -(other)
           Arithmetic.new(self, :-, other)
         end
 
+        # `*`.
+        # @return [AST::Arithmetic]
         def *(other)
           Arithmetic.new(self, :*, other)
         end
 
+        # `/`.
+        # @return [AST::Arithmetic]
         def /(other)
           Arithmetic.new(self, :/, other)
         end
 
+        # Bitwise AND.  `&` between two conditions is AND, which leaves this free to mean the SQL operator.
+        # @return [AST::Bitwise]
+        #
         # SQL's bitwise operators.  & and | are AND and OR between conditions
         # and are defined there, which is what leaves them free to mean here
         # what SQL means by them.  Ruby's precedence puts all six above the
@@ -313,22 +467,32 @@ module ActiveRecord
           Bitwise.new(self, :&, other)
         end
 
+        # Bitwise OR.
+        # @return [AST::Bitwise]
         def |(other)
           Bitwise.new(self, :|, other)
         end
 
+        # Bitwise XOR: `#` on PostgreSQL, `^` on MySQL, and the two operations it is made of on SQLite.
+        # @return [AST::Bitwise]
         def ^(other)
           Bitwise.new(self, :^, other)
         end
 
+        # A shift left.
+        # @return [AST::Bitwise]
         def <<(other)
           Bitwise.new(self, :<<, other)
         end
 
+        # A shift right.
+        # @return [AST::Bitwise]
         def >>(other)
           Bitwise.new(self, :>>, other)
         end
 
+        # Bitwise NOT.
+        # @return [AST::BitwiseNot]
         def ~
           BitwiseNot.new(self)
         end
@@ -339,6 +503,7 @@ module ActiveRecord
       # a column or an expression on the right means a query; anything else
       # goes back to the number through super, so 1 + 2 is 3 inside a block
       # too.
+      # @private
       module NumericArithmetics
         def +(other)
           return super unless other.is_a?(::Symbol) || other.is_a?(Node)
@@ -396,18 +561,31 @@ module ActiveRecord
           raise ScriptError, "subclass must override this method"
         end
 
+        # The expression under an alias, as {BlockSyntax#as} gives a column
+        # one.
+        # @return [AST::As]
         def as(alias_name, quote: true)
           As.new(self, alias_name, quote: quote)
         end
 
+        # An ascending ordering by the expression.
+        # @return [AST::Ordering]
         def asc
           Ordering.new(self, :asc)
         end
 
+        # A descending ordering by the expression.
+        # @return [AST::Ordering]
         def desc
           Ordering.new(self, :desc)
         end
 
+        # The expression under a collation, as {BlockSyntax#collate}.
+        # @return [AST::Collate]
+        def collate(name)
+          Collate.new(self, name)
+        end
+
         private
           # Resolves an operand denoting a column or an expression.  A number
           # rides along for Arel to write out, which it can do for Integer and
@@ -561,16 +739,23 @@ module ActiveRecord
           @default = default
         end
 
+        # The next `WHEN`: a value to compare the operand against, or a condition as a value or a block.
+        # @return [AST::Case::When]
         def when(value = nil, &block)
           Pending.new(self, Case.argument(:when, value, block))
         end
 
+        # `THEN`, which belongs after a `when`; here it says so.
+        # @raise [ArgumentError]
+        #
         # Kernel#then is on every object, so `then` in the wrong place would be
         # answered by it -- with no block, silently, with an Enumerator.
         def then(*)
           raise ArgumentError, "then follows a when, and there is none to follow here"
         end
 
+        # `ELSE value`, as a value or a block, closing the CASE.  Without one the CASE gives NULL where no `when` matched.
+        # @return [AST::Case]
         def else(value = nil, &block)
           Case.new(operand, whens, Case.argument(:else, value, block))
         end
@@ -609,6 +794,8 @@ module ActiveRecord
             @condition = condition
           end
 
+          # `THEN value`, as a value or a block, for the `when` before it.
+          # @return [AST::Case]
           def then(value = nil, &block)
             Case.new(@kase.operand,
                      @kase.whens + [[@condition, Case.argument(:then, value, block)]],
@@ -774,27 +961,8 @@ module ActiveRecord
         end
 
         def to_arel(_table, model)
-          json = Arel::Nodes.build_quoted(JSON.generate(value))
-          case AST.adapter_family(model)
-          when :postgresql then json
-          when :mysql then mysql_literal(json, model)
-          else refuse(model.connection_db_config.adapter)
-          end
+          Dialect.for(model).json_literal(Arel::Nodes.build_quoted(JSON.generate(value)), model)
         end
-
-        private
-          # MariaDB answers to the same adapter and has no JSON type at all.
-          def mysql_literal(json, model)
-            refuse("MariaDB") if model.with_connection { |c| c.mariadb? }
-            Arel::Nodes::NamedFunction.new(
-              "CAST", [Arel::Nodes::As.new(json, Arel::Nodes::SqlLiteral.new("JSON"))])
-          end
-
-          def refuse(database)
-            raise NotImplementedError,
-              "a JSON comparison has no equivalent on #{database}; " \
-              "dig_text gives the value"
-          end
       end
 
       # The JSON operations read a document, and what dig gives is one:
@@ -851,24 +1019,9 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          document = to_arel_operand(operand, table, model)
-          case AST.adapter_family(model)
-          when :postgresql
-            Arel::Nodes::InfixOperation.new(
-              json_value? ? :"#>" : :"#>>", document, Arel::Nodes.build_quoted(steps_array))
-          when :mysql
-            extracted = Arel::Nodes::NamedFunction.new(
-              "JSON_EXTRACT", [document, Arel::Nodes.build_quoted(dollar_path)])
-            json_value? ? extracted : Arel::Nodes::NamedFunction.new("JSON_UNQUOTE", [extracted])
-          else
-            extracted = Arel::Nodes::InfixOperation.new(
-              json_value? ? :"->" : :"->>", document, Arel::Nodes.build_quoted(dollar_path))
-            # SQLite's ->> gives back the value with its type, where the other
-            # two give text.  Cast so that `dig_text(:n) == '5'` means the
-            # same thing everywhere, and a number wants a cast everywhere too.
-            json_value? ? extracted : Arel::Nodes::NamedFunction.new(
-              "CAST", [Arel::Nodes::As.new(extracted, Arel::Nodes::SqlLiteral.new("text"))])
-          end
+          Dialect.for(model).json_path(
+            to_arel_operand(operand, table, model),
+            dollar_path, steps_array, json_value?, model)
         end
 
         private
@@ -899,40 +1052,13 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          document = to_arel_operand(operand, table, model)
-          if AST.adapter_family(model) == :postgresql
-            Arel::Nodes::NamedFunction.new(
-              "jsonb_set",
-              [document, Arel::Nodes.build_quoted(steps_array), postgresql_value(table, model)])
-          else
-            Arel::Nodes::NamedFunction.new(
-              "JSON_SET",
-              [document, Arel::Nodes.build_quoted(dollar_path), other_value(table, model)])
-          end
+          Dialect.for(model).json_set(
+            to_arel_operand(operand, table, model),
+            steps_array, dollar_path, value,
+            (to_arel_operand(value, table, model) if expression?), model)
         end
 
         private
-          # jsonb_set takes jsonb, so an expression is turned into it and a Ruby
-          # value goes in as the JSON that says it -- '"x"' rather than 'x',
-          # which is not a document at all.
-          def postgresql_value(table, model)
-            return Arel::Nodes::NamedFunction.new(
-              "to_jsonb", [to_arel_operand(value, table, model)]) if expression?
-            Arel::Nodes.build_quoted(JSON.generate(value))
-          end
-
-          # The others take the value as it is, except a whole document or a
-          # boolean, which go in as JSON through json_argument.
-          def other_value(table, model)
-            return to_arel_operand(value, table, model) if expression?
-            unless value.is_a?(::Hash) || value.is_a?(::Array) ||
-                   value == true || value == false
-              return Arel::Nodes.build_quoted(value)
-            end
-
-            AST.json_argument(value, model)
-          end
-
           def expression?
             value.is_a?(Node) || value.is_a?(::Symbol)
           end
@@ -961,31 +1087,13 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          document = to_arel_operand(operand, table, model)
-          if AST.adapter_family(model) == :postgresql
-            # Grouped because - binds tighter than #>: dug out of a document,
-            # the subtraction would otherwise take the path literal first.
-            return Arel::Nodes::InfixOperation.new(
-              :-, Arel::Nodes::Grouping.new(document), key_array)
-          end
-
-          Arel::Nodes::NamedFunction.new(
-            "JSON_REMOVE",
-            [document, *keys.map { |key| Arel::Nodes.build_quoted("$#{dollar_step(key)}") }])
+          Dialect.for(model).json_remove(
+            to_arel_operand(operand, table, model),
+            keys.map { |key| "$#{dollar_step(key)}" },
+            steps_array(keys), model)
         end
 
         private
-          # jsonb has three subtractions -- a key, an array of keys, an element
-          # by index -- and an array literal written without a type is read as
-          # the first of them: `meta - '{draft}'` takes out the key spelled
-          # {draft}, which is nothing, and says nothing about it.
-          def key_array
-            Arel::Nodes::NamedFunction.new(
-              "CAST",
-              [Arel::Nodes::As.new(Arel::Nodes.build_quoted(steps_array(keys)),
-                                   Arel::Nodes::SqlLiteral.new("text[]"))])
-          end
-
           # Keys, as Hash#except takes them: an index into an array is not what
           # the name says anywhere, and is bury's business through a path.
           def check_keys(keys)
@@ -1013,17 +1121,9 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          document = to_arel_operand(operand, table, model)
-          json = Arel::Nodes.build_quoted(JSON.generate(value))
-          case AST.adapter_family(model)
-          when :postgresql then Arel::Nodes::Contains.new(document, json)
-          when :mysql
-            Arel::Nodes::NamedFunction.new("JSON_CONTAINS", [document, json])
-          else
-            # Later than the others, since the adapter is only known here.
-            raise NotImplementedError,
-              "contains? has no equivalent on #{model.connection_db_config.adapter}"
-          end
+          Dialect.for(model).json_contains(
+            to_arel_operand(operand, table, model),
+            Arel::Nodes.build_quoted(JSON.generate(value)), model)
         end
       end
 
@@ -1041,18 +1141,10 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          document = to_arel_operand(operand, table, model)
-          name = Arel::Nodes.build_quoted(key.to_s)
-          path = Arel::Nodes.build_quoted("$.#{key}")
-          case AST.adapter_family(model)
-          when :postgresql
-            Arel::Nodes::InfixOperation.new(:"?", document, name)
-          when :mysql
-            Arel::Nodes::NamedFunction.new(
-              "JSON_CONTAINS_PATH", [document, Arel::Nodes.build_quoted("one"), path])
-          else
-            Arel::Nodes::NamedFunction.new("json_type", [document, path]).not_eq(nil)
-          end
+          Dialect.for(model).json_has_key(
+            to_arel_operand(operand, table, model),
+            Arel::Nodes.build_quoted(key.to_s),
+            Arel::Nodes.build_quoted("$.#{key}"), model)
         end
       end
 
@@ -1075,30 +1167,10 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          document = to_arel_operand(operand, table, model)
-          case AST.adapter_family(model)
-          when :sqlite
-            sql = compile(document, model)
-            Arel.sql("CASE WHEN json_type(#{sql}) = 'object' " \
-                     "THEN (SELECT json_group_array(key) FROM json_each(#{sql})) END")
-          when :postgresql
-            sql = compile(document, model)
-            Arel.sql("CASE WHEN jsonb_typeof(#{sql}) = 'object' " \
-                     "THEN COALESCE((SELECT jsonb_agg(k) FROM jsonb_object_keys(#{sql}) k), " \
-                     "CAST('[]' AS jsonb)) END")
-          else
-            Arel::Nodes::NamedFunction.new("JSON_KEYS", [document])
-          end
+          Dialect.for(model).json_keys(to_arel_operand(operand, table, model), model)
         end
 
         private
-          # The document appears more than once, the way SQLite's XOR names
-          # its operands twice; the connection's own visitor compiles it, so
-          # its quoting is the adapter's.
-          def compile(document, model)
-            model.with_connection { |connection| connection.visitor.compile(document) }
-          end
-
           def json_source
             "keys"
           end
@@ -1113,11 +1185,6 @@ module ActiveRecord
         include JsonComparable
         include ComputedJson
 
-        NAMES = {
-          array: { postgresql: "jsonb_build_array" },
-          object: { postgresql: "jsonb_build_object" },
-        }.freeze
-
         attr_reader :kind, :values
 
         def initialize(kind, values)
@@ -1126,39 +1193,23 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          Arel::Nodes::NamedFunction.new(
-            NAMES.fetch(kind).fetch(AST.adapter_family(model)) { "JSON_#{kind.to_s.upcase}" },
-            arguments(table, model))
+          dialect = Dialect.for(model)
+          if kind == :array
+            dialect.json_build(:array, nil,
+              values.map { |value| build_argument(value, dialect, table, model) }, model)
+          else
+            dialect.json_build(:object, values.keys.map(&:to_s),
+              values.values.map { |value| build_argument(value, dialect, table, model) }, model)
+          end
         end
 
         private
-          def arguments(table, model)
-            if kind == :array
-              values.map { |value| build_argument(value, table, model) }
-            else
-              values.flat_map do |key, value|
-                [Arel::Nodes.build_quoted(key.to_s),
-                 build_argument(value, table, model)]
-              end
-            end
-          end
-
-          # An expression is itself and a document or a boolean goes in as
-          # JSON, as bury takes them.  PostgreSQL builds from typed
-          # arguments, so its JSON literal is cast -- left untyped it would
-          # be text, and land as a string.
-          def build_argument(value, table, model)
+          # An expression is itself and a bare scalar is quoted; a document or
+          # a boolean the dialect embeds as JSON, as bury takes it.
+          def build_argument(value, dialect, table, model)
             case value
             when Node, ::Symbol then to_arel_operand(value, table, model)
-            when ::Hash, ::Array, true, false
-              if AST.adapter_family(model) == :postgresql
-                Arel::Nodes::NamedFunction.new(
-                  "CAST", [Arel::Nodes::As.new(
-                    Arel::Nodes.build_quoted(JSON.generate(value)),
-                    Arel::Nodes::SqlLiteral.new("jsonb"))])
-              else
-                AST.json_argument(value, model)
-              end
+            when ::Hash, ::Array, true, false then dialect.json_build_argument(value, model)
             when ::Rational then quote_number(value)
             else Arel::Nodes.build_quoted(value)
             end
@@ -1194,6 +1245,7 @@ module ActiveRecord
       # Each set is a list of its own, so grouping_sets takes lists and rollup
       # and cube take the columns themselves.
       class GroupingSets < Node
+        # @private
         KINDS = {
           grouping_sets: Arel::Nodes::GroupingSet,
           rollup: Arel::Nodes::RollUp,
@@ -1209,7 +1261,7 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          return with_rollup(table, model) if AST.adapter_family(model) == :mysql
+          return with_rollup(table, model) if Dialect.for(model).grouping_by_with_rollup?
 
           KINDS.fetch(kind).new(
             if kind == :grouping_sets
@@ -1256,10 +1308,25 @@ module ActiveRecord
       # Arithmetic on columns and expressions.  Ruby's precedence puts these
       # above the comparison operators, so :price * :quantity > 100 groups the
       # way it reads.
+      #
+      # A Duration on the right moves a date: `:due_on + 3.days`.  No two
+      # families spell the move alike, so the dialect writes it, a part of the
+      # duration at a time.
       class Arithmetic < Node
         include Predications
         include Arithmetics
 
+        # Active Support's parts, as the units the SQL takes.  A week is seven
+        # days: SQLite and Oracle have no week.
+        # @private
+        UNITS = {
+          years: :year, months: :month, weeks: :day, days: :day,
+          hours: :hour, minutes: :minute, seconds: :second,
+        }.freeze
+
+        # @private
+        DATE_UNITS = %i[year month day].freeze
+
         attr_reader :left, :operator, :right
 
         def initialize(left, operator, right)
@@ -1270,11 +1337,53 @@ module ActiveRecord
 
         def to_arel(table, model)
           arel_left = to_arel_operand(left, table, model)
+          return move_date(arel_left, model) if right.is_a?(::ActiveSupport::Duration)
           # The operator dispatches Arel's Math, which a bare number carries
           # none of; quoted, it is a node with the same methods.
           arel_left = Arel::Nodes.build_quoted(arel_left) if arel_left.is_a?(::Numeric)
           arel_left.public_send(operator, to_arel_operand(right, table, model))
         end
+
+        # SQLite has no date type, and its datetime() gives whatever it is
+        # handed a time of day, so a date column moved by a day would come
+        # back a midnight and sort past the same day written bare.  Its
+        # dialect has date() for what is a date to begin with, and this is
+        # what says so: a column the model declares a date, CURRENT_DATE, or
+        # one of those already moved by a date's units.  The other families
+        # keep the type themselves and never ask.
+        def self.date_operand?(operand, model)
+          case operand
+          when ::Symbol then model.type_for_attribute(operand).type == :date
+          when DatetimeValueFunction then operand.name == "CURRENT_DATE"
+          when Arithmetic
+            operand.right.is_a?(::ActiveSupport::Duration) &&
+              date_operand?(operand.left, model) &&
+              operand.right.parts.keys.all? { |part| DATE_UNITS.include?(UNITS[part]) }
+          else false
+          end
+        end
+
+        private
+          # Each amount is written into the SQL as a number, and a fraction
+          # of a unit is not one every family takes, so it has to be a whole
+          # one.
+          def move_date(date, model)
+            unless operator == :+ || operator == :-
+              raise ArgumentError,
+                "a duration is added to a date or subtracted from it, not #{operator}"
+            end
+            dialect = Dialect.for(model)
+            date_only = Arithmetic.date_operand?(left, model)
+            right.parts.reduce(date) do |arel, (part, amount)|
+              unless amount.is_a?(::Integer)
+                raise ArgumentError, "#{amount.inspect} #{part} is not a whole number of them"
+              end
+              unit = UNITS.fetch(part)
+              amount *= 7 if part == :weeks
+              dialect.add_interval(arel, amount, unit, operator == :-,
+                                   date_only && DATE_UNITS.include?(unit))
+            end
+          end
       end
 
       # What the bitwise operators refuse.  Both refusals are there because
@@ -1310,6 +1419,7 @@ module ActiveRecord
         include Arithmetics
         include BitwiseOperands
 
+        # @private
         NODES = {
           :& => Arel::Nodes::BitwiseAnd,
           :| => Arel::Nodes::BitwiseOr,
@@ -1345,14 +1455,7 @@ module ActiveRecord
           # it cannot be the portable one either.  SQLite has no XOR at all;
           # (a | b) - (a & b) is it, at the cost of naming each operand twice.
           def xor(left, right, model)
-            case AST.adapter_family(model)
-            when :postgresql then Arel::Nodes::InfixOperation.new("#", left, right)
-            when :mysql then Arel::Nodes::BitwiseXor.new(left, right)
-            else
-              Arel::Nodes::Subtraction.new(
-                Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseOr.new(left, right)),
-                Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseAnd.new(left, right)))
-            end
+            Dialect.for(model).bitwise_xor(left, right)
           end
       end
 
@@ -1380,6 +1483,12 @@ module ActiveRecord
       # OVER, on the two things that can carry a window: an aggregate, and a
       # function.
       module Windowing
+        # `OVER ()`, an empty window to be filled by {Over#partition},
+        # {Over#order}, {Over#rows} and {Over#range}.
+        # @return [AST::Over]
+        # @example
+        #   Author.select { avg(:age).over.partition(:country).as(:country_average) }
+        #   Post.select { sum(:likes).over.order(:created_at).rows(..0).as(:running) }
         def over
           Over.new(self)
         end
@@ -1401,20 +1510,30 @@ module ActiveRecord
           @frame = frame
         end
 
+        # `PARTITION BY`, the columns or expressions given.
+        # @return [AST::Over]
         def partition(*exprs)
           raise ArgumentError, "partition needs an expression" if exprs.empty?
           Over.new(function, partitions + exprs, orders, frame)
         end
 
+        # `ORDER BY` within the window: columns, or orderings such as `:age.desc`.
+        # @return [AST::Over]
         def order(*exprs)
           raise ArgumentError, "order needs an expression" if exprs.empty?
           Over.new(function, partitions, orders + exprs, frame)
         end
 
+        # `ROWS BETWEEN`, as a range of rows counted from the current one: negative before it, positive after, `0` the row itself, an open end unbounded.  `rows(..0)` is a running total, `rows(-1..1)` the row and its neighbours.
+        # @param bounds [Range]
+        # @return [AST::Over]
         def rows(bounds)
           Over.new(function, partitions, orders, framing(:rows, bounds))
         end
 
+        # `RANGE BETWEEN`, with the bounds as {#rows} takes them.
+        # @param bounds [Range]
+        # @return [AST::Over]
         def range(bounds)
           Over.new(function, partitions, orders, framing(:range, bounds))
         end
@@ -1425,9 +1544,9 @@ module ActiveRecord
           orders.each { |expr| window.order(to_arel_operand(expr, table, model)) }
           frame_arel(window) if frame
 
-          # The JSON aggregates cannot ride a window everywhere; the node
-          # itself says where, once the adapter is known.
-          function.check_window(model) if function.is_a?(JsonAggregate)
+          # Not every aggregate can ride a window everywhere; the node itself
+          # says where, once the adapter is known.
+          function.check_window(model) if function.respond_to?(:check_window)
 
           # A window-only function refuses to build on its own; here is where
           # it is asked for the call itself.
@@ -1481,11 +1600,17 @@ module ActiveRecord
         include Arithmetics
         include Windowing
 
+        # The aggregates DISTINCT changes: over each value once, count counts
+        # fewer and sum and avg reckon less.  min and max give the same
+        # either way, so a DISTINCT there is refused as saying nothing.
+        # @private
+        DISTINCT_FUNCTIONS = %i[count sum average].freeze
+
         attr_reader :operand, :function, :distinct, :condition
 
         def initialize(operand, function, distinct: false, condition: nil)
-          if distinct && function != :count
-            raise ArgumentError, "#{function} does not take distinct"
+          if distinct && !DISTINCT_FUNCTIONS.include?(function)
+            raise ArgumentError, "#{function} does not take distinct; it would give the same"
           end
           if distinct && operand == :*
             raise ArgumentError, "count(:*) does not take distinct; name a column"
@@ -1496,8 +1621,12 @@ module ActiveRecord
           @condition = condition
         end
 
-        # FILTER (WHERE ...): the aggregate is taken over the rows the
-        # condition holds for.  A value or a block, as `when` takes them.
+        # `FILTER (WHERE condition)`: the aggregate taken over the rows the
+        # condition holds for, as a value or a block.  Where there is no
+        # FILTER clause -- MySQL, SQL Server -- the CASE that means the same.
+        # @return [AST::Aggregate]
+        # @example
+        #   Author.select { [count(:*).as(:all), count(:*).filter { :age < 50 }.as(:young)] }
         def filter(condition = nil, &block)
           Aggregate.new(operand, function, distinct: distinct,
                         condition: Case.argument(:filter, condition, block))
@@ -1506,11 +1635,11 @@ module ActiveRecord
         def to_arel(table, model)
           return aggregate(operand, table, model) unless condition
 
-          # MySQL has no FILTER clause.  An aggregate passes over a NULL, so
-          # the case that yields nothing for the rows the condition misses is
-          # the same aggregate over the same rows -- count(*) has no operand to
-          # keep, and counts a 1 instead.
-          if AST.adapter_family(model) == :mysql
+          # A family without a FILTER clause gets the CASE that means the same.
+          # An aggregate passes over a NULL, so the case that yields nothing for
+          # the rows the condition misses is the same aggregate over the same
+          # rows -- count(*) has no operand to keep, and counts a 1 instead.
+          unless Dialect.for(model).filter_supported?
             kept = Case.new.when(condition).then(operand == :* ? 1 : operand)
             return aggregate(kept, table, model)
           end
@@ -1521,11 +1650,10 @@ module ActiveRecord
         private
           def aggregate(over, table, model)
             arel_operand = to_arel_operand(over, table, model)
-            if function == :count
-              arel_operand.count(distinct)
-            else
-              arel_operand.public_send(function)
-            end
+            return arel_operand.count(distinct) if function == :count
+            call = arel_operand.public_send(function)
+            call.distinct = distinct
+            call
           end
       end
 
@@ -1540,14 +1668,6 @@ module ActiveRecord
         include ComputedJson
         include Windowing
 
-        # The standard names, which are also the DSL's own and MySQL's, serve
-        # any adapter the table does not list.
-        NAMES = {
-          arrayagg: { sqlite: "json_group_array", postgresql: "jsonb_agg" },
-          objectagg: { sqlite: "json_group_object",
-                       postgresql: "jsonb_object_agg" },
-        }.freeze
-
         attr_reader :kind, :operands, :condition
 
         def initialize(kind, operands, condition: nil)
@@ -1556,31 +1676,32 @@ module ActiveRecord
           @condition = condition
         end
 
+        # `FILTER (WHERE condition)`, as {Aggregate#filter}; refused on the
+        # MySQL family, where the CASE that stands in would leave a JSON null
+        # for every row it drops.
+        # @return [AST::JsonAggregate]
         def filter(condition = nil, &block)
           JsonAggregate.new(kind, operands,
                             condition: Case.argument(:filter, condition, block))
         end
 
-        # MariaDB takes every other aggregate as a window function, but not
-        # these two; Over asks here before writing one.
+        # Over asks here before writing a window, since a family may take
+        # every other aggregate as one but not these two.
         def check_window(model)
-          return unless AST.adapter_family(model) == :mysql
-          return unless model.with_connection { |connection| connection.mariadb? }
-          raise NotImplementedError,
-            "#{json_source} over a window has no equivalent on MariaDB"
+          Dialect.for(model).check_json_aggregate_window(json_source, model)
         end
 
         def to_arel(table, model)
-          family = AST.adapter_family(model)
+          dialect = Dialect.for(model)
           call = Arel::Nodes::NamedFunction.new(
-            NAMES.fetch(kind).fetch(family) { "JSON_#{kind.to_s.upcase}" },
+            dialect.json_aggregate_name(kind),
             operands.map { |operand| to_arel_argument(operand, table, model) })
           return call unless condition
 
-          # The CASE that stands in for FILTER elsewhere hands the aggregate
-          # a NULL for every row the condition misses, and these two keep a
-          # NULL -- as JSON null -- rather than passing over it.
-          if family == :mysql
+          # The CASE that stands in for FILTER elsewhere hands the aggregate a
+          # NULL for every row the condition misses, and these two keep a NULL
+          # -- as JSON null -- rather than passing over it, so it is refused.
+          unless dialect.json_aggregate_filter_supported?
             raise NotImplementedError,
               "#{json_source}.filter has no equivalent on " \
               "#{model.connection_db_config.adapter}; a CASE would leave a " \
@@ -1595,6 +1716,70 @@ module ActiveRecord
           end
       end
 
+      # The strings of a group joined into one, a separator between:
+      # `string_agg(:title, ", ")`, with `.order` for the order they are
+      # joined in.  Every family has it under a name of its own with the
+      # ORDER BY in a place of its own, and Arel has no node for an ORDER BY
+      # inside a call, so the dialect writes the call.  A NULL is passed
+      # over as by any aggregate, so the CASE that stands in for FILTER
+      # means the same here and is not refused as the JSON aggregates' is.
+      class StringAggregate < Node
+        include Predications
+        include Windowing
+
+        attr_reader :operand, :separator, :orders, :condition
+
+        def initialize(operand, separator, orders: [], condition: nil)
+          unless separator.is_a?(::String)
+            raise ArgumentError, "#{separator.inspect} is not a String separator"
+          end
+          @operand = operand
+          @separator = separator
+          @orders = orders
+          @condition = condition
+        end
+
+        # The order the strings are joined in: columns, or orderings such as
+        # `:title.desc`.
+        # @return [AST::StringAggregate]
+        def order(*exprs)
+          raise ArgumentError, "order needs an expression" if exprs.empty?
+          StringAggregate.new(operand, separator, orders: orders + exprs, condition: condition)
+        end
+
+        # `FILTER (WHERE condition)`, as {Aggregate#filter}.
+        # @return [AST::StringAggregate]
+        def filter(condition = nil, &block)
+          StringAggregate.new(operand, separator, orders: orders,
+                              condition: Case.argument(:filter, condition, block))
+        end
+
+        def check_window(model)
+          Dialect.for(model).check_string_aggregate_window(model)
+        end
+
+        def to_arel(table, model)
+          dialect = Dialect.for(model)
+          kept = condition && !dialect.filter_supported? ?
+            Case.new.when(condition).then(operand) : operand
+          call = dialect.string_agg(
+            to_arel_argument(kept, table, model), separator,
+            orders.map { |expr| to_arel_operand(expr, table, model) },
+            string_operand?(model), model)
+          return call unless condition && dialect.filter_supported?
+          Arel::Nodes::Filter.new(call, condition.to_arel(table, model))
+        end
+
+        private
+          # Whether the operand is a column the model declares a string.
+          # PostgreSQL asks, its STRING_AGG taking text and nothing else; the
+          # others convert for themselves.
+          def string_operand?(model)
+            operand.is_a?(::Symbol) &&
+              %i[string text].include?(model.type_for_attribute(operand).type)
+          end
+      end
+
       # A column alias, quoted by the adapter, so that the name asked for is
       # the name that comes back: unquoted, PostgreSQL folds a capital away
       # and the other two keep it, which is one block meaning two things.
@@ -1628,6 +1813,29 @@ module ActiveRecord
           end
       end
 
+      # A collation named for a comparison or an ordering: `:name.collate(:ci)`.
+      # It stands as an expression -- compared, ordered by, selected -- and
+      # gives back one of its own, so the collation carries through.
+      #
+      # The name follows COLLATE as a bare identifier with no Arel node of its
+      # own.  What names are safe turns on whether the family quotes it -- only
+      # PostgreSQL does -- so the dialect checks the name as it builds the
+      # clause, rather than this node holding one rule for all of them.
+      class Collate < Node
+        include Predications
+
+        attr_reader :operand, :name
+
+        def initialize(operand, name)
+          @name = name.to_s
+          @operand = operand
+        end
+
+        def to_arel(table, model)
+          Dialect.for(model).collate(to_arel_operand(operand, table, model), name, model)
+        end
+      end
+
       class Ordering < Node
         attr_reader :operand, :direction, :nulls
 
@@ -1637,12 +1845,18 @@ module ActiveRecord
           @nulls = nulls
         end
 
+        # `NULLS FIRST`; portable, since Arel emulates it where MySQL has
+        # none.
+        # @return [AST::Ordering]
+        #
         # MySQL has no NULLS FIRST/LAST, but Arel emulates it there with a
         # leading IS NULL ordering, so these are portable.
         def nulls_first
           Ordering.new(operand, direction, :nulls_first)
         end
 
+        # `NULLS LAST`.
+        # @return [AST::Ordering]
         def nulls_last
           Ordering.new(operand, direction, :nulls_last)
         end
@@ -1798,6 +2012,7 @@ module ActiveRecord
       # or an Array compares against a PostgreSQL range or array column, the way
       # Active Record's own force_equality? types do.
       class Comparison < Predicate
+        # @private
         OPERATOR_MAP = {
           :== => :eq, :!= => :not_eq,
           :> => :gt, :>= => :gteq, :< => :lt, :<= => :lteq
@@ -1848,9 +2063,8 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          literal = value ? Arel::Nodes::True.new : Arel::Nodes::False.new
-          Arel::Nodes::InfixOperation.new(negated ? "IS NOT" : "IS",
-            to_arel_operand(operand, table, model), literal)
+          Dialect.for(model).truth_value(
+            to_arel_operand(operand, table, model), value, negated, model)
         end
       end
 
@@ -1939,12 +2153,12 @@ module ActiveRecord
           # they resolve.
           def json_between?(model)
             (values.begin.is_a?(JsonLiteral) || values.end.is_a?(JsonLiteral)) &&
-              AST.adapter_family(model) == :mysql
+              Dialect.for(model).json_list_by_element?
           end
 
           def json_list?(model)
             values.any? { |value| value.is_a?(JsonLiteral) } &&
-              AST.adapter_family(model) == :mysql
+              Dialect.for(model).json_list_by_element?
           end
 
           def json_list(arel_operand, elements)
@@ -2003,6 +2217,7 @@ module ActiveRecord
       end
 
       class Like < Predicate
+        # @private
         ESCAPE = "\\"
 
         # Escapes % and _ so that they match literally. The pattern built from