activerecord-refined 0.8.1 → 0.9.0

data/lib/active_record/refined/ast.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 # JSON.generate, for the document a containment test is given.
-require 'json'
+require "json"
 
 module ActiveRecord
   module Refined
@@ -10,6 +12,10 @@ module ActiveRecord
       # A SQL type as cast writes it: words, at most parenthesized with
       # lengths -- double precision, decimal(10,2).
       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.
+      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
@@ -19,12 +25,12 @@ module ActiveRecord
       # 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,
+        "sqlite3" => :sqlite,
+        "postgresql" => :postgresql,
+        "postgis" => :postgresql,
+        "pglite" => :postgresql,
+        "mysql2" => :mysql,
+        "trilogy" => :mysql,
       }.freeze
 
       def self.adapter_family(model)
@@ -36,6 +42,21 @@ module ActiveRecord
         raise ArgumentError, "#{name.inspect} is not a plain #{what}"
       end
 
+      # A Ruby document or boolean written where JSON is wanted.  Taken as it
+      # is, a document would be the string that spells it and a boolean
+      # SQLite's own 1.  SQLite's json() marks the literal for the JSON
+      # 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
+      end
+
       # 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.
@@ -122,12 +143,14 @@ module ActiveRecord
           In.new(self, values, negated: true)
         end
 
+        # 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, min..max)
+          In.new(self, In::QuotedRange.new(min, max, false))
         end
 
         def not_between?(min, max)
-          In.new(self, min..max, negated: true)
+          In.new(self, In::QuotedRange.new(min, max, false), negated: true)
         end
 
         # CASE with this as the operand, compared against each `when`:
@@ -177,14 +200,14 @@ module ActiveRecord
           if prefixes.empty?
             raise ArgumentError, "start_with? needs at least one prefix"
           end
-          Like.any(self, prefixes.map {|prefix| "#{Like.escape(prefix)}%" })
+          Like.any(self, prefixes.map { |prefix| "#{Like.escape(prefix)}%" })
         end
 
         def end_with?(*suffixes)
           if suffixes.empty?
             raise ArgumentError, "end_with? needs at least one suffix"
           end
-          Like.any(self, suffixes.map {|suffix| "%#{Like.escape(suffix)}" })
+          Like.any(self, suffixes.map { |suffix| "%#{Like.escape(suffix)}" })
         end
 
         def include?(substring)
@@ -222,11 +245,11 @@ module ActiveRecord
         # the JSON questions.  dig_text gives the value as text instead,
         # which is what a comparison wants.
         def dig(*path)
-          JsonPath.new(self, path, as_json: true)
+          JsonPath.new(self, path)
         end
 
         def dig_text(*path)
-          JsonPath.new(self, path)
+          JsonPath.new(self, path, json_value: false)
         end
 
         # Keys taken out of a JSON document, by the name of what Hash does,
@@ -255,6 +278,11 @@ module ActiveRecord
         def key?(key)
           JsonHasKey.new(self, key)
         end
+
+        # The keys of the document, as Hash#keys gives them: a JSON array.
+        def keys
+          JsonKeys.new(self)
+        end
       end
 
       # Arithmetic builders shared by symbols, qualified columns and
@@ -306,6 +334,58 @@ module ActiveRecord
         end
       end
 
