arel 6.0.4 → 7.1.4

data/lib/arel/nodes/binary.rb

@@ -38,9 +38,7 @@ module Arel
       LessThanOrEqual
       NotEqual
       NotIn
-      NotRegexp
       Or
-      Regexp
       Union
       UnionAll
       Intersect

data/lib/arel/nodes/bind_param.rb

@@ -1,6 +1,9 @@
 module Arel
   module Nodes
     class BindParam < Node
+      def ==(other)
+        other.is_a?(BindParam)
+      end
     end
   end
 end

data/lib/arel/nodes/case.rb

@@ -0,0 +1,57 @@
+module Arel
+  module Nodes
+    class Case < Arel::Nodes::Node
+      include Arel::OrderPredications
+      include Arel::Predications
+      include Arel::AliasPredication
+
+      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,44 @@
+module Arel
+  module Nodes
+    class Casted < Arel::Nodes::Node # :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
+    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
+          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/delete_statement.rb

@@ -1,6 +1,8 @@
 module Arel
   module Nodes
     class DeleteStatement < Arel::Nodes::Binary
+      attr_accessor :limit
+
       alias :relation :left
       alias :relation= :left=
       alias :wheres :right

data/lib/arel/nodes/infix_operation.rb

@@ -40,5 +40,40 @@ module Arel
       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
+end

data/lib/arel/nodes/matches.rb

@@ -2,10 +2,12 @@ module Arel
   module Nodes
     class Matches < Binary
       attr_reader :escape
+      attr_accessor :case_sensitive
 
-      def initialize(left, right, escape = nil)
+      def initialize(left, right, escape = nil, case_sensitive = false)
         super(left, right)
         @escape = escape && Nodes.build_quoted(escape)
+        @case_sensitive = case_sensitive
       end
     end
 

data/lib/arel/nodes/regexp.rb

@@ -0,0 +1,14 @@
+module Arel
+  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/select_core.rb

@@ -2,7 +2,7 @@ module Arel
   module Nodes
     class SelectCore < Arel::Nodes::Node
       attr_accessor :top, :projections, :wheres, :groups, :windows
-      attr_accessor :having, :source, :set_quantifier
+      attr_accessor :havings, :source, :set_quantifier
 
       def initialize
         super()
@@ -14,7 +14,7 @@ module Arel
         @projections    = []
         @wheres         = []
         @groups         = []
-        @having         = nil
+        @havings        = []
         @windows        = []
       end
 
@@ -35,14 +35,14 @@ module Arel
         @projections = @projections.clone
         @wheres      = @wheres.clone
         @groups      = @groups.clone
-        @having      = @having.clone if @having
+        @havings     = @havings.clone
         @windows     = @windows.clone
       end
 
       def hash
         [
           @source, @top, @set_quantifier, @projections,
-          @wheres, @groups, @having, @windows
+          @wheres, @groups, @havings, @windows
         ].hash
       end
 
@@ -54,7 +54,7 @@ module Arel
           self.projections == other.projections &&
           self.wheres == other.wheres &&
           self.groups == other.groups &&
-          self.having == other.having &&
+          self.havings == other.havings &&
           self.windows == other.windows
       end
       alias :== :eql?

data/lib/arel/nodes/table_alias.rb

@@ -13,8 +13,12 @@ module Arel
         relation.respond_to?(:name) ? relation.name : name
       end
 
-      def engine
-        relation.engine
+      def type_cast_for_database(*args)
+        relation.type_cast_for_database(*args)
+      end
+
+      def able_to_type_cast?
+        relation.respond_to?(:able_to_type_cast?) && relation.able_to_type_cast?
       end
     end
   end

data/lib/arel/nodes/unary.rb

@@ -22,16 +22,19 @@ module Arel
 
     %w{
       Bin
+      Cube
+      DistinctOn
       Group
-      Having
+      GroupingElement
+      GroupingSet
       Limit
+      Lock
       Not
       Offset
       On
       Ordering
+      RollUp
       Top
-      Lock
-      DistinctOn
     }.each do |name|
       const_set(name, Class.new(Unary))
     end

