activerecord 6.0.5.1 → 6.1.0.rc1

data/lib/arel/nodes/casted.rb

@@ -3,30 +3,42 @@
 module Arel # :nodoc: all
   module Nodes
     class Casted < Arel::Nodes::NodeExpression # :nodoc:
-      attr_reader :val, :attribute
-      def initialize(val, attribute)
-        @val       = val
+      attr_reader :value, :attribute
+      alias :value_before_type_cast :value
+
+      def initialize(value, attribute)
+        @value     = value
         @attribute = attribute
         super()
       end
 
-      def nil?; @val.nil?; end
+      def nil?; value.nil?; end
+
+      def value_for_database
+        if attribute.able_to_type_cast?
+          attribute.type_cast_for_database(value)
+        else
+          value
+        end
+      end
 
       def hash
-        [self.class, val, attribute].hash
+        [self.class, value, attribute].hash
       end
 
       def eql?(other)
         self.class == other.class &&
-            self.val == other.val &&
-            self.attribute == other.attribute
+          self.value == other.value &&
+          self.attribute == other.attribute
       end
       alias :== :eql?
     end
 
     class Quoted < Arel::Nodes::Unary # :nodoc:
-      alias :val :value
-      def nil?; val.nil?; end
+      alias :value_for_database :value
+      alias :value_before_type_cast :value
+
+      def nil?; value.nil?; end
 
       def infinite?
         value.respond_to?(:infinite?) && value.infinite?

data/lib/arel/nodes/equality.rb

@@ -3,16 +3,13 @@
 module Arel # :nodoc: all
   module Nodes
     class Equality < Arel::Nodes::Binary
-      def operator; :== end
-      alias :operand1 :left
-      alias :operand2 :right
-    end
+      include FetchAttribute
+
+      def equality?; true; end
 
-    %w{
-      IsDistinctFrom
-      IsNotDistinctFrom
-    }.each do |name|
-      const_set name, Class.new(Equality)
+      def invert
+        Arel::Nodes::NotEqual.new(left, right)
+      end
     end
   end
 end

data/lib/arel/nodes/grouping.rb

@@ -3,6 +3,9 @@
 module Arel # :nodoc: all
   module Nodes
     class Grouping < Unary
+      def fetch_attribute(&block)
+        expr.fetch_attribute(&block)
+      end
     end
   end
 end

data/lib/arel/nodes/homogeneous_in.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class HomogeneousIn < Node
+      attr_reader :attribute, :values, :type
+
+      def initialize(values, attribute, type)
+        @values = values
+        @attribute = attribute
+        @type = type
+      end
+
+      def hash
+        ivars.hash
+      end
+
+      def eql?(other)
+        super || (self.class == other.class && self.ivars == other.ivars)
+      end
+      alias :== :eql?
+
+      def equality?
+        type == :in
+      end
+
+      def invert
+        Arel::Nodes::HomogeneousIn.new(values, attribute, type == :in ? :notin : :in)
+      end
+
+      def left
+        attribute
+      end
+
+      def right
+        attribute.quoted_array(values)
+      end
+
+      def table_name
+        attribute.relation.table_alias || attribute.relation.name
+      end
+
+      def column_name
+        attribute.name
+      end
+
+      def casted_values
+        type = attribute.type_caster
+
+        casted_values = values.map do |raw_value|
+          type.serialize(raw_value) if type.serializable?(raw_value)
+        end
+
+        casted_values.compact!
+        casted_values
+      end
+
+      def fetch_attribute(&block)
+        if attribute
+          yield attribute
+        else
+          expr.fetch_attribute(&block)
+        end
+      end
+
+      protected
+        def ivars
+          [@attribute, @values, @type]
+        end
+    end
+  end
+end

data/lib/arel/nodes/in.rb

@@ -2,7 +2,14 @@
 
 module Arel # :nodoc: all
   module Nodes
-    class In < Equality
+    class In < Arel::Nodes::Binary
+      include FetchAttribute
+
+      def equality?; true; end
+
+      def invert
+        Arel::Nodes::NotIn.new(left, right)
+      end
     end
   end
 end

data/lib/arel/nodes/infix_operation.rb

@@ -43,7 +43,19 @@ module Arel # :nodoc: all
 
     class Concat < InfixOperation
       def initialize(left, right)