+      # Arithmetic with the number on the left, imported into the numeric
+      # refinements: 20 - :quantity builds what :quantity + 20 builds.  Only
+      # 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.
+      module NumericArithmetics
+        def +(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Arithmetic.new(self, :+, other)
+        end
+
+        def -(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Arithmetic.new(self, :-, other)
+        end
+
+        def *(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Arithmetic.new(self, :*, other)
+        end
+
+        def /(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Arithmetic.new(self, :/, other)
+        end
+
+        def &(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Bitwise.new(self, :&, other)
+        end
+
+        def |(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Bitwise.new(self, :|, other)
+        end
+
+        def ^(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Bitwise.new(self, :^, other)
+        end
+
+        def <<(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Bitwise.new(self, :<<, other)
+        end
+
+        def >>(other)
+          return super unless other.is_a?(::Symbol) || other.is_a?(Node)
+          Bitwise.new(self, :>>, other)
+        end
+      end
+
       class Node
         # The model travels with the table because some SQL cannot be written
         # without knowing the adapter, and a node is built before anything
@@ -329,25 +409,60 @@ module ActiveRecord
         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
+          # Float alone: a BigDecimal is quoted, which the adapter spells as
+          # the exact decimal, and a Rational, which no decimal spells exactly,
+          # is refused.
+          def to_arel_operand(operand, table, model)
+            case operand
+            when Node then operand.to_arel(table, model)
+            when :* then Arel.star
+            when Symbol then table[operand]
+            when ::BigDecimal, ::Rational then quote_number(operand)
+            else operand
+            end
+          end
 
-        # Resolves an operand denoting a column or an expression.
-        def to_arel_operand(operand, table, model)
-          case operand
-          when Node then operand.to_arel(table, model)
-          when :* then Arel.star
-          when Symbol then table[operand]
-          else operand
+          # A bare symbol is a column in every position, the value side of a
+          # comparison included.  The name is checked against the model, since
+          # a name it has no column for is almost always an enum value spelled
+          # as a symbol -- which, taken as a column, would quietly compare
+          # against nothing anyone meant.
+          def column_operand(name, table, model)
+            unless model.column_names.include?(name.to_s)
+              raise ArgumentError,
+                "#{name.inspect} is no column of #{model.table_name}; an enum " \
+                "value is written as its string, a column of another table " \
+                "qualified"
+            end
+            table[name]
           end
-        end
 
-        # Resolves a function argument: a column or an expression as above,
-        # anything else a value to be quoted.
-        def to_arel_argument(arg, table, model)
-          case arg
-          when Node, Symbol then to_arel_operand(arg, table, model)
-          else Arel::Nodes.build_quoted(arg)
+          # A number compares as itself, the way a bound ? does: the typed path
+          # would cast 99.5 against an integer column to 99 and quietly move
+          # the boundary.  Everything else keeps the column's own
+          # serialization -- an enum's name, a time's zone, a custom type's
+          # scaling.
+          def quote_number(value)
+            case value
+            when ::Rational
+              raise ArgumentError,
+                "a Rational has no exact SQL spelling; to_d says the decimal meant"
+            when ::Integer, ::Float, ::BigDecimal
+              Arel::Nodes.build_quoted(value)
+            else value
+            end
+          end
+
+          # Resolves a function argument: a column or an expression as above,
+          # anything else a value to be quoted.
+          def to_arel_argument(arg, table, model)
+            case arg
+            when Node, Symbol, ::Rational then to_arel_operand(arg, table, model)
+            else Arel::Nodes.build_quoted(arg)
+            end
           end
-        end
       end
 
       class Predicate < Node
@@ -366,11 +481,11 @@ module ActiveRecord
 
       # A literal standing where an expression would: `select { value(0).as(:depth) }`.
       #
-      # Values reach the SQL quoted wherever they appear as an operand, but the
-      # top of a select list is Active Record's, and a bare string there is SQL
-      # rather than a string.  Saying `value` is how you ask for the other
-      # meaning, and it carries the predications with it, so a literal can be
-      # compared and combined like anything else.
+      # Values reach the SQL quoted wherever they appear as an operand, but a
+      # bare Ruby literal at the top of a select list is refused as saying
+      # nothing.  `value` is the spelling that quotes it there, and it carries
+      # the predications with it, so a literal can be compared and combined
+      # like anything else.
       class Value < Node
         include Predications
         include Arithmetics
@@ -386,6 +501,43 @@ module ActiveRecord
         end
       end
 
+      # SQL as written: `sql("length(name) > ?", 10)`.  The ? and :name
+      # placeholders take quoted values through sanitize_sql_array, which
+      # needs the connection, so the binds wait here until the model is
+      # known.  Without binds the statement passes untouched -- which is
+      # what leaves PostgreSQL's ? operators writable, since only the
+      # positional-bind rewrite reads ? as a placeholder.
+      #
+      # As an operand the statement is parenthesized: its precedence is
+      # whatever was written inside.  The top of a select list gets it bare,
+      # through field_arel, where parentheses would refuse an alias written
+      # into the string.
+      class Sql < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :statement, :binds
+
+        def initialize(statement, binds)
+          unless statement.is_a?(::String)
+            raise ArgumentError,
+              "sql takes the statement as a string, not #{statement.inspect}"
+          end
+          @statement = statement
+          @binds = binds
+        end
+
+        def to_arel(_table, model)
+          Arel::Nodes::Grouping.new(field_arel(model))
+        end
+
+        def field_arel(model)
+          return Arel.sql(statement) if binds.empty?
+
+          Arel.sql(model.sanitize_sql_array([statement, *binds]))
+        end
+      end
+
       # CASE, in both of the shapes SQL has for it.  With an operand, each
       # `when` is something to compare it against; without one, each `when` is
       # a condition of its own.
@@ -485,24 +637,24 @@ module ActiveRecord
         # quoted so that a comma or a brace in a key is part of it.  except
         # writes its keys the same way, which are steps of no one path.
         def steps_array(steps = path)
-          "{#{steps.map {|step| %("#{escape_step(step)}") }.join(',')}}"
+          "{#{steps.map { |step| %("#{escape_step(step)}") }.join(',')}}"
         end
 
         # MySQL and SQLite take a path expression instead, where an integer is
         # a subscript and a name that is not plain has to be quoted.
         def dollar_path
-          path.inject(+'$') {|so_far, step| so_far << dollar_step(step) }
+          path.inject(+"$") { |so_far, step| so_far << dollar_step(step) }
         end
 
         def dollar_step(step)
           return "[#{step}]" if step.is_a?(::Integer)
           name = step.to_s
-          '.' + (name.match?(/\A[[:alpha:]_][[:alnum:]_]*\z/) ?
+          "." + (name.match?(/\A[[:alpha:]_][[:alnum:]_]*\z/) ?
                  name : %("#{escape_step(step)}"))
         end
 
         def escape_step(step)
-          step.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+          step.to_s.gsub("\\", "\\\\").gsub('"', '\\"')
         end
       end
 
@@ -521,11 +673,12 @@ module ActiveRecord
       # `dig_text(:flag) == true` is true, an error, and false.  cast is what
       # says which type was meant, and then all three agree.
       #
-      # dig is refused the other way about: the JSON for a string carries
-      # its quotes, so `dig(:name) == 'alice'` is false on SQLite, an
-      # error on PostgreSQL and true on MySQL.  dig_text is the one that
-      # gives the value.  What bury and except give back is JSON as dig's
-      # is, and is refused the same way.
+      # dig, bury and except give JSON, and a JSON comparison belongs to the
+      # JSON types -- jsonb and MySQL's -- where numbers compare as numbers
+      # and documents structurally, key order and spelling aside.  The Ruby
+      # value goes in as a JSON literal, and the adapters without such a
+      # type refuse it from JsonLiteral when the SQL is written, which is
+      # when the adapter is known.
       #
       # A string against dig_text, and anything the block itself built -- a
       # column, a function, another dug value -- go through untouched.
@@ -537,15 +690,14 @@ module ActiveRecord
       module JsonComparable
         %i[== != < <= > >=].each do |operator|
           define_method(operator) do |other|
-            check_comparable(other)
-            super(other)
+            super(comparison_value(other))
           end
         end
 
-        def in?(values) = super(check_each(values))
-        def not_in?(values) = super(check_each(values))
-        def between?(min, max) = super(*check_each([min, max]))
-        def not_between?(min, max) = super(*check_each([min, max]))
+        def in?(values) = super(comparison_set(values))
+        def not_in?(values) = super(comparison_set(values))
+        def between?(min, max) = super(comparison_value(min), comparison_value(max))
+        def not_between?(min, max) = super(comparison_value(min), comparison_value(max))
 
         %i[+ - * / & | ^ << >>].each do |operator|
           define_method(operator) do |_other|
@@ -558,39 +710,91 @@ module ActiveRecord
         end
 
         private
+          # nil is left to the comparison itself, which says to use null?, and
+          # so is anything the block built rather than wrote as a literal.
+          def comparison_value(other)
+            return other if other.nil? || other.is_a?(Node) || other.is_a?(::Symbol) ||
+                            other.is_a?(Arel::Nodes::Node) ||
+                            other.is_a?(Arel::Attributes::Attribute) ||
+                            other.is_a?(ActiveRecord::Relation)
+            return json_literal(other) if json_value?
+            return other if other.is_a?(::String)
 
-        # nil is left to the comparison itself, which says to use null?, and
-        # so is anything the block built rather than wrote as a literal.
-        def check_comparable(other)
-          return if other.nil? || other.is_a?(Node) || other.is_a?(::Symbol) ||
-                    other.is_a?(Arel::Nodes::Node) ||
-                    other.is_a?(Arel::Attributes::Attribute) ||
-                    other.is_a?(ActiveRecord::Relation)
-          return if other.is_a?(::String) && !as_json
+            raise ArgumentError,
+              "dig_text gives text, and comparing it with #{other.inspect} means " \
+              "something different on every adapter; cast it to the type meant"
+          end
 
-          raise ArgumentError, as_json ?
-            "#{json_source} gives JSON, and comparing it with #{other.inspect} " \
-            "means something different on every adapter; dig_text gives the value" :
-            "dig_text gives text, and comparing it with #{other.inspect} means " \
-            "something different on every adapter; cast it to the type meant"
-        end
+          def json_literal(other)
+            case other
+            when ::String, ::Integer, ::Float, ::BigDecimal, true, false, ::Hash, ::Array
+              JsonLiteral.new(other)
+            when ::Rational
+              raise ArgumentError,
+                "a Rational has no exact SQL spelling; to_d says the decimal meant"
+            else
+              raise ArgumentError,
+                "#{json_source} gives JSON, and #{other.inspect} has no JSON " \
+                "spelling; dig_text gives the value"
+            end
+          end
 
-        def check_each(values)
-          case values
-          when ActiveRecord::Relation then values
-          when ::Range then [values.begin, values.end].each {|v| check_comparable(v) }
-          else values.each {|value| check_comparable(value) }
+          def comparison_set(values)
+            case values
+            when ActiveRecord::Relation then values
+            when ::Range
+              In::QuotedRange.new(comparison_value(values.begin),
+                                  comparison_value(values.end), values.exclude_end?)
+            else values.map { |value| comparison_value(value) }
+            end
           end
-          values
+
+          def arithmetic_refusal(operator)
+            json_value? ?
+              "#{json_source} gives JSON, and #{operator} on it means something " \
+              "different on every adapter; cast dig_text to the type meant" :
+              "dig_text gives text, and #{operator} on it means something " \
+              "different on every adapter; cast it to the type meant"
+          end
+      end
+
+      # A Ruby value on the JSON side of a comparison, which jsonb and
+      # MySQL's JSON type answer alike: numbers compare as numbers and
+      # documents structurally.  SQLite and MariaDB have only the text of
+      # each -- spelling and key order deciding what equality means -- and
+      # refuse here.  PostgreSQL needs no cast, an untyped literal beside a
+      # jsonb operand coercing to jsonb; MySQL is told CAST(... AS JSON),
+      # since a bare string beside JSON would be a JSON string, and every
+      # string outranks every number in its ordering.
+      class JsonLiteral < Node
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
         end
 
-        def arithmetic_refusal(operator)
-          as_json ?
-            "#{json_source} gives JSON, and #{operator} on it means something " \
-            "different on every adapter; cast dig_text to the type meant" :
-            "dig_text gives text, and #{operator} on it means something " \
-            "different on every adapter; cast it to the type meant"
+        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
         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:
@@ -600,9 +804,9 @@ module ActiveRecord
       # again is where they part company: SQLite parses it back and MySQL
       # takes it as written, where PostgreSQL has no such function for text.
       module JsonDocument
-        %i[dig dig_text key? contains? bury except].each do |name|
+        %i[dig dig_text key? keys contains? bury except].each do |name|
           define_method(name) do |*args|
-            unless as_json
+            unless json_value?
               raise ArgumentError,
                 "dig_text gives text, and #{name} reads JSON; dig keeps it"
             end
@@ -611,6 +815,22 @@ module ActiveRecord
         end
       end
 
+      # JSON the query computes rather than reads out of a document: always
+      # a JSON value, with no dig_text counterpart for JsonComparable's
+      # advice to name.  Included after JsonComparable, whose own
+      # arithmetic_refusal it overrides.
+      module ComputedJson
+        def json_value?
+          true
+        end
+
+        private
+          def arithmetic_refusal(operator)
+            "#{json_source} gives JSON, and #{operator} on it means " \
+            "something different on every adapter"
+          end
+      end
+
       class JsonPath < Node
         include Predications
         include Arithmetics
@@ -618,12 +838,16 @@ module ActiveRecord
         include JsonComparable
         include JsonDocument
 
-        attr_reader :operand, :path, :as_json
+        attr_reader :operand, :path
 
-        def initialize(operand, path, as_json: false)
+        def initialize(operand, path, json_value: true)
           @operand = operand
-          @path = check_steps(path, 'dig')
-          @as_json = as_json
+          @path = check_steps(path, "dig")
+          @json_value = json_value
+        end
+
+        def json_value?
+          @json_value
         end
 
         def to_arel(table, model)
@@ -631,27 +855,26 @@ module ActiveRecord
           case AST.adapter_family(model)
           when :postgresql
             Arel::Nodes::InfixOperation.new(
-              as_json ? :"#>" : :"#>>", document, Arel::Nodes.build_quoted(steps_array))
+              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)])
-            as_json ? extracted : Arel::Nodes::NamedFunction.new('JSON_UNQUOTE', [extracted])
+              "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(
-              as_json ? :"->" : :"->>", document, Arel::Nodes.build_quoted(dollar_path))
+              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.
-            as_json ? extracted : Arel::Nodes::NamedFunction.new(
-              'CAST', [Arel::Nodes::As.new(extracted, Arel::Nodes::SqlLiteral.new('text'))])
+            json_value? ? extracted : Arel::Nodes::NamedFunction.new(
+              "CAST", [Arel::Nodes::As.new(extracted, Arel::Nodes::SqlLiteral.new("text"))])
           end
         end
 
         private
-
-        def json_source
-          'dig'
-        end
+          def json_source
+            "dig"
+          end
       end
 
       # Setting a value inside a JSON document, which is what bury does to what
@@ -666,12 +889,12 @@ module ActiveRecord
 
         def initialize(operand, path, value)
           @operand = operand
-          @path = check_steps(path, 'bury')
+          @path = check_steps(path, "bury")
           @value = value
         end
 
         # Always JSON, which is what the comparison guard asks.
-        def as_json
+        def json_value?
           true
         end
 
@@ -679,54 +902,44 @@ module ActiveRecord
           document = to_arel_operand(operand, table, model)
           if AST.adapter_family(model) == :postgresql
             Arel::Nodes::NamedFunction.new(
-              'jsonb_set',
+              "jsonb_set",
               [document, Arel::Nodes.build_quoted(steps_array), postgresql_value(table, model)])
           else
             Arel::Nodes::NamedFunction.new(
-              'JSON_SET',
+              "JSON_SET",
               [document, Arel::Nodes.build_quoted(dollar_path), other_value(table, model)])
           end
         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
 
-        # 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
 
-        # The others take the value as it is, except a whole document or a
-        # boolean, which go in as JSON: taken as they are, a document would
-        # be the string that spells it, and a boolean SQLite's own 1.
-        # SQLite's json() marks the literal for JSON_SET; the MySQL family,
-        # which has no json(), reads it with JSON_EXTRACT.
-        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)
+            AST.json_argument(value, model)
           end
 
-          json = Arel::Nodes.build_quoted(JSON.generate(value))
-          if AST.adapter_family(model) == :sqlite
-            Arel::Nodes::NamedFunction.new('json', [json])
-          else
-            Arel::Nodes::NamedFunction.new(
-              'JSON_EXTRACT', [json, Arel::Nodes.build_quoted('$')])
+          def expression?
+            value.is_a?(Node) || value.is_a?(::Symbol)
           end
-        end
 
-        def expression?
-          value.is_a?(Node) || value.is_a?(::Symbol)
-        end
-
-        def json_source
-          'bury'
-        end
+          def json_source
+            "bury"
+          end
       end
 
       # Keys taken out of a JSON document.  PostgreSQL subtracts them, the
@@ -743,7 +956,7 @@ module ActiveRecord
           @keys = check_keys(keys)
         end
 
-        def as_json
+        def json_value?
           true
         end
 
@@ -757,38 +970,37 @@ module ActiveRecord
           end
 
           Arel::Nodes::NamedFunction.new(
-            'JSON_REMOVE',
-            [document, *keys.map {|key| Arel::Nodes.build_quoted("$#{dollar_step(key)}") }])
+            "JSON_REMOVE",
+            [document, *keys.map { |key| Arel::Nodes.build_quoted("$#{dollar_step(key)}") }])
         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
 
-        # 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)
-          raise ArgumentError, 'except needs a key' if keys.empty?
-          keys.each do |key|
-            next if key.is_a?(::String) || key.is_a?(::Symbol)
-            raise ArgumentError,
-              "except takes keys of the document, not #{key.inspect}"
+          # 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)
+            raise ArgumentError, "except needs a key" if keys.empty?
+            keys.each do |key|
+              next if key.is_a?(::String) || key.is_a?(::Symbol)
+              raise ArgumentError,
+                "except takes keys of the document, not #{key.inspect}"
+            end
+            keys
           end
-          keys
-        end
 
-        def json_source
-          'except'
-        end
+          def json_source
+            "except"
+          end
       end
 
       # JSON containment: whether the document holds what is given.
@@ -806,7 +1018,7 @@ module ActiveRecord
           case AST.adapter_family(model)
           when :postgresql then Arel::Nodes::Contains.new(document, json)
           when :mysql
-            Arel::Nodes::NamedFunction.new('JSON_CONTAINS', [document, json])
+            Arel::Nodes::NamedFunction.new("JSON_CONTAINS", [document, json])
           else
             # Later than the others, since the adapter is only known here.
             raise NotImplementedError,
@@ -815,9 +1027,11 @@ module ActiveRecord
         end
       end
 
-      # Whether a key is in the document.  PostgreSQL has an operator for it,
-      # ?, which is also what a bind parameter looks like to several drivers;
-      # the function it is shorthand for says the same thing and survives.
+      # Whether a key is in the document.  PostgreSQL's spelling is the ?
+      # operator rather than jsonb_exists, the function it is shorthand for,
+      # because a GIN index matches the operator and never the function.  A
+      # ? is a bind placeholder only to sanitize_sql, which none of the SQL
+      # written here passes through.
       class JsonHasKey < Predicate
         attr_reader :operand, :key
 
@@ -832,19 +1046,150 @@ module ActiveRecord
           path = Arel::Nodes.build_quoted("$.#{key}")
           case AST.adapter_family(model)
           when :postgresql
-            Arel::Nodes::NamedFunction.new('jsonb_exists', [document, name])
+            Arel::Nodes::InfixOperation.new(:"?", document, name)
           when :mysql
             Arel::Nodes::NamedFunction.new(
-              'JSON_CONTAINS_PATH', [document, Arel::Nodes.build_quoted('one'), path])
+              "JSON_CONTAINS_PATH", [document, Arel::Nodes.build_quoted("one"), path])
           else
-            Arel::Nodes::NamedFunction.new('json_type', [document, path]).not_eq(nil)
+            Arel::Nodes::NamedFunction.new("json_type", [document, path]).not_eq(nil)
+          end
+        end
+      end
+
+      # The keys of a JSON document, as Hash#keys gives them: a JSON array.
+      # Only the MySQL family has a function for it; the other two reach the
+      # same array through a subquery over their key-listing functions.  The
+      # type guard is what makes all four answer alike: the keys of what is
+      # not an object are NULL rather than SQLite's array indices or
+      # PostgreSQL's error, and the keys of {} are [] rather than
+      # PostgreSQL's NULL, jsonb_agg over no rows.
+      class JsonKeys < Node
+        include Predications
+        include JsonComparable
+        include ComputedJson
+
+        attr_reader :operand
+
+        def initialize(operand)
+          @operand = operand
+        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
+        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
+      end
+
+      # A JSON document built in the row: json_array from the values given,
+      # json_object from a Ruby hash.  SQLite and the MySQL family both say
+      # the standard names; PostgreSQL is asked to build jsonb, whose
+      # documents the other JSON operations here read.
+      class JsonBuild < Node
+        include Predications
+        include JsonComparable
+        include ComputedJson
+
+        NAMES = {
+          array: { postgresql: "jsonb_build_array" },
+          object: { postgresql: "jsonb_build_object" },
+        }.freeze
+
+        attr_reader :kind, :values
+
+        def initialize(kind, values)
+          @kind = kind
+          @values = kind == :object ? check_pairs(values) : values
+        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))
         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)
