activerecord 5.1.7 → 5.2.8.1

data/lib/active_record/relation/merger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash/keys"
 
 module ActiveRecord
@@ -21,7 +23,11 @@ module ActiveRecord
       # build a relation to merge in rather than directly merging
       # the values.
       def other
-        other = Relation.create(relation.klass, relation.table, relation.predicate_builder)
+        other = Relation.create(
+          relation.klass,
+          table: relation.table,
+          predicate_builder: relation.predicate_builder
+        )
         hash.each { |k, v|
           if k == :joins
             if Hash === v
@@ -50,7 +56,7 @@ module ActiveRecord
 
       NORMAL_VALUES = Relation::VALUE_METHODS -
                       Relation::CLAUSE_METHODS -
-                      [:includes, :preload, :joins, :order, :reverse_order, :lock, :create_with, :reordering] # :nodoc:
+                      [:includes, :preload, :joins, :left_outer_joins, :order, :reverse_order, :lock, :create_with, :reordering] # :nodoc:
 
       def normal_values
         NORMAL_VALUES
@@ -77,6 +83,7 @@ module ActiveRecord
         merge_clauses
         merge_preloads
         merge_joins
+        merge_outer_joins
 
         relation
       end
@@ -110,41 +117,57 @@ module ActiveRecord
           if other.klass == relation.klass
             relation.joins!(*other.joins_values)
           else
-            joins_dependency, rest = other.joins_values.partition do |join|
+            joins_dependency = other.joins_values.map do |join|
               case join
               when Hash, Symbol, Array
-                true
+                ActiveRecord::Associations::JoinDependency.new(
+                  other.klass, other.table, join
+                )
               else
-                false
+                join
               end
             end
 
-            join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
-                                                                             joins_dependency,
-                                                                             [])
-            relation.joins! rest
+            relation.joins!(*joins_dependency)
+          end
+        end
+
+        def merge_outer_joins
+          return if other.left_outer_joins_values.blank?
+
+          if other.klass == relation.klass
+            relation.left_outer_joins!(*other.left_outer_joins_values)
+          else
+            joins_dependency = other.left_outer_joins_values.map do |join|
+              case join
+              when Hash, Symbol, Array
+                ActiveRecord::Associations::JoinDependency.new(
+                  other.klass, other.table, join
+                )
+              else
+                join
+              end
+            end
 
-            @relation = relation.joins join_dependency
+            relation.left_outer_joins!(*joins_dependency)
           end
         end
 
         def merge_multi_values
           if other.reordering_value
             # override any order specified in the original relation
-            relation.reorder! other.order_values
-          elsif other.order_values
+            relation.reorder!(*other.order_values)
+          elsif other.order_values.any?
             # merge in order_values from relation
-            relation.order! other.order_values
+            relation.order!(*other.order_values)
           end
 
-          relation.extend(*other.extending_values) unless other.extending_values.blank?
+          extensions = other.extensions - relation.extensions
+          relation.extending!(*extensions) if extensions.any?
         end
 
         def merge_single_values
-          if relation.from_clause.empty?
-            relation.from_clause = other.from_clause
-          end
-          relation.lock_value ||= other.lock_value
+          relation.lock_value ||= other.lock_value if other.lock_value
 
           unless other.create_with_value.blank?
             relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
@@ -152,11 +175,18 @@ module ActiveRecord
         end
 
         def merge_clauses
-          CLAUSE_METHODS.each do |method|
-            clause = relation.get_value(method)
-            other_clause = other.get_value(method)
-            relation.set_value(method, clause.merge(other_clause))
-          end
+          relation.from_clause = other.from_clause if replace_from_clause?
+
+          where_clause = relation.where_clause.merge(other.where_clause)
+          relation.where_clause = where_clause unless where_clause.empty?
+
+          having_clause = relation.having_clause.merge(other.having_clause)
+          relation.having_clause = having_clause unless having_clause.empty?
+        end
+
+        def replace_from_clause?
+          relation.from_clause.empty? && !other.from_clause.empty? &&
+            relation.klass.base_class == other.klass.base_class
         end
     end
   end

data/lib/active_record/relation/predicate_builder/array_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
@@ -6,18 +8,21 @@ module ActiveRecord
       end
 
       def call(attribute, value)
+        return attribute.in([]) if value.empty?
+
         values = value.map { |x| x.is_a?(Base) ? x.id : x }
         nils, values = values.partition(&:nil?)
