activerecord 6.0.3.4 → 6.1.0

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/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.rb

@@ -1,18 +1,11 @@
 # frozen_string_literal: true
 
 require "arel/visitors/visitor"
-require "arel/visitors/depth_first"
 require "arel/visitors/to_sql"
 require "arel/visitors/sqlite"
 require "arel/visitors/postgresql"
 require "arel/visitors/mysql"
-require "arel/visitors/mssql"
-require "arel/visitors/oracle"
-require "arel/visitors/oracle12"
-require "arel/visitors/where_sql"
 require "arel/visitors/dot"
-require "arel/visitors/ibm_db"
-require "arel/visitors/informix"
 
 module Arel # :nodoc: all
   module Visitors

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

data/lib/arel/visitors/to_sql.rb

@@ -82,12 +82,9 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_Casted(o, collector)
-          collector << quoted(o.val, o.attribute).to_s
-        end
-
-        def visit_Arel_Nodes_Quoted(o, collector)
-          collector << quoted(o.expr, nil).to_s
+          collector << quote(o.value_for_database).to_s
         end
+        alias :visit_Arel_Nodes_Quoted :visit_Arel_Nodes_Casted
 
         def visit_Arel_Nodes_True(o, collector)
           collector << "TRUE"
@@ -195,12 +192,12 @@ module Arel # :nodoc: all
 
         def visit_Arel_Nodes_With(o, collector)
           collector << "WITH "
-          inject_join o.children, collector, ", "
+          collect_ctes(o.children, collector)
         end
 
         def visit_Arel_Nodes_WithRecursive(o, collector)
           collector << "WITH RECURSIVE "
-          inject_join o.children, collector, ", "
+          collect_ctes(o.children, collector)
         end
 
         def visit_Arel_Nodes_Union(o, collector)
@@ -324,6 +321,29 @@ module Arel # :nodoc: all
           end
         end
 
+        def visit_Arel_Nodes_HomogeneousIn(o, collector)
+          collector.preparable = false
+
+          collector << quote_table_name(o.table_name) << "." << quote_column_name(o.column_name)
+
+          if o.type == :in
+            collector << " IN ("
+          else
+            collector << " NOT IN ("
+          end
+
+          values = o.casted_values
+
+          if values.empty?
+            collector << @connection.quote(nil)
+          else
+            collector.add_binds(values, &bind_block)
+          end
+
+          collector << ")"
+          collector
+        end
+
         def visit_Arel_SelectManager(o, collector)
           collector << "("
           visit(o.ast, collector) << ")"
@@ -513,64 +533,35 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_In(o, collector)
-          unless Array === o.right
-            return collect_in_clause(o.left, o.right, collector)
-          end
-
-          unless o.right.empty?
-            o.right.delete_if { |value| unboundable?(value) }
-          end
+          collector.preparable = false
+          attr, values = o.left, o.right
 
-          return collector << "1=0" if o.right.empty?
-
-          in_clause_length = @connection.in_clause_length
-
-          if !in_clause_length || o.right.length <= in_clause_length
-            collect_in_clause(o.left, o.right, collector)
-          else
-            collector << "("
-            o.right.each_slice(in_clause_length).each_with_index do |right, i|
-              collector << " OR " unless i == 0
-              collect_in_clause(o.left, right, collector)
+          if Array === values
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
             end
-            collector << ")"
+
+            return collector << "1=0" if values.empty?
           end
-        end
 
-        def collect_in_clause(left, right, collector)
-          collector = visit left, collector
-          collector << " IN ("
-          visit(right, collector) << ")"
+          visit(attr, collector) << " IN ("
+          visit(values, collector) << ")"
         end
 
         def visit_Arel_Nodes_NotIn(o, collector)
-          unless Array === o.right
-            return collect_not_in_clause(o.left, o.right, collector)
-          end
-
-          unless o.right.empty?
-            o.right.delete_if { |value| unboundable?(value) }
-          end
+          collector.preparable = false
+          attr, values = o.left, o.right
 