+            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 ::Rational then quote_number(value)
+            else Arel::Nodes.build_quoted(value)
+            end
+          end
+
+          # The keys come from Ruby as Hash keys rather than alternating with
+          # the values as SQL has them, which is what keeps a bare symbol
+          # free to mean a column on the value side.  Anything but a name is
+          # refused here, before the adapters answer a NULL key three ways.
+          def check_pairs(pairs)
+            unless pairs.is_a?(::Hash)
+              raise ArgumentError,
+                "json_object takes a hash of keys to values, not #{pairs.inspect}"
+            end
+            pairs.each_key do |key|
+              next if key.is_a?(::String) || key.is_a?(::Symbol)
+              raise ArgumentError,
+                "a key of json_object is a string or a symbol, not #{key.inspect}"
+            end
+            pairs
+          end
+
+          def json_source
+            "json_#{kind}"
+          end
       end
 
       # GROUP BY GROUPING SETS / ROLLUP / CUBE: several groupings asked for at
       # once, the totals of each coming back beside the rows.  PostgreSQL has
-      # all three; the block raises for the others before it gets this far.
+      # all three and the MySQL family rollup alone; the block raises for the
+      # rest before it gets this far.
       #
       # Each set is a list of its own, so grouping_sets takes lists and rollup
       # and cube take the columns themselves.
