activerecord-refined 0.5.0 → 0.6.0

data/lib/active_record/refined/ast.rb

@@ -1,11 +1,9 @@
+# JSON.generate, for the document a containment test is given.
+require 'json'
+
 module ActiveRecord
   module Refined
     module AST
-      # Column aliases and function names are written into the SQL as given,
-      # where a value would have been quoted, so anything that is not a plain
-      # name is refused.  Quoting them instead would need the model's adapter,
-      # which does not reach this far, and quoting with the wrong one would be
-      # a bug of its own -- MySQL does not read "x" as an identifier.
       NAME = /[[:alpha:]_][[:alnum:]_$]*/
       ALIAS_NAME = /\A#{NAME}\z/
       FUNCTION_NAME = /\A#{NAME}(\.#{NAME})?\z/
@@ -13,6 +11,22 @@ module ActiveRecord
       # lengths -- double precision, decimal(10,2).
       TYPE_NAME = /\A[[:alpha:]_][[:alnum:]_ ]*(\(\d+(, ?\d+)?\))?\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.
+      ADAPTER_FAMILIES = {
+        'sqlite3' => :sqlite,
+        'postgresql' => :postgresql,
+        'postgis' => :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}"
@@ -63,26 +77,78 @@ module ActiveRecord
           Match.new(self, pattern, negated: true)
         end
 
+        # `!` 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,
+        # including when the column is NULL; what they save is the reading.
         def null?
           Comparison.new(self, :==, nil)
         end
 
+        def not_null?
+          Comparison.new(self, :!=, nil)
+        end
+
+        # 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
+        # difference shows in the negations: `not_true?` keeps the NULL rows
+        # that `!(:flag == true)` drops.
+        def true?
+          TruthValue.new(self, true)
+        end
+
+        def not_true?
+          TruthValue.new(self, true, negated: true)
+        end
+
+        def false?
+          TruthValue.new(self, false)
+        end
+
+        def not_false?
+          TruthValue.new(self, false, negated: true)
+        end
+
         def in?(values)
           In.new(self, values)
         end
 
+        def not_in?(values)
+          In.new(self, values, negated: true)
+        end
+
         def between?(min, max)
           In.new(self, min..max)
         end
 
+        def not_between?(min, max)
+          In.new(self, min..max, negated: true)
+        end
+
+        # 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`.
+        def when(value = nil, &block)
+          Case.new(self).when(value, &block)
+        end
+
         def like?(pattern)
           Like.new(self, pattern)
         end
 
+        def not_like?(pattern)
+          Like.new(self, pattern, negated: true)
+        end
+
         def ilike?(pattern)
           Like.new(self, pattern, nil, case_sensitive: false)
         end
 
+        def not_ilike?(pattern)
+          Like.new(self, pattern, nil, case_sensitive: false, negated: true)
+        end
+
         # 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)
@@ -144,6 +210,39 @@ module ActiveRecord
         def intersect?(elements)
           ArrayPredicate.new(self, :"&&", ArrayPredicate.elements(elements, "intersect?"))
         end
+
+        # 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 the value rather than the JSON, since that is what
+        # a comparison wants.  dig_json keeps it JSON, for a document to be dug
+        # into further or compared whole.
+        def dig(*path)
+          JsonPath.new(self, path)
+        end
+
+        def dig_json(*path)
+          JsonPath.new(self, path, as_json: true)
+        end
+
+        # 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.
+        def bury(*path, value)
+          JsonSet.new(self, path, value)
+        end
+
+        # 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 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.
+        def key?(key)
+          JsonHasKey.new(self, key)
+        end
       end
 
       # Arithmetic builders shared by symbols, qualified columns and
@@ -165,41 +264,48 @@ module ActiveRecord
         def /(other)
           Arithmetic.new(self, :/, other)
         end
-      end
 
-      # Aggregate builders shared by symbols, qualified columns and
-      # expressions.  Imported into the Symbol refinement like Predications,
-      # so every method must be defined with def.
-      module Aggregations
-        # DISTINCT is Arel's only aggregate modifier, and only for count.
-        def count(distinct: false)
-          Aggregate.new(self, :count, distinct: distinct)
+        # 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
+        # comparisons, so `:flags & 4 > 0` groups the way it reads.
+        def &(other)
+          Bitwise.new(self, :&, other)
+        end
+
+        def |(other)
+          Bitwise.new(self, :|, other)
         end
 
