activerecord 5.2.6 → 6.0.0.beta1

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

data/lib/arel/nodes/grouping.rb

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

data/lib/arel/nodes/in.rb

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

data/lib/arel/nodes/infix_operation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InfixOperation < Binary
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::OrderPredications
+      include Arel::AliasPredication
+      include Arel::Math
+
+      attr_reader :operator
+
+      def initialize(operator, left, right)
+        super(left, right)
+        @operator = operator
+      end
+    end
+
+    class Multiplication < InfixOperation
+      def initialize(left, right)
+        super(:*, left, right)
+      end
+    end
+
+    class Division < InfixOperation
+      def initialize(left, right)
+        super(:/, left, right)
+      end
+    end
+
+    class Addition < InfixOperation
+      def initialize(left, right)
+        super(:+, left, right)
+      end
+    end
+
+    class Subtraction < InfixOperation
+      def initialize(left, right)
+        super(:-, left, right)
+      end
+    end
+
+    class Concat < InfixOperation
+      def initialize(left, right)
+        super("||", left, right)
+      end
+    end
+
+    class BitwiseAnd < InfixOperation
+      def initialize(left, right)
+        super(:&, left, right)
+      end
+    end
+
+    class BitwiseOr < InfixOperation
+      def initialize(left, right)
+        super(:|, left, right)
+      end
+    end
+
+    class BitwiseXor < InfixOperation
+      def initialize(left, right)
+        super(:^, left, right)
+      end
+    end
+
+    class BitwiseShiftLeft < InfixOperation
+      def initialize(left, right)
+        super(:<<, left, right)
+      end
+    end
+
+    class BitwiseShiftRight < InfixOperation
+      def initialize(left, right)
+        super(:>>, left, right)
+      end
+    end
+  end
+end

data/lib/arel/nodes/inner_join.rb

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

data/lib/arel/nodes/insert_statement.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class InsertStatement < Arel::Nodes::Node
+      attr_accessor :relation, :columns, :values, :select
+
+      def initialize
+        super()
+        @relation = nil
+        @columns  = []
+        @values   = nil
+        @select   = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @columns = @columns.clone
+        @values =  @values.clone if @values
+        @select =  @select.clone if @select
+      end
+
+      def hash
+        [@relation, @columns, @values, @select].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.columns == other.columns &&
+          self.select == other.select &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/join_source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    ###
+    # Class that represents a join source
+    #
+    #   http://www.sqlite.org/syntaxdiagrams.html#join-source
+
+    class JoinSource < Arel::Nodes::Binary
+      def initialize(single_source, joinop = [])
+        super
+      end
+
+      def empty?
+        !left && right.empty?
+      end
+    end
+  end
+end

data/lib/arel/nodes/matches.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Matches < Binary
+      attr_reader :escape
+      attr_accessor :case_sensitive
+
+      def initialize(left, right, escape = nil, case_sensitive = false)
+        super(left, right)
+        @escape = escape && Nodes.build_quoted(escape)
+        @case_sensitive = case_sensitive
+      end
+    end
+
+    class DoesNotMatch < Matches; end
+  end
+end

data/lib/arel/nodes/named_function.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class NamedFunction < Arel::Nodes::Function
+      attr_accessor :name
+
+      def initialize(name, expr, aliaz = nil)
+        super(expr, aliaz)
+        @name = name
+      end
+
+      def hash
+        super ^ @name.hash
+      end
+
+      def eql?(other)
+        super && self.name == other.name
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    ###
+    # Abstract base class for all AST nodes
+    class Node
+      include Arel::FactoryMethods
+      include Enumerable
+
+      ###
+      # Factory method to create a Nodes::Not node that has the recipient of
+      # the caller as a child.
+      def not
+        Nodes::Not.new self
+      end
+
+      ###
+      # Factory method to create a Nodes::Grouping node that has an Nodes::Or
+      # node as a child.
+      def or(right)
+        Nodes::Grouping.new Nodes::Or.new(self, right)
+      end
+
+      ###
+      # Factory method to create an Nodes::And node.
+      def and(right)
+        Nodes::And.new [self, right]
+      end
+
+      # FIXME: this method should go away.  I don't like people calling
+      # to_sql on non-head nodes.  This forces us to walk the AST until we
+      # can find a node that has a "relation" member.
+      #
+      # Maybe we should just use `Table.engine`?  :'(
+      def to_sql(engine = Table.engine)
+        collector = Arel::Collectors::SQLString.new
+        collector = engine.connection.visitor.accept self, collector
+        collector.value
+      end
+
+      # Iterate through AST, nodes will be yielded depth-first
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        ::Arel::Visitors::DepthFirst.new(block).accept self
+      end
+    end
+  end
+end