@@ -864,16 +1209,32 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
+          return with_rollup(table, model) if AST.adapter_family(model) == :mysql
+
           KINDS.fetch(kind).new(
             if kind == :grouping_sets
               sets.map do |set|
                 Arel::Nodes::GroupingElement.new(
-                  Array(set).map {|column| to_arel_operand(column, table, model) })
+                  Array(set).map { |column| to_arel_operand(column, table, model) })
               end
             else
-              sets.map {|column| to_arel_operand(column, table, model) }
+              sets.map { |column| to_arel_operand(column, table, model) }
             end)
         end
+
+        private
+          # The MySQL family spells rollup WITH ROLLUP, trailing the whole
+          # group list rather than wrapping a list of its own -- which is also
+          # why a rollup cannot stand beside other group entries there.  The
+          # columns are compiled by the connection's own visitor, so their
+          # quoting is the adapter's.
+          def with_rollup(table, model)
+            columns = sets.map { |column| to_arel_operand(column, table, model) }
+            sql = model.with_connection do |connection|
+              columns.map { |column| connection.visitor.compile(column) }.join(", ")
+            end
+            Arel.sql("#{sql} WITH ROLLUP")
+          end
       end
 
       class Column < Node
@@ -908,8 +1269,11 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          to_arel_operand(left, table, model).
-            public_send(operator, to_arel_operand(right, table, model))
+          arel_left = to_arel_operand(left, table, model)
+          # 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
       end
 
