activerecord 5.2.8.1 → 6.1.6.1

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

data/lib/arel/table.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class Table
+    include Arel::Crud
+    include Arel::FactoryMethods
+    include Arel::AliasPredication
+
+    @engine = nil
+    class << self; attr_accessor :engine; end
+
+    attr_accessor :name, :table_alias
+
+    # TableAlias and Table both have a #table_name which is the name of the underlying table
+    alias :table_name :name
+
+    def initialize(name, as: nil, klass: nil, type_caster: klass&.type_caster)
+      @name = name.to_s
+      @klass = klass
+      @type_caster = type_caster
+
+      # Sometime AR sends an :as parameter to table, to let the table know
+      # that it is an Alias.  We may want to override new, and return a
+      # TableAlias node?
+      if as.to_s == @name
+        as = nil
+      end
+      @table_alias = as
+    end
+
+    def alias(name = "#{self.name}_2")
+      Nodes::TableAlias.new(self, name)
+    end
+
+    def from
+      SelectManager.new(self)
+    end
+
+    def join(relation, klass = Nodes::InnerJoin)
+      return from unless relation
+
+      case relation
+      when String, Nodes::SqlLiteral
+        raise EmptyJoinError if relation.empty?
+        klass = Nodes::StringJoin
+      end
+
+      from.join(relation, klass)
+    end
+
+    def outer_join(relation)
+      join(relation, Nodes::OuterJoin)
+    end
+
+    def group(*columns)
+      from.group(*columns)
+    end
+
+    def order(*expr)
+      from.order(*expr)
+    end
+
+    def where(condition)
+      from.where condition
+    end
+
+    def project(*things)
+      from.project(*things)
+    end
+
+    def take(amount)
+      from.take amount
+    end
+
+    def skip(amount)
+      from.skip amount
+    end
+
+    def having(expr)
+      from.having expr
+    end
+
+    def [](name, table = self)
+      name = name.to_s if name.is_a?(Symbol)
+      name = @klass.attribute_aliases[name] || name if @klass
+      Attribute.new(table, name)
+    end
+
+    def hash
+      # Perf note: aliases and table alias is excluded from the hash
+      #  aliases can have a loop back to this table breaking hashes in parent
+      #  relations, for the vast majority of cases @name is unique to a query
+      @name.hash
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+        self.name == other.name &&
+        self.table_alias == other.table_alias
+    end
+    alias :== :eql?
+
+    def type_cast_for_database(attr_name, value)
+      type_caster.type_cast_for_database(attr_name, value)
+    end
+
+    def type_for_attribute(name)
+      type_caster.type_for_attribute(name)
+    end
+
+    def able_to_type_cast?
+      !type_caster.nil?
+    end
+
+    private
+      attr_reader :type_caster
+  end
+end

data/lib/arel/tree_manager.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class TreeManager
+    include Arel::FactoryMethods
+
+    module StatementMethods
+      def take(limit)
+        @ast.limit = Nodes::Limit.new(Nodes.build_quoted(limit)) if limit
+        self
+      end
+
+      def offset(offset)
+        @ast.offset = Nodes::Offset.new(Nodes.build_quoted(offset)) if offset
+        self
+      end
+
+      def order(*expr)
+        @ast.orders = expr
+        self
+      end
+
+      def key=(key)
+        @ast.key = Nodes.build_quoted(key)
+      end
+
+      def key
+        @ast.key
+      end
+
+      def wheres=(exprs)
+        @ast.wheres = exprs
+      end
+
+      def where(expr)
+        @ast.wheres << expr
+        self
+      end
+    end
+
+    attr_reader :ast
+
+    def initialize
+      @ctx = nil
+    end
+
+    def to_dot
+      collector = Arel::Collectors::PlainString.new
+      collector = Visitors::Dot.new.accept @ast, collector
+      collector.value
+    end
+
+    def to_sql(engine = Table.engine)
+      collector = Arel::Collectors::SQLString.new
+      collector = engine.connection.visitor.accept @ast, collector
+      collector.value
+    end
+
+    def initialize_copy(other)
+      super
+      @ast = @ast.clone
+    end
+
+    def where(expr)
+      if Arel::TreeManager === expr
+        expr = expr.ast
+      end
+      @ctx.wheres << expr
+      self
+    end
+  end
+end

data/lib/arel/update_manager.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class UpdateManager < Arel::TreeManager
+    include TreeManager::StatementMethods
+
+    def initialize
+      super
+      @ast = Nodes::UpdateStatement.new
+      @ctx = @ast
+    end
+
+    ###
+    # UPDATE +table+
+    def table(table)
+      @ast.relation = table
+      self
+    end
+
+    def set(values)
+      if String === values
+        @ast.values = [values]
+      else
+        @ast.values = values.map { |column, value|
+          Nodes::Assignment.new(
+            Nodes::UnqualifiedColumn.new(column),
+            value
+          )
+        }
+      end
+      self
+    end
+  end
+end