-        def sum
-          Aggregate.new(self, :sum)
+        def ^(other)
+          Bitwise.new(self, :^, other)
         end
 
-        def average
-          Aggregate.new(self, :average)
+        def <<(other)
+          Bitwise.new(self, :<<, other)
         end
 
-        def maximum
-          Aggregate.new(self, :maximum)
+        def >>(other)
+          Bitwise.new(self, :>>, other)
         end
 
-        def minimum
-          Aggregate.new(self, :minimum)
+        def ~
+          BitwiseNot.new(self)
         end
       end
 
       class Node
-        def to_arel(table)
+        # The model travels with the table because some SQL cannot be written
+        # without knowing the adapter, and a node is built before anything
+        # knows which one it will be rendered for -- a symbol becomes a node
+        # inside a refinement, where there is no model to ask.  Most nodes
+        # never look at it and only pass it on.
+        def to_arel(table, model)
           raise ScriptError, "subclass must override this method"
         end
 
-        def as(alias_name)
-          As.new(self, alias_name)
+        def as(alias_name, quote: true)
+          As.new(self, alias_name, quote: quote)
         end
 
         def asc
@@ -213,9 +319,9 @@ module ActiveRecord
         private
 
         # Resolves an operand denoting a column or an expression.
-        def to_arel_operand(operand, table)
+        def to_arel_operand(operand, table, model)
           case operand
-          when Node then operand.to_arel(table)
+          when Node then operand.to_arel(table, model)
           when :* then Arel.star
           when Symbol then table[operand]
           else operand
@@ -224,9 +330,9 @@ module ActiveRecord
 
         # Resolves a function argument: a column or an expression as above,
         # anything else a value to be quoted.
-        def to_arel_argument(arg, table)
+        def to_arel_argument(arg, table, model)
           case arg
-          when Node, Symbol then to_arel_operand(arg, table)
+          when Node, Symbol then to_arel_operand(arg, table, model)
           else Arel::Nodes.build_quoted(arg)
           end
         end
@@ -246,10 +352,333 @@ module ActiveRecord
         end
       end
 