@@ -920,23 +1284,22 @@ module ActiveRecord
       # PostgreSQL has no such operator and would say so.
       module BitwiseOperands
         private
+          def check_operand(operand, operator)
+            return operand unless operand.is_a?(Predicate)
+            raise ArgumentError,
+              "a condition cannot be an operand of #{operator}; " \
+              "& and | between conditions are AND and OR"
+          end
 
-        def check_operand(operand, operator)
-          return operand unless operand.is_a?(Predicate)
-          raise ArgumentError,
-            "a condition cannot be an operand of #{operator}; " \
-            "& and | between conditions are AND and OR"
-        end
-
-        # Only the unqualified column can be checked, since that is the one
-        # the model is known to have.
-        def check_not_boolean(operand, operator, model)
-          return unless operand.is_a?(::Symbol)
-          return unless model.type_for_attribute(operand).type == :boolean
-          raise ArgumentError,
-            "#{operand.inspect} is a boolean column, which #{operator} does " \
-            "not take; #{operand.inspect}.true? is the condition"
-        end
+          # Only the unqualified column can be checked, since that is the one
+          # the model is known to have.
+          def check_not_boolean(operand, operator, model)
+            return unless operand.is_a?(::Symbol)
+            return unless model.type_for_attribute(operand).type == :boolean
+            raise ArgumentError,
+              "#{operand.inspect} is a boolean column, which #{operator} does " \
+              "not take; #{operand.inspect}.true? is the condition"
+          end
       end
 
       # SQL's bitwise operators.  Each parenthesises itself, which is what
