activerecord 5.0.7.2 → 6.1.1

data/lib/arel/nodes/values_list.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class ValuesList < Unary
+      alias :rows :expr
+    end
+  end
+end

data/lib/arel/nodes/window.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Window < Arel::Nodes::Node
+      attr_accessor :orders, :framing, :partitions
+
+      def initialize
+        @orders = []
+        @partitions = []
+        @framing = nil
+      end
+
+      def order(*expr)
+        # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+        @orders.concat expr.map { |x|
+          String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
+        }
+        self
+      end
+
+      def partition(*expr)
+        # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+        @partitions.concat expr.map { |x|
+          String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
+        }
+        self
+      end
+
+      def frame(expr)
+        @framing = expr
+      end
+
+      def rows(expr = nil)
+        if @framing
+          Rows.new(expr)
+        else
+          frame(Rows.new(expr))
+        end
+      end
+
+      def range(expr = nil)
+        if @framing
+          Range.new(expr)
+        else
+          frame(Range.new(expr))
+        end
+      end
+
+      def initialize_copy(other)
+        super
+        @orders = @orders.map { |x| x.clone }
+      end
+
+      def hash
+        [@orders, @framing].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.orders == other.orders &&
+          self.framing == other.framing &&
+          self.partitions == other.partitions
+      end
+      alias :== :eql?
+    end
+
+    class NamedWindow < Window
+      attr_accessor :name
+
+      def initialize(name)
+        super()
+        @name = name
+      end
+
+      def initialize_copy(other)
+        super
+        @name = other.name.clone
+      end
+
+      def hash
+        super ^ @name.hash
+      end
+
+      def eql?(other)
+        super && self.name == other.name
+      end
+      alias :== :eql?
+    end
+
+    class Rows < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+
+    class Range < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+
+    class CurrentRow < Node
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+
+    class Preceding < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+
+    class Following < Unary
+      def initialize(expr = nil)
+        super(expr)
+      end
+    end
+  end
+end

data/lib/arel/nodes/with.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class With < Arel::Nodes::Unary
+      alias children expr
+    end
+
+    class WithRecursive < With; end
+  end
+end

data/lib/arel/order_predications.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module OrderPredications
+    def asc
+      Nodes::Ascending.new self
+    end
+
+    def desc
+      Nodes::Descending.new self
+    end
+  end
+end