+      # 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 ActiveRecord'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.
+      class Value < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_arel(_table, _model)
+          Arel::Nodes.build_quoted(value)
+        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.
+      #
+      # Every method returns a new node rather than adding to this one, so a
+      # case kept in a variable can be branched from more than once.
+      class Case < Node
+        include Predications
+        include Arithmetics
+
+        # Having no ELSE is not the same as an ELSE of nil, and nil is what an
+        # omitted argument looks like, so the absence needs a value of its own.
+        NOTHING = Object.new.freeze
+        private_constant :NOTHING
+
+        attr_reader :operand, :whens, :default
+
+        def initialize(operand = nil, whens = [], default = NOTHING)
+          @operand = operand
+          @whens = whens
+          @default = default
+        end
+
+        def when(value = nil, &block)
+          Pending.new(self, Case.argument(:when, value, block))
+        end
+
+        # 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
+
+        def else(value = nil, &block)
+          Case.new(operand, whens, Case.argument(:else, value, block))
+        end
+
+        def to_arel(table, model)
+          raise ArgumentError, "case needs a when before it means anything" if whens.empty?
+
+          node = operand ? Arel::Nodes::Case.new(to_arel_operand(operand, table, model))
+                         : Arel::Nodes::Case.new
+          whens.each do |condition, result|
+            node.when(to_arel_argument(condition, table, model)).
+              then(to_arel_argument(result, table, model))
+          end
+          node.else(to_arel_argument(default, table, model)) unless default.equal?(NOTHING)
+          node
+        end
+
+        # A value or a block, and exactly one of them: the block is what makes
+        # `when { :age >= 60 }` read like the blocks around it, and the value is
+        # what makes `when(10)` possible at all.
+        def self.argument(name, value, block)
+          if block
+            raise ArgumentError, "#{name} takes a value or a block, not both" unless value.nil?
+            return block.call
+          end
+          raise ArgumentError, "#{name} needs a value or a block" if value.nil?
+          value
+        end
+
+        # What a `when` is until its `then` arrives.  A Node so that using it
+        # as one says what is missing rather than reaching ActiveRecord as
+        # something it cannot read.
+        class Pending < Node
+          def initialize(kase, condition)
+            @kase = kase
+            @condition = condition
+          end
+
+          def then(value = nil, &block)
+            Case.new(@kase.operand,
+                     @kase.whens + [[@condition, Case.argument(:then, value, block)]],
+                     @kase.default)
+          end
+
+          def to_arel(_table, _model)
+            raise ArgumentError, "when needs a matching then"
+          end
+        end
+      end
+
+      # A path into a JSON document, spelled the two ways the adapters want it.
+      # Shared, because reading a value and setting one walk the same path.
+      module JsonSteps
+        def check_steps(path, called)
+          raise ArgumentError, "#{called} needs a key or an index" if path.empty?
+          path.each do |step|
+            next if step.is_a?(::Integer) || step.is_a?(::String) || step.is_a?(::Symbol)
+            raise ArgumentError, "a step is a key or an array index, not #{step.inspect}"
+          end
+          path
+        end
+
+        # PostgreSQL takes the steps as a text array, where every element is
+        # quoted so that a comma or a brace in a key is part of it.
+        def steps_array
+          "{#{path.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(+'$') do |so_far, step|
+            next so_far << "[#{step}]" if step.is_a?(::Integer)
+            name = step.to_s
+            so_far << '.' << (name.match?(/\A[[:alpha:]_][[:alnum:]_]*\z/) ?
+                              name : %("#{escape_step(step)}"))
+          end
+        end
+
+        def escape_step(step)
+          step.to_s.gsub('\\', '\\\\').gsub('"', '\\"')
+        end
+      end
+
+      # Reading inside a JSON document.  Every adapter can do it and no two
+      # spell it alike: PostgreSQL walks an array of steps, SQLite has the
+      # operators with a $ path, and MySQL has the functions -- which is what
+      # this uses for that family, since MariaDB answers to the same adapter
+      # and has no -> at all.
+      #
+      # The path is turned into a string either way, so a key with a space or
+      # a quote in it travels as itself rather than having to be refused.
+      class JsonPath < Node
+        include Predications
+        include Arithmetics
+        include JsonSteps
+
+        attr_reader :operand, :path, :as_json
+
+        def initialize(operand, path, as_json: false)
+          @operand = operand
+          @path = check_steps(path, 'dig')
+          @as_json = as_json
+        end
+
+        def to_arel(table, model)
+          document = to_arel_operand(operand, table, model)
+          case AST.adapter_family(model)
+          when :postgresql
+            Arel::Nodes::InfixOperation.new(
+              as_json ? :"#>" : :"#>>", 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])
+          else
+            extracted = Arel::Nodes::InfixOperation.new(
+              as_json ? :"->" : :"->>", 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(: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'))])
+          end
+        end
+
+      end
+
+      # Setting a value inside a JSON document, which is what bury does to what
+      # dig reads.  The document comes back changed rather than being written
+      # anywhere; update_all is what writes it.
+      class JsonSet < Node
+        include Predications
+        include JsonSteps
+
+        attr_reader :operand, :path, :value
+
+        def initialize(operand, path, value)
+          @operand = operand
+          @path = check_steps(path, 'bury')
+          @value = value
+        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
+        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, which
+        # they read out of a literal rather than take as a string.  MySQL casts
+        # to JSON where MariaDB, which answers to the same adapter, does not.
+        def other_value(table, model)
+          return to_arel_operand(value, table, model) if expression?
+          return Arel::Nodes.build_quoted(value) unless value.is_a?(::Hash) || value.is_a?(::Array)
+
+          Arel::Nodes::NamedFunction.new(
+            'JSON_EXTRACT',
+            [Arel::Nodes.build_quoted(JSON.generate(value)), Arel::Nodes.build_quoted('$')])
+        end
+
+        def expression?
+          value.is_a?(Node) || value.is_a?(::Symbol)
+        end
+      end
+
+      # JSON containment: whether the document holds what is given.
+      class JsonContains < Predicate
+        attr_reader :operand, :value
+
+        def initialize(operand, value)
+          @operand = operand
+          @value = value
+        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
+        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.
+      class JsonHasKey < Predicate
+        attr_reader :operand, :key
+
+        def initialize(operand, key)
+          @operand = operand
+          @key = key
+        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::NamedFunction.new('jsonb_exists', [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
+        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.
+      #
+      # Each set is a list of its own, so grouping_sets takes lists and rollup
+      # and cube take the columns themselves.
+      class GroupingSets < Node
+        KINDS = {
+          grouping_sets: Arel::Nodes::GroupingSet,
+          rollup: Arel::Nodes::RollUp,
+          cube: Arel::Nodes::Cube,
+        }.freeze
+
+        attr_reader :kind, :sets
+
+        def initialize(kind, sets)
+          raise ArgumentError, "#{kind} needs something to group by" if sets.empty?
+          @kind = kind
+          @sets = sets
+        end
+
+        def to_arel(table, model)
+          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) })
+              end
+            else
+              sets.map {|column| to_arel_operand(column, table, model) }
+            end)
+        end
+      end
+
       class Column < Node
         include Predications
         include Arithmetics