-
-        return attribute.in([]) if values.empty? && nils.empty?
-
         ranges, values = values.partition { |v| v.is_a?(Range) }
 
         values_predicate =
           case values.length
           when 0 then NullPredicate
           when 1 then predicate_builder.build(attribute, values.first)
-          else attribute.in(values)
+          else
+            values.map! do |v|
+              predicate_builder.build_bind_attribute(attribute.name, v)
+            end
+            values.empty? ? NullPredicate : attribute.in(values)
           end
 
         unless nils.empty?
@@ -26,11 +31,9 @@ module ActiveRecord
 
         array_predicates = ranges.map { |range| predicate_builder.build(attribute, range) }
         array_predicates.unshift(values_predicate)
-        array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        array_predicates.inject(&:or)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
         attr_reader :predicate_builder

data/lib/active_record/relation/predicate_builder/association_query_value.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class AssociationQueryValue # :nodoc:
+      def initialize(associated_table, value)
+        @associated_table = associated_table
+        @value = value
+      end
+
+      def queries
+        [associated_table.association_join_foreign_key.to_s => ids]
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+        attr_reader :associated_table, :value
+
+      private
+        def ids
+          case value
+          when Relation
+            value.select_values.empty? ? value.select(primary_key) : value
+          when Array
+            value.map { |v| convert_to_id(v) }
+          else
+            convert_to_id(value)
+          end
+        end
+
+        def primary_key
+          associated_table.association_join_primary_key
+        end
+
+        def convert_to_id(value)
+          case value
+          when Base
+            value._read_attribute(primary_key)
+          else
+            value
+          end
+        end
+    end
+  end
+end

data/lib/active_record/relation/predicate_builder/base_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class BaseHandler # :nodoc:
@@ -9,8 +11,6 @@ module ActiveRecord
         predicate_builder.build(attribute, value.id)
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
         attr_reader :predicate_builder

data/lib/active_record/relation/predicate_builder/basic_object_handler.rb

@@ -1,9 +1,20 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class BasicObjectHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
       def call(attribute, value)
-        attribute.eq(value)
+        bind = predicate_builder.build_bind_attribute(attribute.name, value)
+        attribute.eq(bind)
       end
+
+      protected
+
+        attr_reader :predicate_builder
     end
   end
 end

data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class PolymorphicArrayValue # :nodoc:
+      def initialize(associated_table, values)
+        @associated_table = associated_table
+        @values = values
+      end
+
+      def queries
+        type_to_ids_mapping.map do |type, ids|
+          {
+            associated_table.association_foreign_type.to_s => type,
+            associated_table.association_foreign_key.to_s => ids
+          }
+        end
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+        attr_reader :associated_table, :values
+
+      private
+        def type_to_ids_mapping
+          default_hash = Hash.new { |hsh, key| hsh[key] = [] }
+          values.each_with_object(default_hash) do |value, hash|
+            hash[klass(value).polymorphic_name] << convert_to_id(value)
+          end
+        end
+
+        def primary_key(value)
+          associated_table.association_join_primary_key(klass(value))
+        end
+
+        def klass(value)
+          case value
+          when Base
+            value.class
+          when Relation
+            value.klass
+          end
+        end
+
+        def convert_to_id(value)
+          case value
+          when Base
+            value._read_attribute(primary_key(value))
+          when Relation
+            value.select(primary_key(value))
+          end
+        end
+    end
+  end
+end

data/lib/active_record/relation/predicate_builder/range_handler.rb

@@ -1,25 +1,42 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class RangeHandler # :nodoc:
-      RangeWithBinds = Struct.new(:begin, :end, :exclude_end?)
+      class RangeWithBinds < Struct.new(:begin, :end)
+        def exclude_end?
+          false
+        end
+      end
+
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
 
       def call(attribute, value)
-        if value.begin.respond_to?(:infinite?) && value.begin.infinite?
-          if value.end.respond_to?(:infinite?) && value.end.infinite?
+        begin_bind = predicate_builder.build_bind_attribute(attribute.name, value.begin)
+        end_bind = predicate_builder.build_bind_attribute(attribute.name, value.end)
+
+        if begin_bind.value.infinity?
+          if end_bind.value.infinity?
             attribute.not_in([])
           elsif value.exclude_end?
-            attribute.lt(value.end)
+            attribute.lt(end_bind)
           else
-            attribute.lteq(value.end)
+            attribute.lteq(end_bind)
           end
