activerecord 4.2.9 → 6.1.4.1

data/lib/active_record/relation/from_clause.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    class FromClause # :nodoc:
+      attr_reader :value, :name
+
+      def initialize(value, name)
+        @value = value
+        @name = name
+      end
+
+      def merge(other)
+        self
+      end
+
+      def empty?
+        value.nil?
+      end
+
+      def ==(other)
+        self.class == other.class && value == other.value && name == other.name
+      end
+
+      def self.empty
+        @empty ||= new(nil, nil).freeze
+      end
+    end
+  end
+end

data/lib/active_record/relation/merger.rb

@@ -1,20 +1,22 @@
-require 'active_support/core_ext/hash/keys'
-require "set"
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/keys"
 
 module ActiveRecord
   class Relation
     class HashMerger # :nodoc:
       attr_reader :relation, :hash
 
-      def initialize(relation, hash)
+      def initialize(relation, hash, rewhere = nil)
         hash.assert_valid_keys(*Relation::VALUE_METHODS)
 
         @relation = relation
         @hash     = hash
+        @rewhere  = rewhere
       end
 
-      def merge #:nodoc:
-        Merger.new(relation, other).merge
+      def merge
+        Merger.new(relation, other, @rewhere).merge
       end
 
       # Applying values to a relation has some side effects. E.g.
@@ -22,20 +24,19 @@ module ActiveRecord
       # build a relation to merge in rather than directly merging
       # the values.
       def other
-        other = Relation.create(relation.klass, relation.table)
-        hash.each { |k, v|
-          if k == :joins
-            if Hash === v
-              other.joins!(v)
-            else
-              other.joins!(*v)
-            end
-          elsif k == :select
-            other._select!(v)
+        other = Relation.create(
+          relation.klass,
+          table: relation.table,
+          predicate_builder: relation.predicate_builder
+        )
+        hash.each do |k, v|
+          k = :_select if k == :select
+          if Array === v
+            other.public_send("#{k}!", *v)
           else
-            other.send("#{k}!", v)
+            other.public_send("#{k}!", v)
           end
-        }
+        end
         other
       end
     end
@@ -43,16 +44,16 @@ module ActiveRecord
     class Merger # :nodoc:
       attr_reader :relation, :values, :other
 
-      def initialize(relation, other)
+      def initialize(relation, other, rewhere = nil)
         @relation = relation
         @values   = other.values
         @other    = other
+        @rewhere  = rewhere
       end
 
-      NORMAL_VALUES = Relation::SINGLE_VALUE_METHODS +
-                      Relation::MULTI_VALUE_METHODS -
-                      [:includes, :preload, :joins, :where, :order, :bind, :reverse_order, :lock, :create_with, :reordering, :from] # :nodoc:
-
+      NORMAL_VALUES = Relation::VALUE_METHODS -
+                      Relation::CLAUSE_METHODS -
+                      [:includes, :preload, :joins, :left_outer_joins, :order, :reverse_order, :lock, :create_with, :reordering] # :nodoc:
 
       def normal_values
         NORMAL_VALUES
@@ -69,125 +70,116 @@ module ActiveRecord
             if name == :select
               relation._select!(*value)
             else
-              relation.send("#{name}!", *value)
+              relation.public_send("#{name}!", *value)
             end
           end
         end
 
         merge_multi_values
         merge_single_values
+        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_values |= other.preload_values unless other.preload_values.empty?
+            relation.includes_values |= 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.empty?
 
-        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_values |= other.joins_values
+          else
+            associations, others = other.joins_values.partition do |join|
+              case join
+              when Hash, Symbol, Array; true
+              end
             end
-          end
-
-          join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
-                                                                           joins_dependency,
-                                                                           [])
-          relation.joins! rest
 
-          @relation = relation.joins join_dependency
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::InnerJoin
+            )
+            relation.joins!(join_dependency, *others)
+          end
         end
-      end
 
-      def merge_multi_values
-        lhs_wheres = relation.where_values
-        rhs_wheres = other.where_values
+        def merge_outer_joins
+          return if other.left_outer_joins_values.empty?
 
-        lhs_binds  = relation.bind_values
-        rhs_binds  = other.bind_values
-
-        removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
+          if other.klass == relation.klass
+            relation.left_outer_joins_values |= other.left_outer_joins_values
+          else
+            associations, others = other.left_outer_joins_values.partition do |join|
+              case join
+              when Hash, Symbol, Array; true
+              end
+            end
 
-        where_values = kept + rhs_wheres
-        bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.left_outer_joins!(join_dependency, *others)
+          end
+        end
 
-        relation.where_values = where_values
-        relation.bind_values  = bind_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
 
-        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
+          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.from_value          = other.from_value unless relation.from_value
-        relation.lock_value          = other.lock_value unless relation.lock_value
+        def merge_single_values
+          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)
+          unless other.create_with_value.blank?
+            relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
+          end
         end
