activerecord 5.0.7.2 → 6.0.3.4

data/lib/active_record/relation/from_clause.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Relation
     class FromClause # :nodoc:
@@ -8,14 +10,6 @@ module ActiveRecord
         @name = name
       end
 
-      def binds
-        if value.is_a?(Relation)
-          value.bound_attributes
-        else
-          []
-        end
-      end
-
       def merge(other)
         self
       end
@@ -24,6 +18,10 @@ module ActiveRecord
         value.nil?
       end
 
+      def ==(other)
+        self.class == other.class && value == other.value && name == other.name
+      end
+
       def self.empty
         @empty ||= new(nil, nil)
       end

data/lib/active_record/relation/merger.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/hash/keys'
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
 
 module ActiveRecord
   class Relation
@@ -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,91 +83,101 @@ module ActiveRecord
         merge_clauses
         merge_preloads
         merge_joins
+        merge_outer_joins
 
         relation
       end
 
       private
+        def merge_preloads
+          return if other.preload_values.empty? && other.includes_values.empty?
 
-      def merge_preloads
-        return if other.preload_values.empty? && other.includes_values.empty?
-
-        if other.klass == relation.klass
-          relation.preload!(*other.preload_values) unless other.preload_values.empty?
-          relation.includes!(other.includes_values) unless other.includes_values.empty?
-        else
-          reflection = relation.klass.reflect_on_all_associations.find do |r|
-            r.class_name == other.klass.name
-          end || return
+          if other.klass == relation.klass
+            relation.preload!(*other.preload_values) unless other.preload_values.empty?
+            relation.includes!(other.includes_values) unless other.includes_values.empty?
+          else
+            reflection = relation.klass.reflect_on_all_associations.find do |r|
+              r.class_name == other.klass.name
+            end || return
 
-          unless other.preload_values.empty?
-            relation.preload! reflection.name => other.preload_values
-          end
+            unless other.preload_values.empty?
+              relation.preload! reflection.name => other.preload_values
+            end
 
-          unless other.includes_values.empty?
-            relation.includes! reflection.name => other.includes_values
+            unless other.includes_values.empty?
+              relation.includes! reflection.name => other.includes_values
+            end
           end
         end
-      end
 
-      def merge_joins
-        return if other.joins_values.blank?
+        def merge_joins
+          return if other.joins_values.blank?
 
-        if other.klass == relation.klass
-          relation.joins!(*other.joins_values)
-        else
-          joins_dependency, rest = other.joins_values.partition do |join|
-            case join
-            when Hash, Symbol, Array
-              true
-            else
-              false
+          if other.klass == relation.klass
+            relation.joins!(*other.joins_values)
+          else
+            associations, others = other.joins_values.partition do |join|
+              case join
+              when Hash, Symbol, Array; true
+              end
             end
+
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::InnerJoin
+            )
+            relation.joins!(join_dependency, *others)
           end
+        end
 
-          join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
-                                                                           joins_dependency,
-                                                                           [])
-          relation.joins! rest
+        def merge_outer_joins
+          return if other.left_outer_joins_values.blank?
 
-          @relation = relation.joins join_dependency
+          if other.klass == relation.klass
+            relation.left_outer_joins!(*other.left_outer_joins_values)
+          else
+            associations = other.left_outer_joins_values
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.joins!(join_dependency)
+          end
         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
-          # merge in order_values from relation
-          relation.order! other.order_values
+        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.any?
+            # merge in order_values from relation
+            relation.order!(*other.order_values)
+          end
+
+          extensions = other.extensions - relation.extensions
+          relation.extending!(*extensions) if extensions.any?
         end
 
-        relation.extend(*other.extending_values) unless other.extending_values.blank?
-      end
+        def merge_single_values
+          relation.lock_value ||= other.lock_value if other.lock_value
 
-      def merge_single_values
-        if relation.from_clause.empty?
-          relation.from_clause = other.from_clause
+          unless other.create_with_value.blank?
+            relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
+          end
         end
-        relation.lock_value ||= other.lock_value
 
-        unless other.create_with_value.blank?
-          relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
-        end
-      end
+        def merge_clauses
+          relation.from_clause = other.from_clause if replace_from_clause?
 
-      CLAUSE_METHOD_NAMES = CLAUSE_METHODS.map do |name|
-        ["#{name}_clause", "#{name}_clause="]
-      end
+          where_clause = relation.where_clause.merge(other.where_clause)
+          relation.where_clause = where_clause unless where_clause.empty?
 