data/lib/arel/predications.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Predications
+    def not_eq(other)
+      Nodes::NotEqual.new self, quoted_node(other)
+    end
+
+    def not_eq_any(others)
+      grouping_any :not_eq, others
+    end
+
+    def not_eq_all(others)
+      grouping_all :not_eq, others
+    end
+
+    def eq(other)
+      Nodes::Equality.new self, quoted_node(other)
+    end
+
+    def is_not_distinct_from(other)
+      Nodes::IsNotDistinctFrom.new self, quoted_node(other)
+    end
+
+    def is_distinct_from(other)
+      Nodes::IsDistinctFrom.new self, quoted_node(other)
+    end
+
+    def eq_any(others)
+      grouping_any :eq, others
+    end
+
+    def eq_all(others)
+      grouping_all :eq, quoted_array(others)
+    end
+
+    def between(other)
+      if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
+        self.in([])
+      elsif open_ended?(other.begin)
+        if open_ended?(other.end)
+          not_in([])
+        elsif other.exclude_end?
+          lt(other.end)
+        else
+          lteq(other.end)
+        end
+      elsif open_ended?(other.end)
+        gteq(other.begin)
+      elsif other.exclude_end?
+        gteq(other.begin).and(lt(other.end))
+      else
+        left = quoted_node(other.begin)
+        right = quoted_node(other.end)
+        Nodes::Between.new(self, left.and(right))
+      end
+    end
+
+    def in(other)
+      case other
+      when Arel::SelectManager
+        Arel::Nodes::In.new(self, other.ast)
+      when Enumerable
+        Nodes::In.new self, quoted_array(other)
+      else
+        Nodes::In.new self, quoted_node(other)
+      end
+    end
+
+    def in_any(others)
+      grouping_any :in, others
+    end
+
+    def in_all(others)
+      grouping_all :in, others
+    end
+
+    def not_between(other)
+      if unboundable?(other.begin) == 1 || unboundable?(other.end) == -1
+        not_in([])
+      elsif open_ended?(other.begin)
+        if open_ended?(other.end)
+          self.in([])
+        elsif other.exclude_end?
+          gteq(other.end)
+        else
+          gt(other.end)
+        end
+      elsif open_ended?(other.end)
+        lt(other.begin)
+      else
+        left = lt(other.begin)
+        right = if other.exclude_end?
+          gteq(other.end)
+        else
+          gt(other.end)
+        end
+        left.or(right)
+      end
+    end
+
+    def not_in(other)
+      case other
+      when Arel::SelectManager
+        Arel::Nodes::NotIn.new(self, other.ast)
+      when Enumerable
+        Nodes::NotIn.new self, quoted_array(other)
+      else
+        Nodes::NotIn.new self, quoted_node(other)
+      end
+    end
+
+    def not_in_any(others)
+      grouping_any :not_in, others
+    end
+
+    def not_in_all(others)
+      grouping_all :not_in, others
+    end
+
+    def matches(other, escape = nil, case_sensitive = false)
+      Nodes::Matches.new self, quoted_node(other), escape, case_sensitive
+    end
+
+    def matches_regexp(other, case_sensitive = true)
+      Nodes::Regexp.new self, quoted_node(other), case_sensitive
+    end
+
+    def matches_any(others, escape = nil, case_sensitive = false)
+      grouping_any :matches, others, escape, case_sensitive
+    end
+
+    def matches_all(others, escape = nil, case_sensitive = false)
+      grouping_all :matches, others, escape, case_sensitive
+    end
+
+    def does_not_match(other, escape = nil, case_sensitive = false)
+      Nodes::DoesNotMatch.new self, quoted_node(other), escape, case_sensitive
+    end
+
+    def does_not_match_regexp(other, case_sensitive = true)
+      Nodes::NotRegexp.new self, quoted_node(other), case_sensitive
+    end
+
+    def does_not_match_any(others, escape = nil)
+      grouping_any :does_not_match, others, escape
+    end
+
+    def does_not_match_all(others, escape = nil)
+      grouping_all :does_not_match, others, escape
+    end
+
+    def gteq(right)
+      Nodes::GreaterThanOrEqual.new self, quoted_node(right)
+    end
+
+    def gteq_any(others)
+      grouping_any :gteq, others
+    end
+
+    def gteq_all(others)
+      grouping_all :gteq, others
+    end
+
+    def gt(right)
+      Nodes::GreaterThan.new self, quoted_node(right)
+    end
+
+    def gt_any(others)
+      grouping_any :gt, others
+    end
+
+    def gt_all(others)
+      grouping_all :gt, others
+    end
+
+    def lt(right)
+      Nodes::LessThan.new self, quoted_node(right)
+    end
+
+    def lt_any(others)
+      grouping_any :lt, others
+    end
+
+    def lt_all(others)
+      grouping_all :lt, others
+    end
+
+    def lteq(right)
+      Nodes::LessThanOrEqual.new self, quoted_node(right)
+    end
+
+    def lteq_any(others)
+      grouping_any :lteq, others
+    end
+
+    def lteq_all(others)
+      grouping_all :lteq, others
+    end
+
+    def when(right)
+      Nodes::Case.new(self).when quoted_node(right)
+    end
+
+    def concat(other)
+      Nodes::Concat.new self, other
+    end
+
+    def contains(other)
+      Arel::Nodes::Contains.new(self, other)
+    end
+
+    def overlaps(other)
+      Arel::Nodes::Overlaps.new(self, other)
+    end
+
+    def quoted_array(others)
+      others.map { |v| quoted_node(v) }
+    end
+
+    private
+      def grouping_any(method_id, others, *extras)
+        nodes = others.map { |expr| send(method_id, expr, *extras) }
+        Nodes::Grouping.new nodes.inject { |memo, node|
+          Nodes::Or.new(memo, node)
+        }
+      end
+
+      def grouping_all(method_id, others, *extras)
+        nodes = others.map { |expr| send(method_id, expr, *extras) }
+        Nodes::Grouping.new Nodes::And.new(nodes)
+      end
+
+      def quoted_node(other)
+        Nodes.build_quoted(other, self)
+      end
+
+      def infinity?(value)
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+
+      def unboundable?(value)
+        value.respond_to?(:unboundable?) && value.unboundable?
+      end
+
+      def open_ended?(value)
+        value.nil? || infinity?(value) || unboundable?(value)
+      end
+  end
+end