-        super("||", 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
 

data/lib/arel/nodes/join_source.rb

@@ -5,7 +5,7 @@ module Arel # :nodoc: all
     ###
     # Class that represents a join source
     #
-    #   http://www.sqlite.org/syntaxdiagrams.html#join-source
+    #   https://www.sqlite.org/syntaxdiagrams.html#join-source
 
     class JoinSource < Arel::Nodes::Binary
       def initialize(single_source, joinop = [])

data/lib/arel/nodes/node.rb

@@ -6,7 +6,6 @@ module Arel # :nodoc: all
     # 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
@@ -28,6 +27,10 @@ module Arel # :nodoc: all
         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.
@@ -39,12 +42,10 @@ module Arel # :nodoc: all
         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
+      def fetch_attribute
       end
+
+      def equality?; false; end
     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/sql_literal.rb

@@ -11,6 +11,9 @@ module Arel # :nodoc: all
       def encode_with(coder)
         coder.scalar = self.to_s
       end
+
+      def fetch_attribute
+      end
     end
   end
 end

data/lib/arel/nodes/table_alias.rb

@@ -8,15 +8,19 @@ module Arel # :nodoc: all
       alias :table_alias :name
 
       def [](name)
-        Attribute.new(self, 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(*args)
-        relation.type_cast_for_database(*args)
+      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?

data/lib/arel/nodes/unary.rb

@@ -36,7 +36,6 @@ module Arel # :nodoc: all
       Offset
       On
       OptimizerHints
-      Ordering
       RollUp
     }.each do |name|
       const_set(name, Class.new(Unary))

data/lib/arel/nodes.rb

@@ -18,6 +18,8 @@ require "arel/nodes/false"
 # unary
 require "arel/nodes/unary"
 require "arel/nodes/grouping"
+require "arel/nodes/homogeneous_in"
+require "arel/nodes/ordering"
 require "arel/nodes/ascending"
 require "arel/nodes/descending"
 require "arel/nodes/unqualified_column"
@@ -26,7 +28,7 @@ require "arel/nodes/with"
 # binary
 require "arel/nodes/binary"
 require "arel/nodes/equality"
-require "arel/nodes/in" # Why is this subclassed from equality?
+require "arel/nodes/in"
 require "arel/nodes/join_source"
 require "arel/nodes/delete_statement"
 require "arel/nodes/table_alias"

data/lib/arel/predications.rb

@@ -60,13 +60,6 @@ module Arel # :nodoc: all
       case other
       when Arel::SelectManager
         Arel::Nodes::In.new(self, other.ast)
-      when Range
-        if $VERBOSE
-          warn <<-eowarn
-Passing a range to `#in` is deprecated. Call `#between`, instead.
-          eowarn
-        end
-        between(other)
       when Enumerable
         Nodes::In.new self, quoted_array(other)
       else
@@ -110,13 +103,6 @@ Passing a range to `#in` is deprecated. Call `#between`, instead.
       case other
       when Arel::SelectManager
         Arel::Nodes::NotIn.new(self, other.ast)
-      when Range
-        if $VERBOSE
-          warn <<-eowarn
-Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
-          eowarn
-        end
-        not_between(other)
       when Enumerable
         Nodes::NotIn.new self, quoted_array(other)
       else
@@ -220,6 +206,18 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       Nodes::Concat.new self, other
     end
 
+    def contains(other)
+      Arel::Nodes::Contains.new(self, other)
+    end
+
+    def overlaps(other)
+      Arel::Nodes::Overlaps.new(self, other)
+    end
+
+    def quoted_array(others)
+      others.map { |v| quoted_node(v) }
+    end
+
     private
       def grouping_any(method_id, others, *extras)
         nodes = others.map { |expr| send(method_id, expr, *extras) }
@@ -237,10 +235,6 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
         Nodes.build_quoted(other, self)
       end
 
-      def quoted_array(others)
-        others.map { |v| quoted_node(v) }
-      end
-
       def infinity?(value)
         value.respond_to?(:infinite?) && value.infinite?
       end

data/lib/arel/select_manager.rb

@@ -186,8 +186,7 @@ module Arel # :nodoc: all
     def where_sql(engine = Table.engine)
       return if @ctx.wheres.empty?
 
-      viz = Visitors::WhereSql.new(engine.connection.visitor, engine.connection)
-      Nodes::SqlLiteral.new viz.accept(@ctx, Collectors::SQLString.new).value
+      Nodes::SqlLiteral.new("WHERE #{Nodes::And.new(@ctx.wheres).to_sql(engine)}")
     end
 
     def union(operation, other = nil)

data/lib/arel/table.rb

@@ -4,6 +4,7 @@ module Arel # :nodoc: all
   class Table
     include Arel::Crud
     include Arel::FactoryMethods
+    include Arel::AliasPredication
 
     @engine = nil
     class << self; attr_accessor :engine; end
@@ -13,8 +14,9 @@ module Arel # :nodoc: all
     # 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, type_caster: nil)
+    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
@@ -78,8 +80,10 @@ module Arel # :nodoc: all
       from.having expr
     end
 
-    def [](name)
-      ::Arel::Attribute.new self, name
+    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
@@ -96,8 +100,12 @@ module Arel # :nodoc: all
     end
     alias :== :eql?
 
-    def type_cast_for_database(attribute_name, value)
-      type_caster.type_cast_for_database(attribute_name, value)
+    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?

data/lib/arel/visitors/dot.rb

@@ -157,7 +157,13 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_Casted(o)
-          visit_edge o, "val"
+          visit_edge o, "value"
+          visit_edge o, "attribute"
+        end
+
+        def visit_Arel_Nodes_HomogeneousIn(o)
+          visit_edge o, "values"
+          visit_edge o, "type"
           visit_edge o, "attribute"
         end
 
@@ -218,7 +224,13 @@ module Arel # :nodoc: all
         alias :visit_Symbol :visit_String
         alias :visit_Arel_Nodes_SqlLiteral :visit_String
 
-        def visit_Arel_Nodes_BindParam(o); end
+        def visit_Arel_Nodes_BindParam(o)
+          edge("value") { visit o.value }
+        end
+
+        def visit_ActiveModel_Attribute(o)
+          edge("value_before_type_cast") { visit o.value_before_type_cast }
+        end
 
         def visit_Hash(o)
           o.each_with_index do |pair, i|

data/lib/arel/visitors/mysql.rb

@@ -15,7 +15,9 @@ module Arel # :nodoc: all
 
         ###
         # :'(
-        # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
+        # To retrieve all rows from a certain offset up to the end of the result set,
+        # you can use some large number for the second parameter.
+        # https://dev.mysql.com/doc/refman/en/select.html
         def visit_Arel_Nodes_SelectStatement(o, collector)
           if o.offset && !o.limit
             o.limit = Arel::Nodes::Limit.new(18446744073709551615)
@@ -48,6 +50,14 @@ module Arel # :nodoc: all
           visit_Arel_Nodes_IsNotDistinctFrom o, collector
         end
 
+        def visit_Arel_Nodes_Regexp(o, collector)
+          infix_value o, collector, " REGEXP "
+        end
+
+        def visit_Arel_Nodes_NotRegexp(o, collector)
+          infix_value o, collector, " NOT REGEXP "
+        end
+
         # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
         # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
         # these, we must use a subquery.

data/lib/arel/visitors/postgresql.rb

@@ -41,10 +41,6 @@ module Arel # :nodoc: all
           visit(o.expr, collector) << " )"
         end
 
-        def visit_Arel_Nodes_BindParam(o, collector)
-          collector.add_bind(o.value) { |i| "$#{i}" }
-        end
-
         def visit_Arel_Nodes_GroupingElement(o, collector)
           collector << "( "
           visit(o.expr, collector) << " )"
@@ -82,6 +78,21 @@ module Arel # :nodoc: all
           visit o.right, collector
         end
 
+        def visit_Arel_Nodes_NullsFirst(o, collector)
+          visit o.expr, collector
+          collector << " NULLS FIRST"
+        end
+
+        def visit_Arel_Nodes_NullsLast(o, collector)
+          visit o.expr, collector
+          collector << " NULLS LAST"
+        end
+
+        BIND_BLOCK = proc { |i| "$#{i}" }
+        private_constant :BIND_BLOCK
+
+        def bind_block; BIND_BLOCK; end
+
         # Used by Lateral visitor to enclose select queries in parentheses
         def grouping_parentheses(o, collector)
           if o.expr.is_a? Nodes::SelectStatement