-        include Aggregations
 
         attr_reader :table_name, :column_name
 
@@ -258,7 +687,7 @@ module ActiveRecord
           @column_name = column_name
         end
 
-        def to_arel(_table)
+        def to_arel(_table, _model)
           Arel::Table.new(table_name)[column_name]
         end
       end
@@ -269,7 +698,6 @@ module ActiveRecord
       class Arithmetic < Node
         include Predications
         include Arithmetics
-        include Aggregations
 
         attr_reader :left, :operator, :right
 
@@ -279,19 +707,218 @@ module ActiveRecord
           @right = right
         end
 
-        def to_arel(table)
-          to_arel_operand(left, table).
-            public_send(operator, to_arel_operand(right, table))
+        def to_arel(table, model)
+          to_arel_operand(left, table, model).
+            public_send(operator, to_arel_operand(right, table, model))
+        end
+      end
+
+      # What the bitwise operators refuse.  Both refusals are there because
+      # the same Ruby would otherwise mean different things per adapter: MySQL
+      # and SQLite take a boolean for the one bit it is stored as, so
+      # `published & active` would quietly be the AND it looks like, while
+      # 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
+
+        # 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
+      # keeps Ruby's grouping: PostgreSQL gives & and | the same precedence
+      # and reads a | b & c from the left, where Ruby reads the & first.
+      class Bitwise < Node
+        include Predications
+        include Arithmetics
+        include BitwiseOperands
+
+        NODES = {
+          :& => Arel::Nodes::BitwiseAnd,
+          :| => Arel::Nodes::BitwiseOr,
+          :<< => Arel::Nodes::BitwiseShiftLeft,
+          :>> => Arel::Nodes::BitwiseShiftRight,
+        }.freeze
+
+        attr_reader :left, :operator, :right
+
+        def initialize(left, operator, right)
+          @left = left
+          @operator = operator
+          @right = check_operand(right, operator)
+        end
+
+        def to_arel(table, model)
+          check_not_boolean(left, operator, model)
+          check_not_boolean(right, operator, model)
+          arel_left = to_arel_operand(left, table, model)
+          arel_right = to_arel_argument(right, table, model)
+          Arel::Nodes::Grouping.new(
+            if operator == :^
+              xor(arel_left, arel_right, model)
+            else
+              NODES.fetch(operator).new(arel_left, arel_right)
+            end)
+        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)))
+          end
+        end
+      end
+
+      # ~, which every adapter has.  MySQL answers with the unsigned 64-bit
+      # number where the others answer with a negative one; the bits are the
+      # same, and only reading the value back tells them apart.
+      class BitwiseNot < Node
+        include Predications
+        include Arithmetics
+        include BitwiseOperands
+
+        attr_reader :operand
+
+        def initialize(operand)
+          @operand = check_operand(operand, :~)
+        end
+
+        def to_arel(table, model)
+          check_not_boolean(operand, :~, model)
+          Arel::Nodes::Grouping.new(
+            Arel::Nodes::BitwiseNot.new(to_arel_operand(operand, table, model)))
+        end
+      end
+
+      # OVER, on the two things that can carry a window: an aggregate, and a
+      # function.
+      module Windowing
+        def over
+          Over.new(self)
+        end
+      end
+
+      # A function with a window.  The window is built by chaining, the way
+      # Arel's own is, and each method returns a new node rather than adding to
+      # this one, so a window can be finished more than one way.
+      class Over < Node
+        include Predications
+        include Arithmetics
+
+        attr_reader :function, :partitions, :orders, :frame
+
+        def initialize(function, partitions = [], orders = [], frame = nil)
+          @function = function
+          @partitions = partitions
+          @orders = orders
+          @frame = frame
+        end
+
+        def partition(*exprs)
+          raise ArgumentError, "partition needs an expression" if exprs.empty?
+          Over.new(function, partitions + exprs, orders, frame)
+        end
+
+        def order(*exprs)
+          raise ArgumentError, "order needs an expression" if exprs.empty?
+          Over.new(function, partitions, orders + exprs, frame)
+        end
+
+        def rows(bounds)
+          Over.new(function, partitions, orders, framing(:rows, bounds))
+        end
+
+        def range(bounds)
+          Over.new(function, partitions, orders, framing(:range, bounds))
+        end
+
+        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)) }
+          frame_arel(window) if frame
+
+          # A window-only function refuses to build on its own; here is where
+          # it is asked for the call itself.
+          arel_function =
+            function.is_a?(WindowFunction) ? function.call_arel(table, model)
+                                           : function.to_arel(table, model)
+          Arel::Nodes::Over.new(arel_function, window)
+        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"
+          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
+
+        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
         include Predications
         include Arithmetics