@@ -976,22 +1339,21 @@ module ActiveRecord
         end
 
         private
-
-        # Arel has a node for XOR, but it writes ^ on every adapter, and ^ is
-        # exponentiation to PostgreSQL -- a wrong answer rather than an error.
-        # PostgreSQL's own spelling, #, is where a comment starts on MySQL, so
-        # 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)))
+          # Arel has a node for XOR, but it writes ^ on every adapter, and ^ is
+          # exponentiation to PostgreSQL -- a wrong answer rather than an error.
+          # PostgreSQL's own spelling, #, is where a comment starts on MySQL, so
+          # 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
           end
-        end
       end
 
       # ~, which every adapter has.  MySQL answers with the unsigned 64-bit
@@ -1059,10 +1421,14 @@ module ActiveRecord
 
         def to_arel(table, model)
           window = Arel::Nodes::Window.new
-          partitions.each {|expr| window.partition(to_arel_operand(expr, table, model)) }
-          orders.each {|expr| window.order(to_arel_operand(expr, table, model)) }
+          partitions.each { |expr| window.partition(to_arel_operand(expr, table, model)) }
+          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)
+
           # A window-only function refuses to build on its own; here is where
           # it is asked for the call itself.
           arel_function =
@@ -1072,43 +1438,42 @@ module ActiveRecord
         end
 
         private
-
-        # The frame is a range of rows counted from the current one: negative
-        # before it, positive after, 0 the row itself, and an open end for
-        # unbounded.  `rows(..0)` is what a running total wants.
-        def framing(kind, bounds)
-          raise ArgumentError, "a window has one frame" if frame
-          unless bounds.is_a?(::Range)
-            raise ArgumentError, "#{kind} takes a range of rows, as in rows(..0)"
-          end
-          if bounds.exclude_end?
-            raise ArgumentError, "a frame ends on a row rather than before one; use .."
-          end
-          [bounds.begin, bounds.end].each do |bound|
-            next if bound.nil? || bound.is_a?(::Integer)
-            raise ArgumentError,
-              "a frame bound is a number of rows, or nothing for unbounded"
+          # The frame is a range of rows counted from the current one: negative
+          # before it, positive after, 0 the row itself, and an open end for
+          # unbounded.  `rows(..0)` is what a running total wants.
+          def framing(kind, bounds)
+            raise ArgumentError, "a window has one frame" if frame
+            unless bounds.is_a?(::Range)
+              raise ArgumentError, "#{kind} takes a range of rows, as in rows(..0)"
+            end
+            if bounds.exclude_end?
+              raise ArgumentError, "a frame ends on a row rather than before one; use .."
+            end
+            [bounds.begin, bounds.end].each do |bound|
+              next if bound.nil? || bound.is_a?(::Integer)
+              raise ArgumentError,
+                "a frame bound is a number of rows, or nothing for unbounded"
+            end
+            [kind, bounds.begin, bounds.end]
           end
-          [kind, bounds.begin, bounds.end]
-        end
 
-        # Arel wants the keyword itself on the left of the BETWEEN, which is
-        # what window.rows with no argument hands back.
-        def frame_arel(window)
-          kind, from, to = frame
-          window.frame(
-            Arel::Nodes::Between.new(
-              window.public_send(kind),
-              Arel::Nodes::And.new([bound(from, Arel::Nodes::Preceding.new),
-                                    bound(to, Arel::Nodes::Following.new)])))
-        end
+          # Arel wants the keyword itself on the left of the BETWEEN, which is
+          # what window.rows with no argument hands back.
+          def frame_arel(window)
+            kind, from, to = frame
+            window.frame(
+              Arel::Nodes::Between.new(
+                window.public_send(kind),
+                Arel::Nodes::And.new([bound(from, Arel::Nodes::Preceding.new),
+                                      bound(to, Arel::Nodes::Following.new)])))
+          end
 
-        def bound(rows, unbounded)
-          return unbounded if rows.nil?
-          return Arel::Nodes::CurrentRow.new if rows.zero?
-          rows.negative? ? Arel::Nodes::Preceding.new(-rows)
-                         : Arel::Nodes::Following.new(rows)
-        end
+          def bound(rows, unbounded)
+            return unbounded if rows.nil?
+            return Arel::Nodes::CurrentRow.new if rows.zero?
+            rows.negative? ? Arel::Nodes::Preceding.new(-rows)
+                           : Arel::Nodes::Following.new(rows)
+          end
       end
 
       class Aggregate < Node
@@ -1154,15 +1519,80 @@ module ActiveRecord
         end
 
         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
+          end
+      end
 
