activerecord 5.2.3 → 6.1.0

data/lib/arel/nodes/infix_operation.rb

@@ -0,0 +1,92 @@
+# 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 Contains < InfixOperation
+      def initialize(left, right)
+        super(:"@>", left, right)
+      end
+    end
+
+    class Overlaps < 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
+    #
+    #   https://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,51 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    ###
+    # Abstract base class for all AST nodes
+    class Node
+      include Arel::FactoryMethods
+
+      ###
+      # 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
+
+      def invert
+        Arel::Nodes::Not.new(self)
+      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
+
+      def fetch_attribute
+      end
+
+      def equality?; false; end
+    end
+  end
+end

data/lib/arel/nodes/node_expression.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class NodeExpression < Arel::Nodes::Node
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+      include Arel::Math
+    end
+  end
+end

data/lib/arel/nodes/ordering.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Ordering < Unary
+      def nulls_first
+        NullsFirst.new(self)
+      end
+
+      def nulls_last
+        NullsLast.new(self)
+      end
+    end
+
+    class NullsFirst < Ordering
+      def reverse
+        NullsLast.new(expr.reverse)
+      end
+    end
+
+    class NullsLast < Ordering
+      def reverse
+        NullsFirst.new(expr.reverse)
+      end
+    end
+  end
+end

data/lib/arel/nodes/outer_join.rb

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

data/lib/arel/nodes/over.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Over < Binary
+      include Arel::AliasPredication
+
+      def initialize(left, right = nil)
+        super(left, right)
+      end
+
+      def operator; "OVER" end
+    end
+  end
+end

data/lib/arel/nodes/regexp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Regexp < Binary
+      attr_accessor :case_sensitive
+
+      def initialize(left, right, case_sensitive = true)
+        super(left, right)
+        @case_sensitive = case_sensitive
+      end
+    end
+
+    class NotRegexp < Regexp; end
+  end
+end

data/lib/arel/nodes/right_outer_join.rb

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

data/lib/arel/nodes/select_core.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class SelectCore < Arel::Nodes::Node
+      attr_accessor :projections, :wheres, :groups, :windows, :comment
+      attr_accessor :havings, :source, :set_quantifier, :optimizer_hints
+
+      def initialize
+        super()
+        @source = JoinSource.new nil
+
+        # https://ronsavage.github.io/SQL/sql-92.bnf.html#set%20quantifier
+        @set_quantifier  = nil
+        @optimizer_hints = nil
+        @projections     = []
+        @wheres          = []
+        @groups          = []
+        @havings         = []
+        @windows         = []
+        @comment         = nil
+      end
+
+      def from
+        @source.left
+      end
+
+      def from=(value)
+        @source.left = value
+      end
+
+      alias :froms= :from=
+      alias :froms :from
+
+      def initialize_copy(other)
+        super
+        @source      = @source.clone if @source
+        @projections = @projections.clone
+        @wheres      = @wheres.clone
+        @groups      = @groups.clone
+        @havings     = @havings.clone
+        @windows     = @windows.clone
+      end
+
+      def hash
+        [
+          @source, @set_quantifier, @projections, @optimizer_hints,
+          @wheres, @groups, @havings, @windows, @comment
+        ].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.source == other.source &&
+          self.set_quantifier == other.set_quantifier &&
+          self.optimizer_hints == other.optimizer_hints &&
+          self.projections == other.projections &&
+          self.wheres == other.wheres &&
+          self.groups == other.groups &&
+          self.havings == other.havings &&
+          self.windows == other.windows &&
+          self.comment == other.comment
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/select_statement.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class SelectStatement < Arel::Nodes::NodeExpression
+      attr_reader :cores
+      attr_accessor :limit, :orders, :lock, :offset, :with
+
+      def initialize(cores = [SelectCore.new])
+        super()
+        @cores          = cores
+        @orders         = []
+        @limit          = nil
+        @lock           = nil
+        @offset         = nil
+        @with           = nil
+      end
+
+      def initialize_copy(other)
+        super
+        @cores  = @cores.map { |x| x.clone }
+        @orders = @orders.map { |x| x.clone }
+      end
+
+      def hash
+        [@cores, @orders, @limit, @lock, @offset, @with].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.cores == other.cores &&
+          self.orders == other.orders &&
+          self.limit == other.limit &&
+          self.lock == other.lock &&
+          self.offset == other.offset &&
+          self.with == other.with
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/sql_literal.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class SqlLiteral < String
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::AliasPredication
+      include Arel::OrderPredications
+
+      def encode_with(coder)
+        coder.scalar = self.to_s
+      end
+
+      def fetch_attribute
+      end
+    end
+  end
+end

data/lib/arel/nodes/string_join.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class StringJoin < Arel::Nodes::Join
+      def initialize(left, right = nil)
+        super
+      end
+    end
+  end
+end

data/lib/arel/nodes/table_alias.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class TableAlias < Arel::Nodes::Binary
+      alias :name :right
+      alias :relation :left
+      alias :table_alias :name
+
+      def [](name)
+        relation.is_a?(Table) ? relation[name, self] : Attribute.new(self, name)
+      end
+
+      def table_name
+        relation.respond_to?(:name) ? relation.name : name
+      end
+
+      def type_cast_for_database(attr_name, value)
+        relation.type_cast_for_database(attr_name, value)
+      end
+
+      def type_for_attribute(name)
+        relation.type_for_attribute(name)
+      end
+
+      def able_to_type_cast?
+        relation.respond_to?(:able_to_type_cast?) && relation.able_to_type_cast?
+      end
+    end
+  end
+end

data/lib/arel/nodes/terminal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Distinct < 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/true.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class True < 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/unary.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Unary < Arel::Nodes::NodeExpression
+      attr_accessor :expr
+      alias :value :expr
+
+      def initialize(expr)
+        super()
+        @expr = expr
+      end
+
+      def hash
+        @expr.hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.expr == other.expr
+      end
+      alias :== :eql?
+    end
+
+    %w{
+      Bin
+      Cube
+      DistinctOn
+      Group
+      GroupingElement
+      GroupingSet
+      Lateral
+      Limit
+      Lock
+      Not
+      Offset
+      On
+      OptimizerHints
+      RollUp
+    }.each do |name|
+      const_set(name, Class.new(Unary))
+    end
+  end
+end

data/lib/arel/nodes/unary_operation.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class UnaryOperation < Unary
+      attr_reader :operator
+
+      def initialize(operator, operand)
+        super(operand)
+        @operator = operator
+      end
+    end
+
+    class BitwiseNot < UnaryOperation
+      def initialize(operand)
+        super(:~, operand)
+      end
+    end
+  end
+end

data/lib/arel/nodes/unqualified_column.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class UnqualifiedColumn < Arel::Nodes::Unary
+      alias :attribute :expr
+      alias :attribute= :expr=
+
+      def relation
+        @expr.relation
+      end
+
+      def column
+        @expr.column
+      end
+
+      def name
+        @expr.name
+      end
+    end
+  end
+end

data/lib/arel/nodes/update_statement.rb

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