activerecord 5.2.8 → 6.0.0.beta1

data/lib/arel/crud.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  ###
+  # FIXME hopefully we can remove this
+  module Crud
+    def compile_update(values, pk)
+      um = UpdateManager.new
+
+      if Nodes::SqlLiteral === values
+        relation = @ctx.from
+      else
+        relation = values.first.first.relation
+      end
+      um.key = pk
+      um.table relation
+      um.set values
+      um.take @ast.limit.expr if @ast.limit
+      um.order(*@ast.orders)
+      um.wheres = @ctx.wheres
+      um
+    end
+
+    def compile_insert(values)
+      im = create_insert
+      im.insert values
+      im
+    end
+
+    def create_insert
+      InsertManager.new
+    end
+
+    def compile_delete
+      dm = DeleteManager.new
+      dm.take @ast.limit.expr if @ast.limit
+      dm.wheres = @ctx.wheres
+      dm.from @ctx.froms
+      dm
+    end
+  end
+end

data/lib/arel/delete_manager.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class DeleteManager < Arel::TreeManager
+    include TreeManager::StatementMethods
+
+    def initialize
+      super
+      @ast = Nodes::DeleteStatement.new
+      @ctx = @ast
+    end
+
+    def from(relation)
+      @ast.relation = relation
+      self
+    end
+  end
+end

data/lib/arel/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class ArelError < StandardError
+  end
+
+  class EmptyJoinError < ArelError
+  end
+end

data/lib/arel/expressions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Expressions
+    def count(distinct = false)
+      Nodes::Count.new [self], distinct
+    end
+
+    def sum
+      Nodes::Sum.new [self]
+    end
+
+    def maximum
+      Nodes::Max.new [self]
+    end
+
+    def minimum
+      Nodes::Min.new [self]
+    end
+
+    def average
+      Nodes::Avg.new [self]
+    end
+
+    def extract(field)
+      Nodes::Extract.new [self], field
+    end
+  end
+end

data/lib/arel/factory_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  ###
+  # Methods for creating various nodes
+  module FactoryMethods
+    def create_true
+      Arel::Nodes::True.new
+    end
+
+    def create_false
+      Arel::Nodes::False.new
+    end
+
+    def create_table_alias(relation, name)
+      Nodes::TableAlias.new(relation, name)
+    end
+
+    def create_join(to, constraint = nil, klass = Nodes::InnerJoin)
+      klass.new(to, constraint)
+    end
+
+    def create_string_join(to)
+      create_join to, nil, Nodes::StringJoin
+    end
+
+    def create_and(clauses)
+      Nodes::And.new clauses
+    end
+
+    def create_on(expr)
+      Nodes::On.new expr
+    end
+
+    def grouping(expr)
+      Nodes::Grouping.new expr
+    end
+
+    ###
+    # Create a LOWER() function
+    def lower(column)
+      Nodes::NamedFunction.new "LOWER", [Nodes.build_quoted(column)]
+    end
+
+    def coalesce(*exprs)
+      Nodes::NamedFunction.new "COALESCE", exprs
+    end
+  end
+end

data/lib/arel/insert_manager.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  class InsertManager < Arel::TreeManager
+    def initialize
+      super
+      @ast = Nodes::InsertStatement.new
+    end
+
+    def into(table)
+      @ast.relation = table
+      self
+    end
+
+    def columns; @ast.columns end
+    def values=(val); @ast.values = val; end
+
+    def select(select)
+      @ast.select = select
+    end
+
+    def insert(fields)
+      return if fields.empty?
+
+      if String === fields
+        @ast.values = Nodes::SqlLiteral.new(fields)
+      else
+        @ast.relation ||= fields.first.first.relation
+
+        values = []
+
+        fields.each do |column, value|
+          @ast.columns << column
+          values << value
+        end
+        @ast.values = create_values values, @ast.columns
+      end
+      self
+    end
+
+    def create_values(values, columns)
+      Nodes::Values.new values, columns
+    end
+
+    def create_values_list(rows)
+      Nodes::ValuesList.new(rows)
+    end
+  end
+end