-        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)
+      # Rows gathered into one JSON document: json_arrayagg collects a value
+      # from each row into an array, json_objectagg a key and a value into an
+      # object.  Every adapter has the pair under a name of its own; what
+      # PostgreSQL gets is the jsonb one, whose documents the other JSON
+      # operations here read.
+      class JsonAggregate < Node
+        include Predications
+        include JsonComparable
+        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)
+          @kind = kind
+          @operands = operands
+          @condition = condition
+        end
+
+        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.
+        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"
+        end
+
+        def to_arel(table, model)
+          family = AST.adapter_family(model)
+          call = Arel::Nodes::NamedFunction.new(
+            NAMES.fetch(kind).fetch(family) { "JSON_#{kind.to_s.upcase}" },
+            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
+            raise NotImplementedError,
+              "#{json_source}.filter has no equivalent on " \
+              "#{model.connection_db_config.adapter}; a CASE would leave a " \
+              "null in the document for every row it drops"
           end
+          call.filter(condition.to_arel(table, model))
         end
+
+        private
+          def json_source
+            "json_#{kind}"
+          end
       end
 
       # A column alias, quoted by the adapter, so that the name asked for is
@@ -1191,12 +1621,11 @@ module ActiveRecord
         end
 
         private
-
-        def alias_sql(model)
-          name = alias_name.to_s
-          return name unless quote
-          model.with_connection {|connection| connection.quote_column_name(name) }
-        end
+          def alias_sql(model)
+            name = alias_name.to_s
+            return name unless quote
+            model.with_connection { |connection| connection.quote_column_name(name) }
+          end
       end
 
       class Ordering < Node
@@ -1237,11 +1666,54 @@ module ActiveRecord
         end
 
         def to_arel(table, model)
-          arel_args = args.map {|arg| to_arel_argument(arg, table, model) }
+          arel_args = args.map { |arg| to_arel_argument(arg, table, model) }
           Arel::Nodes::NamedFunction.new(name, arel_args)
         end
       end
 
+      # Escape hatch for operators without a spelling of their own, the way
+      # fn is for functions.  The operator is emitted as written -- whether
+      # the adapter has it is the caller's assertion, as fn's names are --
+      # and the values ride as quoted literals, so on PostgreSQL an untyped
+      # one takes the type of the operand beside it.
+      class Operation < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :operator, :left, :right
+
+        def initialize(operator, left, right)
+          @operator = AST.check_name(operator, OPERATOR, "operator").to_s
+          @left = check_side(left)
+          @right = check_side(right)
+        end
+
+        def to_arel(table, model)
+          Arel::Nodes::Grouping.new(
+            Arel::Nodes::InfixOperation.new(
+              operator, side(left, table, model), side(right, table, model)))
+        end
+
+        private
+          # An expression operand is parenthesized: an unknown operator's
+          # precedence is unknown too, and PostgreSQL reads its named
+          # operators from the left, so a bare infix on the right would take
+          # the new operator's left side into its own.
+          def side(operand, table, model)
+            arel = to_arel_argument(operand, table, model)
+            operand.is_a?(Node) ? Arel::Nodes::Grouping.new(arel) : arel
+          end
+
+          def check_side(operand)
+            if operand.is_a?(::Hash) || operand.is_a?(::Array) || operand.is_a?(::Set)
+              raise ArgumentError,
+                "#{operand.inspect} has no one SQL spelling; a string says it " \
+                "in the adapter's own, to_json for a document"
+            end
+            operand
+          end
+      end
+
       # ROW_NUMBER and its kind: functions that say nothing without a window.
       # On its own this refuses rather than reaching the database as an error
       # there; over asks it for call_arel instead.
@@ -1344,24 +1816,24 @@ module ActiveRecord
           arel_value =
             case value
             when Node then value.to_arel(table, model)
+            when ::Symbol then column_operand(value, table, model)
             when ActiveRecord::Relation then scalar_subquery(value)
-            else value
+            else quote_number(value)
             end
           arel_column.public_send(OPERATOR_MAP.fetch(operator), arel_value)
         end
 
         private
-
-        # A relation compared against a column has to yield a single value, so
-        # unlike In there is no sensible default select list to fall back on.
-        def scalar_subquery(relation)
-          if relation.select_values.empty?
-            raise ArgumentError,
-              "#{operator} needs a subquery selecting one value; add a select"
+          # A relation compared against a column has to yield a single value, so
+          # unlike In there is no sensible default select list to fall back on.
+          def scalar_subquery(relation)
+            if relation.select_values.empty?
+              raise ArgumentError,
+                "#{operator} needs a subquery selecting one value; add a select"
+            end
+            relation = relation.send(:apply_join_dependency) if relation.eager_loading?
+            relation.arel
           end
-          relation = relation.send(:apply_join_dependency) if relation.eager_loading?
-          relation.arel
-        end
       end
 
       # IS TRUE, IS FALSE and their negations, which every adapter spells the
@@ -1377,7 +1849,7 @@ module ActiveRecord
 
         def to_arel(table, model)
           literal = value ? Arel::Nodes::True.new : Arel::Nodes::False.new
-          Arel::Nodes::InfixOperation.new(negated ? 'IS NOT' : 'IS',
+          Arel::Nodes::InfixOperation.new(negated ? "IS NOT" : "IS",
             to_arel_operand(operand, table, model), literal)
         end
       end
@@ -1388,19 +1860,18 @@ module ActiveRecord
       # selects the model's primary key.
       module SetSubquery
         private
-
-        def set_subquery(relation, spelling)
-          relation = relation.send(:apply_join_dependency) if relation.eager_loading?
-          if relation.select_values.empty?
-            model = relation.model
-            if model.composite_primary_key?
-              raise ArgumentError,
-                "Cannot map composite primary key #{model.primary_key} to #{spelling}"
+          def set_subquery(relation, spelling)
+            relation = relation.send(:apply_join_dependency) if relation.eager_loading?
+            if relation.select_values.empty?
+              model = relation.model
+              if model.composite_primary_key?
+                raise ArgumentError,
+                  "Cannot map composite primary key #{model.primary_key} to #{spelling}"
+              end
+              relation = relation.select(relation.table[model.primary_key])
             end
-            relation = relation.select(relation.table[model.primary_key])
+            relation.arel
           end
-          relation.arel
-        end
       end
 
       # IN for a list of values, BETWEEN for a range, IN (SELECT ...) for a
@@ -1408,6 +1879,12 @@ module ActiveRecord
       class In < Predicate
         include SetSubquery
 
+        # Range holds its endpoints to Comparable, which a quoted node is
+        # not, so this quacks the three methods Arel's between reads.
+        QuotedRange = Struct.new(:begin, :end, :exclude_end) do
+          def exclude_end? = exclude_end
+        end
+
         attr_reader :operand, :values, :negated
 
         def initialize(operand, values, negated: false)
@@ -1418,13 +1895,67 @@ module ActiveRecord
 
         def to_arel(table, model)
           arel_operand = to_arel_operand(operand, table, model)
-          if values.is_a?(Range)
-            arel_operand.public_send(negated ? :not_between : :between, values)
+          case values
+          when Range, QuotedRange
+            lower = quote_value(values.begin, table, model)
+            upper = quote_value(values.end, table, model)
+            if json_between?(model) && lower && upper && !negated
+              return arel_operand.gteq(lower).and(
+                values.exclude_end? ? arel_operand.lt(upper) : arel_operand.lteq(upper))
+            end
+            range = QuotedRange.new(lower, upper, values.exclude_end?)
+            arel_operand.public_send(negated ? :not_between : :between, range)
+          when ActiveRecord::Relation
+            arel_operand.public_send(negated ? :not_in : :in, set_subquery(values, "IN"))
           else
-            arg = values.is_a?(ActiveRecord::Relation) ? set_subquery(values, 'IN') : values
+            arg = values
+            if arg.is_a?(::Array)
+              arg = arg.map { |value| quote_value(value, table, model) }
+              return json_list(arel_operand, arg) if json_list?(model)
+            end
             arel_operand.public_send(negated ? :not_in : :in, arg)
           end
         end
+
+        private
+          # An element that is already an expression resolves, a symbol is a
+          # column here as everywhere, a number is quoted as itself, and the
+          # rest ride for Arel to cast by the column.
+          def quote_value(value, table, model)
+            case value
+            when Node then value.to_arel(table, model)
+            when ::Symbol then column_operand(value, table, model)
+            else quote_number(value)
+            end
+          end
+
+          # MySQL leaves IN and BETWEEN out of its JSON comparisons -- they
+          # fall back to another comparison entirely -- so on it a JSON set is
+          # spelled as the comparisons it means: the closed range as its two
+          # bounds, the list as one equality per element.  That names the dug
+          # value once per element, the price SQLite's XOR pays per operand;
+          # a negated range needs nothing, Arel writing it as two comparisons
+          # everywhere.  MariaDB never gets this far: the endpoints refuse as
+          # they resolve.
+          def json_between?(model)
+            (values.begin.is_a?(JsonLiteral) || values.end.is_a?(JsonLiteral)) &&
+              AST.adapter_family(model) == :mysql
+          end
+
+          def json_list?(model)
+            values.any? { |value| value.is_a?(JsonLiteral) } &&
+              AST.adapter_family(model) == :mysql
+          end
+
+          def json_list(arel_operand, elements)
+            comparisons = elements.map do |element|
+              negated ? arel_operand.not_eq(element) : arel_operand.eq(element)
+            end
+            joined = comparisons.inject do |so_far, piece|
+              negated ? so_far.and(piece) : so_far.or(piece)
+            end
+            negated ? Arel::Nodes::Grouping.new(joined) : joined
+          end
       end
 
       # ANY and ALL, which stand on the right of a comparison and say how many
@@ -1472,7 +2003,7 @@ module ActiveRecord
       end
 
       class Like < Predicate
-        ESCAPE = "\\".freeze
+        ESCAPE = "\\"
 
         # Escapes % and _ so that they match literally. The pattern built from
         # the result must be used with ESCAPE, since SQLite has no default
@@ -1484,8 +2015,8 @@ module ActiveRecord
         # ORs one LIKE per pattern, for the shortcuts that accept several
         # literals the way String#start_with? does.
         def self.any(operand, patterns)
-          patterns.map {|pattern| new(operand, pattern, ESCAPE) }.
-            inject {|left, right| Or.new(left, right) }
+          patterns.map { |pattern| new(operand, pattern, ESCAPE) }.
+            inject { |left, right| Or.new(left, right) }
         end
 
         attr_reader :operand, :pattern, :escape, :case_sensitive, :negated
@@ -1569,21 +2100,20 @@ module ActiveRecord
         end
 
         private
-
-        # PostgreSQL array input syntax: elements joined by commas inside
-        # braces, and an element is double-quoted whenever it is empty, spells
-        # NULL, or contains a character the parser treats specially.
-        def array_literal
-          encoded = elements.map do |value|
-            s = value.to_s
-            if s.empty? || s.casecmp?("null") || s.match?(/[\s{},"\\]/)
-              "\"#{s.gsub(/["\\]/) {|c| "\\#{c}" }}\""
-            else
-              s
+          # PostgreSQL array input syntax: elements joined by commas inside
+          # braces, and an element is double-quoted whenever it is empty, spells
+          # NULL, or contains a character the parser treats specially.
+          def array_literal
+            encoded = elements.map do |value|
+              s = value.to_s
+              if s.empty? || s.casecmp?("null") || s.match?(/[\s{},"\\]/)
+                "\"#{s.gsub(/["\\]/) { |c| "\\#{c}" }}\""
+              else
+                s
+              end
             end