+        include Windowing
 
-        attr_reader :operand, :function, :distinct
+        attr_reader :operand, :function, :distinct, :condition
 
-        def initialize(operand, function, distinct: false)
+        def initialize(operand, function, distinct: false, condition: nil)
           if distinct && function != :count
             raise ArgumentError, "#{function} does not take distinct"
           end
@@ -301,10 +928,35 @@ module ActiveRecord
           @operand = operand
           @function = function
           @distinct = distinct
+          @condition = condition
         end
 
-        def to_arel(table)
-          arel_operand = to_arel_operand(operand, table)
+        # FILTER (WHERE ...): the aggregate is taken over the rows the
+        # condition holds for.  A value or a block, as `when` takes them.
+        def filter(condition = nil, &block)
+          Aggregate.new(operand, function, distinct: distinct,
+                        condition: Case.argument(:filter, condition, block))
+        end
+
+        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
+            kept = Case.new.when(condition).then(operand == :* ? 1 : operand)
+            return aggregate(kept, table, model)
+          end
+
+          aggregate(operand, table, model).filter(condition.to_arel(table, model))
+        end
+
+        private
+
+        def aggregate(over, table, model)
+          arel_operand = to_arel_operand(over, table, model)
           if function == :count
             arel_operand.count(distinct)
           else
@@ -313,16 +965,37 @@ module ActiveRecord
         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.
+      # Quoting also leaves nothing to refuse -- a name that would have been
+      # SQL is an identifier with a strange name instead.
+      #
+      # `quote: false` asks for the name as written, for a schema that wants
+      # the folding.
       class As < Node
-        attr_reader :operand, :alias_name
+        attr_reader :operand, :alias_name, :quote
 
-        def initialize(operand, alias_name)
+        def initialize(operand, alias_name, quote: true)
+          # Checked here rather than where the SQL is built, so that a name
+          # the adapter is not being asked to quote is refused where it was
+          # written.
+          AST.check_name(alias_name, ALIAS_NAME, "column alias") unless quote
           @operand = operand
-          @alias_name = AST.check_name(alias_name, ALIAS_NAME, "column alias")
+          @alias_name = alias_name
+          @quote = quote
         end
 
-        def to_arel(table)
-          to_arel_operand(operand, table).as(alias_name.to_s)
+        def to_arel(table, model)
+          to_arel_operand(operand, table, model).as(alias_sql(model))
+        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
       end
 
@@ -345,8 +1018,8 @@ module ActiveRecord
           Ordering.new(operand, direction, :nulls_last)
         end
 
-        def to_arel(table)
-          ordering = to_arel_operand(operand, table).public_send(direction)
+        def to_arel(table, model)
+          ordering = to_arel_operand(operand, table, model).public_send(direction)
           nulls ? ordering.public_send(nulls) : ordering
         end
       end
@@ -354,6 +1027,7 @@ module ActiveRecord
       class Function < Node
         include Predications
         include Arithmetics
+        include Windowing
 
         attr_reader :name, :args
 
@@ -362,12 +1036,23 @@ module ActiveRecord
           @args = args
         end
 
-        def to_arel(table)
-          arel_args = args.map {|arg| to_arel_argument(arg, table) }
+        def to_arel(table, model)
+          arel_args = args.map {|arg| to_arel_argument(arg, table, model) }
           Arel::Nodes::NamedFunction.new(name, arel_args)
         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.
