activerecord 5.2.3.rc1 → 6.0.0.beta1

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,257 @@
+# 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 other.end.nil? || open_ended?(other.end)
+          not_in([])
+        elsif other.exclude_end?
+          lt(other.end)
+        else
+          lteq(other.end)
+        end
+      elsif other.end.nil? || 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 Range
+        if $VERBOSE
+          warn <<-eowarn
+Passing a range to `#in` is deprecated. Call `#between`, instead.
+          eowarn
+        end
+        between(other)
+      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 other.end.nil? || open_ended?(other.end)
+          self.in([])
+        elsif other.exclude_end?
+          gteq(other.end)
+        else
+          gt(other.end)
+        end
+      elsif other.end.nil? || 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 Range
+        if $VERBOSE
+          warn <<-eowarn
+Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
+          eowarn
+        end
+        not_between(other)
+      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
+
+    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 quoted_array(others)
+        others.map { |v| quoted_node(v) }
+      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)
+        infinity?(value) || unboundable?(value)
+      end
+  end
+end

data/lib/arel/select_manager.rb

@@ -0,0 +1,271 @@
+# 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 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?
+
+      viz = Visitors::WhereSql.new(engine.connection.visitor, engine.connection)
+      Nodes::SqlLiteral.new viz.accept(@ctx, Collectors::SQLString.new).value
+    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
+
+    class Row < Struct.new(:data) # :nodoc:
+      def id
+        data["id"]
+      end
+
+      def method_missing(name, *args)
+        name = name.to_s
+        return data[name] if data.key?(name)
+        super
+      end
+    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