activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/relation/from_clause.rb

@@ -0,0 +1,26 @@
+# 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 self.empty
+        @empty ||= new(nil, nil)
+      end
+    end
+  end
+end

data/lib/active_record/relation/merger.rb

@@ -0,0 +1,193 @@
+# 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)
+        hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+        @relation = relation
+        @hash     = hash
+      end
+
+      def merge #:nodoc:
+        Merger.new(relation, other).merge
+      end
+
+      # Applying values to a relation has some side effects. E.g.
+      # interpolation might take place for where values. So we should
+      # build a relation to merge in rather than directly merging
+      # the values.
+      def other
+        other = Relation.create(
+          relation.klass,
+          table: relation.table,
+          predicate_builder: relation.predicate_builder
+        )
+        hash.each { |k, v|
+          if k == :joins
+            if Hash === v
+              other.joins!(v)
+            else
+              other.joins!(*v)
+            end
+          elsif k == :select
+            other._select!(v)
+          else
+            other.send("#{k}!", v)
+          end
+        }
+        other
+      end
+    end
+
+    class Merger # :nodoc:
+      attr_reader :relation, :values, :other
+
+      def initialize(relation, other)
+        @relation = relation
+        @values   = other.values
+        @other    = other
+      end
+
+      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
+      end
+
+      def merge
+        normal_values.each do |name|
+          value = values[name]
+          # The unless clause is here mostly for performance reasons (since the `send` call might be moderately
+          # expensive), most of the time the value is going to be `nil` or `.blank?`, the only catch is that
+          # `false.blank?` returns `true`, so there needs to be an extra check so that explicit `false` values
+          # don't fall through the cracks.
+          unless value.nil? || (value.blank? && false != value)
+            if name == :select
+              relation._select!(*value)
+            else
+              relation.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?
+
+          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.includes_values.empty?
+              relation.includes! reflection.name => other.includes_values
+            end
+          end
+        end
+
+        def merge_joins
+          return if other.joins_values.blank?
+
+          if other.klass == relation.klass
+            relation.joins!(*other.joins_values)
+          else
+            joins_dependency = other.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.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.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.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
+
+        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)
+          end
+        end
+
+        def merge_clauses
+          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
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class ArrayHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      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?)
+        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
+            values.map! do |v|
+              predicate_builder.build_bind_attribute(attribute.name, v)
+            end
+            values.empty? ? NullPredicate : attribute.in(values)
+          end
+
+        unless nils.empty?
+          values_predicate = values_predicate.or(predicate_builder.build(attribute, nil))
+        end
+
+        array_predicates = ranges.map { |range| predicate_builder.build(attribute, range) }
+        array_predicates.unshift(values_predicate)
+        array_predicates.inject(&:or)
+      end
+
+      protected
+
+        attr_reader :predicate_builder
+
+        module NullPredicate # :nodoc:
+          def self.or(other)
+            other
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class BaseHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        predicate_builder.build(attribute, value.id)
+      end
+
+      protected
+
+        attr_reader :predicate_builder
+    end
+  end
+end

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

@@ -0,0 +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)
+        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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class RangeHandler # :nodoc:
+      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)
+        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(end_bind)
+          else
+            attribute.lteq(end_bind)
+          end
+        elsif end_bind.value.infinity?
+          attribute.gteq(begin_bind)
+        elsif value.exclude_end?
+          attribute.gteq(begin_bind).and(attribute.lt(end_bind))
+        else
+          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

@@ -0,0 +1,19 @@
+# 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
+
+        attribute.in(value.arel)
+      end
+    end
+  end
+end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,63 +1,152 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    def self.build_from_hash(engine, attributes, default_table, allow_table_name = true)
-      predicates = attributes.map do |column, value|
-        table = default_table
+    delegate :resolve_column_aliases, to: :table
 
-        if allow_table_name && value.is_a?(Hash)
-          table = Arel::Table.new(column, engine)
+    def initialize(table)
+      @table = table
+      @handlers = []
 
-          if value.empty?
-            '1 = 2'
-          else
-            build_from_hash(engine, value, table, false)
-          end
+      register_handler(BasicObject, BasicObjectHandler.new(self))
+      register_handler(Base, BaseHandler.new(self))
+      register_handler(Range, RangeHandler.new(self))
+      register_handler(Relation, RelationHandler.new)
+      register_handler(Array, ArrayHandler.new(self))
+      register_handler(Set, ArrayHandler.new(self))
+    end
+
+    def build_from_hash(attributes)
+      attributes = convert_dot_notation_to_hash(attributes)
+      expand_from_hash(attributes)
+    end
+
+    def self.references(attributes)
+      attributes.map do |key, value|
+        if value.is_a?(Hash)
+          key
         else
-          column = column.to_s
+          key = key.to_s
+          key.split(".".freeze).first if key.include?(".".freeze)
+        end
+      end.compact
+    end
 
-          if allow_table_name && column.include?('.')
-            table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, engine)
-          end
+    # Define how a class is converted to Arel nodes when passed to +where+.
+    # The handler can be any object that responds to +call+, and will be used
+    # for any value that +===+ the class given. For example:
+    #
+    #     MyCustomDateRange = Struct.new(:start, :end)
+    #     handler = proc do |column, range|
+    #       Arel::Nodes::Between.new(column,
+    #         Arel::Nodes::And.new([range.start, range.end])
+    #       )
+    #     end
+    #     ActiveRecord::PredicateBuilder.new("users").register_handler(MyCustomDateRange, handler)
+    def register_handler(klass, handler)
+      @handlers.unshift([klass, handler])
+    end
 
-          attribute = table[column]
+    def build(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
 
-          case value
-          when ActiveRecord::Relation
-            value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
-            attribute.in(value.arel.ast)
-          when Array, ActiveRecord::Associations::CollectionProxy
-            values = value.to_a.map {|x| x.is_a?(ActiveRecord::Base) ? x.id : x}
-            ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+    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
 
-            array_predicates = ranges.map {|range| attribute.in(range)}
+    protected
 
-            if values.include?(nil)
-              values = values.compact
-              if values.empty?
-                array_predicates << attribute.eq(nil)
-              else
-                array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
+      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) && !table.has_column?(key)
+            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
-            else
-              array_predicates << attribute.in(values)
             end
 
-            array_predicates.inject {|composite, predicate| composite.or(predicate)}
-          when Range, Arel::Relation
-            attribute.in(value)
-          when ActiveRecord::Base
-            attribute.eq(value.id)
-          when Class
-            # FIXME: I think we need to deprecate this behavior
-            attribute.eq(value.name)
+            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
-            attribute.eq(value)
+            build(table.arel_attribute(key), value)
           end
         end
       end
 
-      predicates.flatten
-    end
+    private
+
+      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?(".".freeze) && !v.is_a?(Hash)
+        end
+
+        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
+      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"