+      class WindowFunction < Function
+        alias_method :call_arel, :to_arel
+
+        def to_arel(_table, _model)
+          raise ArgumentError, "#{name.downcase} is a window function; it needs over"
+        end
+      end
+
       # EXTRACT(field FROM expr).  The field is grammar rather than a value --
       # a keyword the adapter reads bare -- so it has to be a plain name,
       # which Arel upcases on the way out.
@@ -382,8 +1067,8 @@ module ActiveRecord
           @operand = operand
         end
 
-        def to_arel(table)
-          Arel::Nodes::Extract.new(to_arel_argument(operand, table), field.to_s)
+        def to_arel(table, model)
+          Arel::Nodes::Extract.new(to_arel_argument(operand, table, model), field.to_s)
         end
       end
 
@@ -402,10 +1087,10 @@ module ActiveRecord
           @sql_type = AST.check_name(sql_type, TYPE_NAME, "SQL type")
         end
 
-        def to_arel(table)
+        def to_arel(table, model)
           Arel::Nodes::NamedFunction.new(
             "CAST",
-            [Arel::Nodes::As.new(to_arel_argument(operand, table),
+            [Arel::Nodes::As.new(to_arel_argument(operand, table, model),
                                  Arel::Nodes::SqlLiteral.new(sql_type.to_s))])
         end
       end
@@ -431,7 +1116,7 @@ module ActiveRecord
           @precision = precision
         end
 
-        def to_arel(_table)
+        def to_arel(_table, _model)
           Arel::Nodes::SqlLiteral.new(
             precision ? "#{name}(#{precision})" : name)
         end
@@ -454,11 +1139,11 @@ module ActiveRecord
           @value = value
         end
 
-        def to_arel(table)
-          arel_column = to_arel_operand(column, table)
+        def to_arel(table, model)
+          arel_column = to_arel_operand(column, table, model)
           arel_value =
             case value
-            when Node then value.to_arel(table)
+            when Node then value.to_arel(table, model)
             when ActiveRecord::Relation then scalar_subquery(value)
             else value
             end
@@ -479,39 +1164,38 @@ module ActiveRecord
         end
       end
 
-      # IN for a list of values, BETWEEN for a range, IN (SELECT ...) for a
-      # relation.
-      class In < Predicate
-        attr_reader :operand, :values
+      # IS TRUE, IS FALSE and their negations, which every adapter spells the
+      # same way and answers alike, NULL included.
+      class TruthValue < Predicate
+        attr_reader :operand, :value, :negated
 
-        def initialize(operand, values)
+        def initialize(operand, value, negated: false)
           @operand = operand
-          @values = values
+          @value = value
+          @negated = negated
         end
 
-        def to_arel(table)
-          arel_operand = to_arel_operand(operand, table)
-          case values
-          when Range then arel_operand.between(values)
-          when ActiveRecord::Relation then arel_operand.in(subquery(values))
-          else arel_operand.in(values)
-          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)
         end
+      end
 
+      # A relation standing for a set of values, which is what IN and the
+      # quantifiers each take.  The treatment is ActiveRecord's own
+      # RelationHandler's: without an explicit select list the subquery
+      # selects the model's primary key.
+      module SetSubquery
         private
 
-        # The same treatment ActiveRecord's own RelationHandler gives a
-        # relation used as a value: without an explicit select list the
-        # subquery selects the model's primary key.
-        def subquery(relation)
-          if relation.eager_loading?
-            relation = relation.send(:apply_join_dependency)
-          end
+        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 IN"
+                "Cannot map composite primary key #{model.primary_key} to #{spelling}"
             end
             relation = relation.select(relation.table[model.primary_key])
           end
@@ -519,6 +1203,55 @@ module ActiveRecord
         end
       end
 
+      # IN for a list of values, BETWEEN for a range, IN (SELECT ...) for a
+      # relation.
+      class In < Predicate
+        include SetSubquery
+
+        attr_reader :operand, :values, :negated
+
+        def initialize(operand, values, negated: false)
+          @operand = operand
+          @values = values
+          @negated = negated
+        end
+
+        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)
+          else
+            arg = values.is_a?(ActiveRecord::Relation) ? set_subquery(values, 'IN') : values
+            arel_operand.public_send(negated ? :not_in : :in, arg)
+          end
+        end
+      end
+
+      # ANY and ALL, which stand on the right of a comparison and say how many
+      # of the subquery's rows have to satisfy it.  Where a scalar subquery
+      # has to return one row, these take as many as come.
+      class Quantified < Node
+        include SetSubquery
+
+        attr_reader :kind, :relation
+
+        def initialize(kind, relation)
+          unless relation.is_a?(ActiveRecord::Relation)
+            raise ArgumentError,
+              "#{kind} takes a relation as its subquery; a list is what in? takes"
+          end
+          @kind = kind
+          @relation = relation
+        end
+
+        # The subquery goes in as its own AST rather than as the manager,
+        # which would parenthesise it a second time -- and to PostgreSQL
+        # `ANY ((SELECT ...))` is ANY of one scalar, which it refuses.
+        def to_arel(_table, _model)
+          Arel::Nodes::NamedFunction.new(kind, [set_subquery(relation, kind).ast])
+        end
+      end
+
       # EXISTS (SELECT ...) for a relation.  Correlate the subquery with the
       # outer table through qualified columns.  EXISTS only asks whether a row
       # comes back, so unlike In there is no select list to fix up.