-      def merge_clauses
-        CLAUSE_METHOD_NAMES.each do |(reader, writer)|
-          clause = relation.send(reader)
-          other_clause = other.send(reader)
-          relation.send(writer, clause.merge(other_clause))
+          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
   end
 end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,14 +1,7 @@
+# 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/class_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)
@@ -16,14 +9,11 @@ module ActiveRecord
       @handlers = []
 
       register_handler(BasicObject, BasicObjectHandler.new(self))
-      register_handler(Class, ClassHandler.new(self))
       register_handler(Base, BaseHandler.new(self))
       register_handler(Range, RangeHandler.new(self))
-      register_handler(RangeHandler::RangeWithBinds, 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)
@@ -31,28 +21,13 @@ 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 expand(column, value)
-      # 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)
-      value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
-      build(table.arel_attribute(column), value)
-    end
-
     def self.references(attributes)
       attributes.map do |key, value|
         if value.is_a?(Hash)
           key
         else
           key = key.to_s
-          key.split('.'.freeze).first if key.include?('.'.freeze)
+          key.split(".").first if key.include?(".")
         end
       end.compact
     end
@@ -73,96 +48,99 @@ module ActiveRecord
     end
 
     def build(attribute, value)
-      handler_for(value).call(attribute, value)
-    end
-
-    protected
-
-    attr_reader :table
-
-    def expand_from_hash(attributes)
-      return ["1=0"] if attributes.empty?
-
-      attributes.flat_map do |key, value|
-        if value.is_a?(Hash)
-          associated_predicate_builder(key).expand_from_hash(value)
-        else
-          expand(key, value)
-        end
+      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
 
-    def create_binds_for_hash(attributes)
-      result = attributes.dup
-      binds = []
-
-      attributes.each do |column_name, value|
-        case value
-        when Hash
-          attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
-          result[column_name] = attrs
-          binds += bvs
-        when Relation
-          binds += value.bound_attributes
-        when Range
-          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
-          end
-          unless last.respond_to?(:infinite?) && last.infinite?
-            binds << build_bind_param(column_name, last)
-            last = Arel::Nodes::BindParam.new
-          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)
+    protected
+      def expand_from_hash(attributes)
+        return ["1=0"] if attributes.empty?
+
+        attributes.flat_map do |key, value|
+          if value.is_a?(Hash) && !table.has_column?(key)
+            table.associated_predicate_builder(key).expand_from_hash(value)
+          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
+
+            klass ||= AssociationQueryValue
+            queries = klass.new(associated_table, value).queries.map do |query|
+              expand_from_hash(query).reduce(&:and)
+            end
+            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
+          else
+            build(table.arel_attribute(key), value)
           end
         end
       end
 
-      [result, binds]
-    end
-
     private
+      attr_reader :table
 
-    def associated_predicate_builder(association_name)
-      self.class.new(table.associated_table(association_name))
-    end
+      def convert_dot_notation_to_hash(attributes)
+        dot_notation = attributes.select do |k, v|
+          k.include?(".") && !v.is_a?(Hash)
+        end
 
-    def convert_dot_notation_to_hash(attributes)
-      dot_notation = attributes.select do |k, v|
-        k.include?(".".freeze) && !v.is_a?(Hash)
-      end
+        dot_notation.each_key do |key|
+          table_name, column_name = key.split(".")
+          value = attributes.delete(key)
+          attributes[table_name] ||= {}
 
-      dot_notation.each_key do |key|
-        table_name, column_name = key.split(".".freeze)
-        value = attributes.delete(key)
-        attributes[table_name] ||= {}
+          attributes[table_name] = attributes[table_name].merge(column_name => value)
+        end
 
-        attributes[table_name] = attributes[table_name].merge(column_name => value)
+        attributes
       end
 
-      attributes
-    end
-
-    def handler_for(object)
-      @handlers.detect { |klass, _| klass === object }.last
-    end
-
-    def can_be_bound?(column_name, value)
-      !value.nil? &&
-        handler_for(value).is_a?(BasicObjectHandler) &&
-        !table.associated_with?(column_name)
-    end
-
-    def build_bind_param(column_name, value)
-      Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
-    end
+      def handler_for(object)
+        @handlers.detect { |klass, _| klass === object }.last
+      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"