data/lib/arel/math.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Math
+    def *(other)
+      Arel::Nodes::Multiplication.new(self, other)
+    end
+
+    def +(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::Addition.new(self, other))
+    end
+
+    def -(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::Subtraction.new(self, other))
+    end
+
+    def /(other)
+      Arel::Nodes::Division.new(self, other)
+    end
+
+    def &(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseAnd.new(self, other))
+    end
+
+    def |(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseOr.new(self, other))
+    end
+
+    def ^(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseXor.new(self, other))
+    end
+
+    def <<(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftLeft.new(self, other))
+    end
+
+    def >>(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftRight.new(self, other))
+    end
+
+    def ~@
+      Arel::Nodes::BitwiseNot.new(self)
+    end
+  end
+end

data/lib/arel/nodes/and.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class And < Arel::Nodes::Node
+      attr_reader :children
+
+      def initialize(children)
+        super()
+        @children = children
+      end
+
+      def left
+        children.first
+      end
+
+      def right
+        children[1]
+      end
+
+      def hash
+        children.hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.children == other.children
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/ascending.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Ascending < Ordering
+      def reverse
+        Descending.new(expr)
+      end
+
+      def direction
+        :asc
+      end
+
+      def ascending?
+        true
+      end
+
+      def descending?
+        false
+      end
+    end
+  end
+end

data/lib/arel/nodes/binary.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Binary < Arel::Nodes::NodeExpression
+      attr_accessor :left, :right
+
+      def initialize(left, right)
+        super()
+        @left  = left
+        @right = right
+      end
+
+      def initialize_copy(other)
+        super
+        @left  = @left.clone if @left
+        @right = @right.clone if @right
+      end
+
+      def hash
+        [self.class, @left, @right].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.left == other.left &&
+          self.right == other.right
+      end
+      alias :== :eql?
+    end
+
+    %w{
+      As
+      Assignment
+      Between
+      GreaterThan
+      GreaterThanOrEqual
+      Join
+      LessThan
+      LessThanOrEqual
+      NotEqual
+      NotIn
+      Or
+      Union
+      UnionAll
+      Intersect
+      Except
+    }.each do |name|
+      const_set name, Class.new(Binary)
+    end
+  end
+end

data/lib/arel/nodes/bind_param.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class BindParam < Node
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+        super()
+      end
+
+      def hash
+        [self.class, self.value].hash
+      end
+
+      def eql?(other)
+        other.is_a?(BindParam) &&
+          value == other.value
+      end
+      alias :== :eql?
+
+      def nil?
+        value.nil?
+      end
+
+      def infinite?
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+
+      def unboundable?
+        value.respond_to?(:unboundable?) && value.unboundable?
+      end
+    end
+  end
+end

data/lib/arel/nodes/case.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Case < Arel::Nodes::Node
+      attr_accessor :case, :conditions, :default
+
+      def initialize(expression = nil, default = nil)
+        @case = expression
+        @conditions = []
+        @default = default
+      end
+
+      def when(condition, expression = nil)
+        @conditions << When.new(Nodes.build_quoted(condition), expression)
+        self
+      end
+
+      def then(expression)
+        @conditions.last.right = Nodes.build_quoted(expression)
+        self
+      end
+
+      def else(expression)
+        @default = Else.new Nodes.build_quoted(expression)
+        self
+      end
+
+      def initialize_copy(other)
+        super
+        @case = @case.clone if @case
+        @conditions = @conditions.map { |x| x.clone }
+        @default = @default.clone if @default
+      end
+
+      def hash
+        [@case, @conditions, @default].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.case == other.case &&
+          self.conditions == other.conditions &&
+          self.default == other.default
+      end
+      alias :== :eql?
+    end
+
+    class When < Binary # :nodoc:
+    end
+
+    class Else < Unary # :nodoc:
+    end
+  end
+end