@@ -529,7 +1262,7 @@ module ActiveRecord
           @relation = relation
         end
 
-        def to_arel(_table)
+        def to_arel(_table, _model)
           subquery = relation
           if subquery.eager_loading?
             subquery = subquery.send(:apply_join_dependency)
@@ -555,19 +1288,23 @@ module ActiveRecord
             inject {|left, right| Or.new(left, right) }
         end
 
-        attr_reader :operand, :pattern, :escape, :case_sensitive
+        attr_reader :operand, :pattern, :escape, :case_sensitive, :negated
 
-        def initialize(operand, pattern, escape = nil, case_sensitive: true)
+        def initialize(operand, pattern, escape = nil, case_sensitive: true,
+                       negated: false)
           @operand = operand
           @pattern = pattern
           @escape = escape
           @case_sensitive = case_sensitive
+          @negated = negated
         end
 
-        def to_arel(table)
+        def to_arel(table, model)
           # Arel matches case-insensitively unless told otherwise, which is
           # what picks ILIKE over LIKE on PostgreSQL.
-          to_arel_operand(operand, table).matches(pattern, escape, case_sensitive)
+          to_arel_operand(operand, table, model).
+            public_send(negated ? :does_not_match : :matches,
+                        pattern, escape, case_sensitive)
         end
       end
 
@@ -583,9 +1320,9 @@ module ActiveRecord
           @negated = negated
         end
 
-        def to_arel(table)
-          arel_operand = to_arel_operand(operand, table)
-          arel_value = value.is_a?(Node) ? value.to_arel(table) : value
+        def to_arel(table, model)
+          arel_operand = to_arel_operand(operand, table, model)
+          arel_value = value.is_a?(Node) ? value.to_arel(table, model) : value
           if negated
             arel_operand.is_distinct_from(arel_value)
           else
@@ -621,8 +1358,8 @@ module ActiveRecord
           @elements = elements
         end
 
-        def to_arel(table)
-          arel_operand = to_arel_operand(operand, table)
+        def to_arel(table, model)
+          arel_operand = to_arel_operand(operand, table, model)
           quoted = Arel::Nodes.build_quoted(array_literal)
           case operator
           when :"@>" then Arel::Nodes::Contains.new(arel_operand, quoted)
@@ -660,8 +1397,8 @@ module ActiveRecord
           @negated = negated
         end
 
-        def to_arel(table)
-          arel_operand = to_arel_operand(operand, table)
+        def to_arel(table, model)
+          arel_operand = to_arel_operand(operand, table, model)
           if negated
             arel_operand.does_not_match_regexp(pattern)
           else
@@ -693,8 +1430,8 @@ module ActiveRecord
           @right = right
         end
 
-        def to_arel(table)
-          left.to_arel(table).and(right.to_arel(table))
+        def to_arel(table, model)
+          left.to_arel(table, model).and(right.to_arel(table, model))
         end
       end
 
@@ -706,8 +1443,8 @@ module ActiveRecord
           @right = right
         end
 
-        def to_arel(table)
-          left.to_arel(table).or(right.to_arel(table))
+        def to_arel(table, model)
+          left.to_arel(table, model).or(right.to_arel(table, model))
         end
       end
 
@@ -718,8 +1455,8 @@ module ActiveRecord
           @operand = operand
         end
 
-        def to_arel(table)
-          Arel::Nodes::Not.new(operand.to_arel(table))
+        def to_arel(table, model)
+          Arel::Nodes::Not.new(operand.to_arel(table, model))
         end
       end
     end