-      end
 
-      def filter_binds(lhs_binds, removed_wheres)
-        return lhs_binds if removed_wheres.empty?
+        def merge_clauses
+          relation.from_clause = other.from_clause if replace_from_clause?
 
-        set = Set.new removed_wheres.map { |x| x.left.name.to_s }
-        lhs_binds.dup.delete_if { |col,_| set.include? col.name }
-      end
-
-      # Remove equalities from the existing relation with a LHS which is
-      # present in the relation being merged in.
-      # returns [things_to_remove, things_to_keep]
-      def partition_overwrites(lhs_wheres, rhs_wheres)
-        if lhs_wheres.empty? || rhs_wheres.empty?
-          return [[], lhs_wheres]
-        end
+          where_clause = relation.where_clause.merge(other.where_clause, @rewhere)
+          relation.where_clause = where_clause unless where_clause.empty?
 
-        nodes = rhs_wheres.find_all do |w|
-          w.respond_to?(:operator) && w.operator == :==
+          having_clause = relation.having_clause.merge(other.having_clause)
+          relation.having_clause = having_clause unless having_clause.empty?
         end
-        seen = Set.new(nodes) { |node| node.left }
 
-        lhs_wheres.partition do |w|
-          w.respond_to?(:operator) && w.operator == :== && seen.include?(w.left)
+        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/array_handler.rb

@@ -1,48 +1,48 @@
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
 
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
-      def call(attribute, value)
-        values = value.map { |x| x.is_a?(Base) ? x.id : x }
-        nils, values = values.partition(&:nil?)
-
-        if values.any? { |val| val.is_a?(Array) }
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing a nested array to Active Record finder methods is
-            deprecated and will be removed. Flatten your array before using
-            it for 'IN' conditions.
-          MSG
-
-          flat_values = values.flatten
-          values = flat_values unless flat_values.include?(nil)
-        end
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
 
-        return attribute.in([]) if values.empty? && nils.empty?
+      def call(attribute, value)
+        return attribute.in([]) if value.empty?
 
-        ranges, values = values.partition { |v| v.is_a?(Range) }
+        values = value.map { |x| x.is_a?(Base) ? x.id : x }
+        nils = values.extract!(&:nil?)
+        ranges = values.extract! { |v| v.is_a?(Range) }
 
         values_predicate =
           case values.length
           when 0 then NullPredicate
-          when 1 then attribute.eq(values.first)
-          else attribute.in(values)
+          when 1 then predicate_builder.build(attribute, values.first)
+          else Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
           end
 
         unless nils.empty?
           values_predicate = values_predicate.or(attribute.eq(nil))
         end
 
-        array_predicates = ranges.map { |range| attribute.between(range) }
-        array_predicates.unshift(values_predicate)
-        array_predicates.inject { |composite, predicate| composite.or(predicate) }
+        if ranges.empty?
+          values_predicate
+        else
+          array_predicates = ranges.map! { |range| predicate_builder.build(attribute, range) }
+          array_predicates.inject(values_predicate, &:or)
+        end
       end
 
-      module NullPredicate # :nodoc:
-        def self.or(other)
-          other
+      private
+        attr_reader :predicate_builder
+
+        module NullPredicate # :nodoc:
+          def self.or(other)
+            other
+          end
         end
-      end
     end
   end
 end

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

@@ -0,0 +1,42 @@
+# 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.join_foreign_key => ids ]
+      end
+
+      private
+        attr_reader :associated_table, :value
+
+        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.join_primary_key
+        end
+
+        def convert_to_id(value)
+          if value.respond_to?(primary_key)
+            value.public_send(primary_key)
+          else
+            value
+          end
+        end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,57 @@
+# 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
+        return [ associated_table.join_foreign_key => values ] if values.empty?
+
+        type_to_ids_mapping.map do |type, ids|
+          query = {}
+          query[associated_table.join_foreign_type] = type if type
+          query[associated_table.join_foreign_key] = ids
+          query
+        end
+      end
+
+      private
+        attr_reader :associated_table, :values
+
+        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.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))
+          else
+            value
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class RangeHandler # :nodoc:
+      RangeWithBinds = Struct.new(:begin, :end, :exclude_end?)
+
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        begin_bind = predicate_builder.build_bind_attribute(attribute.name, value.begin)
+        end_bind = predicate_builder.build_bind_attribute(attribute.name, value.end)
+        attribute.between(RangeWithBinds.new(begin_bind, end_bind, value.exclude_end?))
+      end
+
+      private
+        attr_reader :predicate_builder
+    end
+  end
+end

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

@@ -1,9 +1,15 @@
+# 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.klass.arel_table[value.klass.primary_key])
+          value = value.select(value.table[value.klass.primary_key])
         end
 
         attribute.in(value.arel)