+            "{#{encoded.join(',')}}"
           end
-          "{#{encoded.join(',')}}"
-        end
       end
 
       # Regular expression match: REGEXP on MySQL, ~ on PostgreSQL.  SQLite has
@@ -1607,19 +2137,18 @@ module ActiveRecord
         end
 
         private
-
-        # A Regexp literal reads naturally with =~, but only its source crosses
-        # over; the database has its own dialect and no notion of Ruby's flags.
-        # Dropping a flag would silently change what the query matches, so
-        # anything beyond a plain literal is refused rather than ignored.
-        def regexp_source(regexp)
-          unless regexp.options.zero?
-            raise ArgumentError,
-              "#{regexp.inspect} has options that SQL cannot express; " \
-              "pass the pattern as a string instead"
+          # A Regexp literal reads naturally with =~, but only its source crosses
+          # over; the database has its own dialect and no notion of Ruby's flags.
+          # Dropping a flag would silently change what the query matches, so
+          # anything beyond a plain literal is refused rather than ignored.
+          def regexp_source(regexp)
+            unless regexp.options.zero?
+              raise ArgumentError,
+                "#{regexp.inspect} has options that SQL cannot express; " \
+                "pass the pattern as a string instead"
+            end
+            regexp.source
           end
-          regexp.source
-        end
       end
 
       class And < Predicate