data/lib/arel/nodes/casted.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Casted < Arel::Nodes::NodeExpression # :nodoc:
+      attr_reader :val, :attribute
+      def initialize(val, attribute)
+        @val       = val
+        @attribute = attribute
+        super()
+      end
+
+      def nil?; @val.nil?; end
+
+      def hash
+        [self.class, val, attribute].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+            self.val == other.val &&
+            self.attribute == other.attribute
+      end
+      alias :== :eql?
+    end
+
+    class Quoted < Arel::Nodes::Unary # :nodoc:
+      alias :val :value
+      def nil?; val.nil?; end
+
+      def infinite?
+        value.respond_to?(:infinite?) && value.infinite?
+      end
+    end
+
+    def self.build_quoted(other, attribute = nil)
+      case other
+      when Arel::Nodes::Node, Arel::Attributes::Attribute, Arel::Table, Arel::Nodes::BindParam, Arel::SelectManager, Arel::Nodes::Quoted, Arel::Nodes::SqlLiteral
+        other
+      else
+        case attribute
+        when Arel::Attributes::Attribute
+          Casted.new other, attribute
+        else
+          Quoted.new other
+        end
+      end
+    end
+  end
+end

data/lib/arel/nodes/count.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Count < Arel::Nodes::Function
+      def initialize(expr, distinct = false, aliaz = nil)
+        super(expr, aliaz)
+        @distinct = distinct
+      end
+    end
+  end
+end

data/lib/arel/nodes/delete_statement.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class DeleteStatement < Arel::Nodes::Node
+      attr_accessor :left, :right, :orders, :limit, :offset, :key
+
+      alias :relation :left
+      alias :relation= :left=
+      alias :wheres :right
+      alias :wheres= :right=
+
+      def initialize(relation = nil, wheres = [])
+        super()
+        @left = relation
+        @right = wheres
+        @orders = []
+        @limit = nil
+        @offset = nil
+        @key = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @left  = @left.clone if @left
+        @right = @right.clone if @right
+      end
+
+      def hash
+        [self.class, @left, @right, @orders, @limit, @offset, @key].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.left == other.left &&
+          self.right == other.right &&
+          self.orders == other.orders &&
+          self.limit == other.limit &&
+          self.offset == other.offset &&
+          self.key == other.key
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/descending.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Descending < Ordering
+      def reverse
+        Ascending.new(expr)
+      end
+
+      def direction
+        :desc
+      end
+
+      def ascending?
+        false
+      end
+
+      def descending?
+        true
+      end
+    end
+  end
+end

data/lib/arel/nodes/equality.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Equality < Arel::Nodes::Binary
+      def operator; :== end
+      alias :operand1 :left
+      alias :operand2 :right
+    end
+
+    %w{
+      IsDistinctFrom
+      IsNotDistinctFrom
+    }.each do |name|
+      const_set name, Class.new(Equality)
+    end
+  end
+end

data/lib/arel/nodes/extract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Extract < Arel::Nodes::Unary
+      attr_accessor :field
+
+      def initialize(expr, field)
+        super(expr)
+        @field = field
+      end
+
+      def hash
+        super ^ @field.hash
+      end
+
+      def eql?(other)
+        super &&
+          self.field == other.field
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/false.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class False < Arel::Nodes::NodeExpression
+      def hash
+        self.class.hash
+      end
+
+      def eql?(other)
+        self.class == other.class
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/full_outer_join.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class FullOuterJoin < Arel::Nodes::Join
+    end
+  end
+end

data/lib/arel/nodes/function.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Function < Arel::Nodes::NodeExpression
+      include Arel::WindowPredications
+      attr_accessor :expressions, :alias, :distinct
+
+      def initialize(expr, aliaz = nil)
+        super()
+        @expressions = expr
+        @alias       = aliaz && SqlLiteral.new(aliaz)
+        @distinct    = false
+      end
+
+      def as(aliaz)
+        self.alias = SqlLiteral.new(aliaz)
+        self
+      end
+
+      def hash
+        [@expressions, @alias, @distinct].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.expressions == other.expressions &&
+          self.alias == other.alias &&
+          self.distinct == other.distinct
+      end
+      alias :== :eql?
+    end
+
+    %w{
+      Sum
+      Exists
+      Max
+      Min
+      Avg
+    }.each do |name|
+      const_set(name, Class.new(Function))
+    end
+  end
+end