data/lib/arel/select_manager.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class SelectManager < Arel::TreeManager
+    include Arel::Crud
+
+    STRING_OR_SYMBOL_CLASS = [Symbol, String]
+
+    def initialize(table = nil)
+      super()
+      @ast = Nodes::SelectStatement.new
+      @ctx = @ast.cores.last
+      from table
+    end
+
+    def initialize_copy(other)
+      super
+      @ctx = @ast.cores.last
+    end
+
+    def limit
+      @ast.limit && @ast.limit.expr
+    end
+    alias :taken :limit
+
+    def constraints
+      @ctx.wheres
+    end
+
+    def offset
+      @ast.offset && @ast.offset.expr
+    end
+
+    def skip(amount)
+      if amount
+        @ast.offset = Nodes::Offset.new(amount)
+      else
+        @ast.offset = nil
+      end
+      self
+    end
+    alias :offset= :skip
+
+    ###
+    # Produces an Arel::Nodes::Exists node
+    def exists
+      Arel::Nodes::Exists.new @ast
+    end
+
+    def as(other)
+      create_table_alias grouping(@ast), Nodes::SqlLiteral.new(other)
+    end
+
+    def lock(locking = Arel.sql("FOR UPDATE"))
+      case locking
+      when true
+        locking = Arel.sql("FOR UPDATE")
+      when Arel::Nodes::SqlLiteral
+      when String
+        locking = Arel.sql locking
+      end
+
+      @ast.lock = Nodes::Lock.new(locking)
+      self
+    end
+
+    def locked
+      @ast.lock
+    end
+
+    def on(*exprs)
+      @ctx.source.right.last.right = Nodes::On.new(collapse(exprs))
+      self
+    end
+
+    def group(*columns)
+      columns.each do |column|
+        # FIXME: backwards compat
+        column = Nodes::SqlLiteral.new(column) if String === column
+        column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
+
+        @ctx.groups.push Nodes::Group.new column
+      end
+      self
+    end
+
+    def from(table)
+      table = Nodes::SqlLiteral.new(table) if String === table
+
+      case table
+      when Nodes::Join
+        @ctx.source.right << table
+      else
+        @ctx.source.left = table
+      end
+
+      self
+    end
+
+    def froms
+      @ast.cores.map { |x| x.from }.compact
+    end
+
+    def join(relation, klass = Nodes::InnerJoin)
+      return self unless relation
+
+      case relation
+      when String, Nodes::SqlLiteral
+        raise EmptyJoinError if relation.empty?
+        klass = Nodes::StringJoin
+      end
+
+      @ctx.source.right << create_join(relation, nil, klass)
+      self
+    end
+
+    def outer_join(relation)
+      join(relation, Nodes::OuterJoin)
+    end
+
+    def having(expr)
+      @ctx.havings << expr
+      self
+    end
+
+    def window(name)
+      window = Nodes::NamedWindow.new(name)
+      @ctx.windows.push window
+      window
+    end
+
+    def project(*projections)
+      # FIXME: converting these to SQLLiterals is probably not good, but
+      # rails tests require it.
+      @ctx.projections.concat projections.map { |x|
+        STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def projections
+      @ctx.projections
+    end
+
+    def projections=(projections)
+      @ctx.projections = projections
+    end
+
+    def optimizer_hints(*hints)
+      unless hints.empty?
+        @ctx.optimizer_hints = Arel::Nodes::OptimizerHints.new(hints)
+      end
+      self
+    end
+
+    def distinct(value = true)
+      if value
+        @ctx.set_quantifier = Arel::Nodes::Distinct.new
+      else
+        @ctx.set_quantifier = nil
+      end
+      self
+    end
+
+    def distinct_on(value)
+      if value
+        @ctx.set_quantifier = Arel::Nodes::DistinctOn.new(value)
+      else
+        @ctx.set_quantifier = nil
+      end
+      self
+    end
+
+    def order(*expr)
+      # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
+      @ast.orders.concat expr.map { |x|
+        STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
+      }
+      self
+    end
+
+    def orders
+      @ast.orders
+    end
+
+    def where_sql(engine = Table.engine)
+      return if @ctx.wheres.empty?
+
+      Nodes::SqlLiteral.new("WHERE #{Nodes::And.new(@ctx.wheres).to_sql(engine)}")
+    end
+
+    def union(operation, other = nil)
+      if other
+        node_class = Nodes.const_get("Union#{operation.to_s.capitalize}")
+      else
+        other = operation
+        node_class = Nodes::Union
+      end
+
+      node_class.new self.ast, other.ast
+    end
+
+    def intersect(other)
+      Nodes::Intersect.new ast, other.ast
+    end
+
+    def except(other)
+      Nodes::Except.new ast, other.ast
+    end
+    alias :minus :except
+
+    def lateral(table_name = nil)
+      base = table_name.nil? ? ast : as(table_name)
+      Nodes::Lateral.new(base)
+    end
+
+    def with(*subqueries)
+      if subqueries.first.is_a? Symbol
+        node_class = Nodes.const_get("With#{subqueries.shift.to_s.capitalize}")
+      else
+        node_class = Nodes::With
+      end
+      @ast.with = node_class.new(subqueries.flatten)
+
+      self
+    end
+
+    def take(limit)
+      if limit
+        @ast.limit = Nodes::Limit.new(limit)
+      else
+        @ast.limit = nil
+      end
+      self
+    end
+    alias limit= take
+
+    def join_sources
+      @ctx.source.right
+    end
+
+    def source
+      @ctx.source
+    end
+
+    def comment(*values)
+      @ctx.comment = Nodes::Comment.new(values)
+      self
+    end
+
+    private
+      def collapse(exprs)
+        exprs = exprs.compact
+        exprs.map! { |expr|
+          if String === expr
+            # FIXME: Don't do this automatically
+            Arel.sql(expr)
+          else
+            expr
+          end
+        }
+
+        if exprs.length == 1
+          exprs.first
+        else
+          create_and exprs
+        end
+      end
+  end
+end