-        elsif value.end.respond_to?(:infinite?) && value.end.infinite?
-          attribute.gteq(value.begin)
+        elsif end_bind.value.infinity?
+          attribute.gteq(begin_bind)
         elsif value.exclude_end?
-          attribute.gteq(value.begin).and(attribute.lt(value.end))
+          attribute.gteq(begin_bind).and(attribute.lt(end_bind))
         else
-          attribute.between(value)
+          attribute.between(RangeWithBinds.new(begin_bind, end_bind))
         end
       end
+
+      protected
+
+        attr_reader :predicate_builder
     end
   end
 end

data/lib/active_record/relation/predicate_builder/relation_handler.rb

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder
     class RelationHandler # :nodoc:
       def call(attribute, value)
+        if value.eager_loading?
+          value = value.send(:apply_join_dependency)
+        end
+
         if value.select_values.empty?
           value = value.select(value.arel_attribute(value.klass.primary_key))
         end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,27 +1,19 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    require "active_record/relation/predicate_builder/array_handler"
-    require "active_record/relation/predicate_builder/association_query_handler"
-    require "active_record/relation/predicate_builder/base_handler"
-    require "active_record/relation/predicate_builder/basic_object_handler"
-    require "active_record/relation/predicate_builder/polymorphic_array_handler"
-    require "active_record/relation/predicate_builder/range_handler"
-    require "active_record/relation/predicate_builder/relation_handler"
-
     delegate :resolve_column_aliases, to: :table
 
     def initialize(table)
       @table = table
       @handlers = []
 
-      register_handler(BasicObject, BasicObjectHandler.new)
+      register_handler(BasicObject, BasicObjectHandler.new(self))
       register_handler(Base, BaseHandler.new(self))
-      register_handler(Range, RangeHandler.new)
-      register_handler(RangeHandler::RangeWithBinds, RangeHandler.new)
+      register_handler(Range, RangeHandler.new(self))
       register_handler(Relation, RelationHandler.new)
       register_handler(Array, ArrayHandler.new(self))
-      register_handler(AssociationQueryValue, AssociationQueryHandler.new(self))
-      register_handler(PolymorphicArrayValue, PolymorphicArrayHandler.new(self))
+      register_handler(Set, ArrayHandler.new(self))
     end
 
     def build_from_hash(attributes)
@@ -29,11 +21,6 @@ module ActiveRecord
       expand_from_hash(attributes)
     end
 
-    def create_binds(attributes)
-      attributes = convert_dot_notation_to_hash(attributes)
-      create_binds_for_hash(attributes)
-    end
-
     def self.references(attributes)
       attributes.map do |key, value|
         if value.is_a?(Hash)
@@ -61,11 +48,19 @@ module ActiveRecord
     end
 
     def build(attribute, value)
-      handler_for(value).call(attribute, value)
+      if table.type(attribute.name).force_equality?(value)
+        bind = build_bind_attribute(attribute.name, value)
+        attribute.eq(bind)
+      else
+        handler_for(value).call(attribute, value)
+      end
+    end
+
+    def build_bind_attribute(column_name, value)
+      attr = Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
+      Arel::Nodes::BindParam.new(attr)
     end
 
-    # TODO Change this to private once we've dropped Ruby 2.2 support.
-    # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
       attr_reader :table
@@ -76,56 +71,47 @@ module ActiveRecord
         attributes.flat_map do |key, value|
           if value.is_a?(Hash) && !table.has_column?(key)
             associated_predicate_builder(key).expand_from_hash(value)
-          else
-            build(table.arel_attribute(key), value)
-          end
-        end
-      end
+          elsif table.associated_with?(key)
+            # Find the foreign key when using queries such as:
+            # Post.where(author: author)
+            #
+            # For polymorphic relationships, find the foreign key and type:
+            # PriceEstimate.where(estimate_of: treasure)
+            associated_table = table.associated_table(key)
+            if associated_table.polymorphic_association?
+              case value.is_a?(Array) ? value.first : value
+              when Base, Relation
+                value = [value] unless value.is_a?(Array)
+                klass = PolymorphicArrayValue
+              end
+            end
 