-          return collector << "1=1" if o.right.empty?
-
-          in_clause_length = @connection.in_clause_length
-
-          if !in_clause_length || o.right.length <= in_clause_length
-            collect_not_in_clause(o.left, o.right, collector)
-          else
-            o.right.each_slice(in_clause_length).each_with_index do |right, i|
-              collector << " AND " unless i == 0
-              collect_not_in_clause(o.left, right, collector)
+          if Array === values
+            unless values.empty?
+              values.delete_if { |value| unboundable?(value) }
             end
-            collector
+
+            return collector << "1=1" if values.empty?
           end
-        end
 
-        def collect_not_in_clause(left, right, collector)
-          collector = visit left, collector
-          collector << " NOT IN ("
-          visit(right, collector) << ")"
+          visit(attr, collector) << " NOT IN ("
+          visit(values, collector) << ")"
         end
 
         def visit_Arel_Nodes_And(o, collector)
@@ -578,9 +569,18 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_Or(o, collector)
-          collector = visit o.left, collector
-          collector << " OR "
-          visit o.right, collector
+          stack = [o.right, o.left]
+
+          while o = stack.pop
+            if o.is_a?(Arel::Nodes::Or)
+              stack.push o.right, o.left
+            else
+              visit o, collector
+              collector << " OR " unless stack.empty?
+            end
+          end
+
+          collector
         end
 
         def visit_Arel_Nodes_Assignment(o, collector)
@@ -689,28 +689,23 @@ module Arel # :nodoc: all
           join_name = o.relation.table_alias || o.relation.name
           collector << quote_table_name(join_name) << "." << quote_column_name(o.name)
         end
-        alias :visit_Arel_Attributes_Integer :visit_Arel_Attributes_Attribute
-        alias :visit_Arel_Attributes_Float :visit_Arel_Attributes_Attribute
-        alias :visit_Arel_Attributes_Decimal :visit_Arel_Attributes_Attribute
-        alias :visit_Arel_Attributes_String :visit_Arel_Attributes_Attribute
-        alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute
-        alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute
 
-        def literal(o, collector); collector << o.to_s; end
+        BIND_BLOCK = proc { "?" }
+        private_constant :BIND_BLOCK
+
+        def bind_block; BIND_BLOCK; end
 
         def visit_Arel_Nodes_BindParam(o, collector)
-          collector.add_bind(o.value) { "?" }
+          collector.add_bind(o.value, &bind_block)
         end
 
-        alias :visit_Arel_Nodes_SqlLiteral :literal
-        alias :visit_Integer               :literal
+        def visit_Arel_Nodes_SqlLiteral(o, collector)
+          collector.preparable = false
+          collector << o.to_s
+        end
 
-        def quoted(o, a)
-          if a && a.able_to_type_cast?
-            quote(a.type_cast_for_database(o))
-          else
-            quote(o)
-          end
+        def visit_Integer(o, collector)
+          collector << o.to_s
         end
 
         def unsupported(o, collector)
@@ -738,11 +733,6 @@ module Arel # :nodoc: all
           visit o.right, collector
         end
 
-        alias :visit_Arel_Nodes_Addition       :visit_Arel_Nodes_InfixOperation
-        alias :visit_Arel_Nodes_Subtraction    :visit_Arel_Nodes_InfixOperation
-        alias :visit_Arel_Nodes_Multiplication :visit_Arel_Nodes_InfixOperation
-        alias :visit_Arel_Nodes_Division       :visit_Arel_Nodes_InfixOperation
-
         def visit_Arel_Nodes_UnaryOperation(o, collector)
           collector << " #{o.operator} "
           visit o.expr, collector
@@ -883,6 +873,27 @@ module Arel # :nodoc: all
           collector << " IS NULL)"
           collector << " THEN 0 ELSE 1 END"
         end
+
+        def collect_ctes(children, collector)
+          children.each_with_index do |child, i|
+            collector << ", " unless i == 0
+
+            case child
+            when Arel::Nodes::As
+              name = child.left.name
+              relation = child.right
+            when Arel::Nodes::TableAlias
+              name = child.name
+              relation = child.relation
+            end
+
+            collector << quote_table_name(name)
+            collector << " AS "
+            visit relation, collector
+          end
+
+          collector
+        end
     end
   end
 end