data/lib/arel/nodes/unary_operation.rb

@@ -0,0 +1,25 @@
+module Arel
+  module Nodes
+
+    class UnaryOperation < Unary
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::OrderPredications
+      include Arel::AliasPredication
+      include Arel::Math
+
+      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/predications.rb

@@ -25,15 +25,15 @@ module Arel
     end
 
     def between other
-      if other.begin == -Float::INFINITY
-        if other.end == Float::INFINITY
+      if equals_quoted?(other.begin, -Float::INFINITY)
+        if equals_quoted?(other.end, Float::INFINITY)
           not_in([])
         elsif other.exclude_end?
           lt(other.end)
         else
           lteq(other.end)
         end
-      elsif other.end == Float::INFINITY
+      elsif equals_quoted?(other.end, Float::INFINITY)
         gteq(other.begin)
       elsif other.exclude_end?
         gteq(other.begin).and(lt(other.end))
@@ -71,15 +71,15 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
     end
 
     def not_between other
-      if other.begin == -Float::INFINITY # The range begins with negative infinity
-        if other.end == Float::INFINITY
+      if equals_quoted?(other.begin, -Float::INFINITY)
+        if equals_quoted?(other.end, Float::INFINITY)
           self.in([])
         elsif other.exclude_end?
           gteq(other.end)
         else
           gt(other.end)
         end
-      elsif other.end == Float::INFINITY
+      elsif equals_quoted?(other.end, Float::INFINITY)
         lt(other.begin)
       else
         left = lt(other.begin)
@@ -118,20 +118,28 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       grouping_all :not_in, others
     end
 
-    def matches other, escape = nil
-      Nodes::Matches.new self, quoted_node(other), escape
+    def matches other, escape = nil, case_sensitive = false
+      Nodes::Matches.new self, quoted_node(other), escape, case_sensitive
     end
 
-    def matches_any others, escape = nil
-      grouping_any :matches, others, escape
+    def matches_regexp other, case_sensitive = true
+      Nodes::Regexp.new self, quoted_node(other), case_sensitive
     end
 
-    def matches_all others, escape = nil
-      grouping_all :matches, others, escape
+    def matches_any others, escape = nil, case_sensitive = false
+      grouping_any :matches, others, escape, case_sensitive
     end
 
-    def does_not_match other, escape = nil
-      Nodes::DoesNotMatch.new self, quoted_node(other), escape
+    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
@@ -190,6 +198,14 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       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
@@ -211,5 +227,13 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
     def quoted_array(others)
       others.map { |v| quoted_node(v) }
     end
+
+    def equals_quoted?(maybe_quoted, value)
+      if maybe_quoted.is_a?(Nodes::Quoted)
+        maybe_quoted.val == value
+      else
+        maybe_quoted == value
+      end
+    end
   end
 end

data/lib/arel/select_manager.rb

@@ -6,8 +6,8 @@ module Arel
 
     STRING_OR_SYMBOL_CLASS = [Symbol, String]
 
-    def initialize engine, table = nil
-      super(engine)
+    def initialize table = nil
+      super()
       @ast   = Nodes::SelectStatement.new
       @ctx    = @ast.cores.last
       from table
@@ -118,8 +118,8 @@ module Arel
       join(relation, Nodes::OuterJoin)
     end
 
-    def having *exprs
-      @ctx.having = Nodes::Having.new(collapse(exprs, @ctx.having))
+    def having expr
+      @ctx.havings << expr
       self
     end
 
@@ -176,10 +176,10 @@ module Arel
       @ast.orders
     end
 
-    def where_sql
+    def where_sql engine = Table.engine
       return if @ctx.wheres.empty?
 
-      viz = Visitors::WhereSql.new @engine.connection
+      viz = Visitors::WhereSql.new(engine.connection.visitor, engine.connection)
       Nodes::SqlLiteral.new viz.accept(@ctx, Collectors::SQLString.new).value
     end