-      def create_binds_for_hash(attributes)
-        result = attributes.dup
-        binds = []
-
-        attributes.each do |column_name, value|
-          case
-          when value.is_a?(Hash) && !table.has_column?(column_name)
-            attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
-            result[column_name] = attrs
-            binds += bvs
-            next
-          when value.is_a?(Relation)
-            binds += value.bound_attributes
-          when value.is_a?(Range) && !table.type(column_name).force_equality?(value)
-            first = value.begin
-            last = value.end
-            unless first.respond_to?(:infinite?) && first.infinite?
-              binds << build_bind_param(column_name, first)
-              first = Arel::Nodes::BindParam.new
+            klass ||= AssociationQueryValue
+            queries = klass.new(associated_table, value).queries.map do |query|
+              expand_from_hash(query).reduce(&:and)
             end
-            unless last.respond_to?(:infinite?) && last.infinite?
-              binds << build_bind_param(column_name, last)
-              last = Arel::Nodes::BindParam.new
+            queries.reduce(&:or)
+          elsif table.aggregated_with?(key)
+            mapping = table.reflect_on_aggregation(key).mapping
+            values = value.nil? ? [nil] : Array.wrap(value)
+            if mapping.length == 1 || values.empty?
+              column_name, aggr_attr = mapping.first
+              values = values.map do |object|
+                object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+              end
+              build(table.arel_attribute(column_name), values)
+            else
+              queries = values.map do |object|
+                mapping.map do |field_attr, aggregate_attr|
+                  build(table.arel_attribute(field_attr), object.try!(aggregate_attr))
+                end.reduce(&:and)
+              end
+              queries.reduce(&:or)
             end
-
-            result[column_name] = RangeHandler::RangeWithBinds.new(first, last, value.exclude_end?)
           else
-            if can_be_bound?(column_name, value)
-              result[column_name] = Arel::Nodes::BindParam.new
-              binds << build_bind_param(column_name, value)
-            end
-          end
-
-          # Find the foreign key when using queries such as:
-          # Post.where(author: author)
-          #
-          # For polymorphic relationships, find the foreign key and type:
-          # PriceEstimate.where(estimate_of: treasure)
-          if table.associated_with?(column_name)
-            result[column_name] = AssociationQueryHandler.value_for(table, column_name, value)
+            build(table.arel_attribute(key), value)
           end
         end
-
-        [result, binds]
       end
 
     private
@@ -153,19 +139,14 @@ module ActiveRecord
       def handler_for(object)
         @handlers.detect { |klass, _| klass === object }.last
       end
-
-      def can_be_bound?(column_name, value)
-        return if table.associated_with?(column_name)
-        case value
-        when Array, Range
-          table.type(column_name).force_equality?(value)
-        else
-          !value.nil? && handler_for(value).is_a?(BasicObjectHandler)
-        end
-      end
-
-      def build_bind_param(column_name, value)
-        Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
-      end
   end
 end
+
+require "active_record/relation/predicate_builder/array_handler"
+require "active_record/relation/predicate_builder/base_handler"
+require "active_record/relation/predicate_builder/basic_object_handler"
+require "active_record/relation/predicate_builder/range_handler"
+require "active_record/relation/predicate_builder/relation_handler"
+
+require "active_record/relation/predicate_builder/association_query_value"
+require "active_record/relation/predicate_builder/polymorphic_array_value"

data/lib/active_record/relation/query_attribute.rb

@@ -1,8 +1,10 @@
-require "active_record/attribute"
+# frozen_string_literal: true
+
+require "active_model/attribute"
 
 module ActiveRecord
   class Relation
-    class QueryAttribute < Attribute # :nodoc:
+    class QueryAttribute < ActiveModel::Attribute # :nodoc:
       def type_cast(value)
         value
       end
@@ -14,6 +16,30 @@ module ActiveRecord
       def with_cast_value(value)
         QueryAttribute.new(name, value, type)
       end
+
+      def nil?
+        unless value_before_type_cast.is_a?(StatementCache::Substitute)
+          value_before_type_cast.nil? ||
+            type.respond_to?(:subtype, true) && value_for_database.nil?
+        end
+      end
+
+      def boundable?
+        return @_boundable if defined?(@_boundable)
+        value_for_database unless value_before_type_cast.is_a?(StatementCache::Substitute)
+        @_boundable = true
+      rescue ::RangeError
+        @_boundable = false
+      end
+
+      def infinity?
+        _infinity?(value_before_type_cast) || boundable? && _infinity?(value_for_database)
+      end
+
+      private
+        def _infinity?(value)
+          value.respond_to?(:infinite?) && value.infinite?
+        end
     end
   end
 end