omg-activerecord 8.0.0.alpha1

data/lib/active_record/relation/merger.rb

@@ -0,0 +1,192 @@
+# 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
+        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.model,
+          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.public_send("#{k}!", v)
+          end
+        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 -
+                      [
+                        :select, :includes, :preload, :joins, :left_outer_joins,
+                        :order, :reverse_order, :lock, :create_with, :reordering
+                      ]
+
+      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)
+            relation.public_send(:"#{name}!", *value)
+          end
+        end
+
+        relation.none! if other.null_relation?
+
+        merge_select_values
+        merge_multi_values
+        merge_single_values
+        merge_clauses
+        merge_preloads
+        merge_joins
+        merge_outer_joins
+
+        relation
+      end
+
+      private
+        def merge_select_values
+          return if other.select_values.empty?
+
+          if other.model == relation.model
+            relation.select_values |= other.select_values
+          else
+            relation.select_values |= other.instance_eval do
+              arel_columns(select_values)
+            end
+          end
+        end
+
+        def merge_preloads
+          return if other.preload_values.empty? && other.includes_values.empty?
+
+          if other.model == relation.model
+            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.model.reflect_on_all_associations.find do |r|
+              r.class_name == other.model.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.empty?
+
+          if other.model == relation.model
+            relation.joins_values |= 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
+
+        def merge_outer_joins
+          return if other.left_outer_joins_values.empty?
+
+          if other.model == relation.model
+            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
+
+            join_dependency = other.construct_join_dependency(
+              associations, Arel::Nodes::OuterJoin
+            )
+            relation.left_outer_joins!(join_dependency, *others)
+          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.model.base_class == other.model.base_class
+        end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
+
+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.compact!
+        ranges = values.extract! { |v| v.is_a?(Range) }
+
+        values_predicate =
+          case values.length
+          when 0 then NullPredicate
+          when 1 then predicate_builder.build(attribute, values.first)
+          else Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
+          end
+
+        if nils
+          values_predicate = values_predicate.or(attribute.eq(nil))
+        end
+
+        if ranges.empty?
+          values_predicate
+        else
+          array_predicates = ranges.map! { |range| predicate_builder.build(attribute, range) }
+          array_predicates.inject(values_predicate, &:or)
+        end
+      end
+
+      private
+        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,76 @@
+# 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
+        if associated_table.join_foreign_key.is_a?(Array)
+          id_list = ids
+          id_list = id_list.pluck(primary_key) if id_list.is_a?(Relation)
+
+          id_list.map { |ids_set| associated_table.join_foreign_key.zip(ids_set).to_h }
+        else
+          [ associated_table.join_foreign_key => ids ]
+        end
+      end
+
+      private
+        attr_reader :associated_table, :value
+
+        def ids
+          case value
+          when Relation
+            relation = value
+            relation = relation.select(primary_key) if select_clause?
+            relation = relation.where(primary_type => polymorphic_name) if polymorphic_clause?
+            relation
+          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 primary_type
+          associated_table.join_primary_type
+        end
+
+        def polymorphic_name
+          associated_table.polymorphic_name_association
+        end
+
+        def select_clause?
+          value.select_values.empty?
+        end
+
+        def polymorphic_clause?
+          primary_type && !value.where_values_hash.has_key?(primary_type)
+        end
+
+        def convert_to_id(value)
+          if primary_key.is_a?(Array)
+            primary_key.map do |attribute|
+              if attribute == "id"
+                value.id_value
+              else
+                value.public_send(attribute)
+              end
+            end
+          elsif 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,60 @@
+# 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)
+          if value.is_a?(Base)
+            value.class
+          elsif value.is_a?(Relation)
+            value.model
+          end
+        end
+
+        def convert_to_id(value)
+          if value.is_a?(Base)
+            primary_key = primary_key(value)
+            if primary_key.is_a?(Array)
+              primary_key.map { |column| value._read_attribute(column) }
+            else
+              value._read_attribute(primary_key)
+            end
+          elsif value.is_a?(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

@@ -0,0 +1,24 @@
+# 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?
+          model = value.model
+          if model.composite_primary_key?
+            raise ArgumentError, "Cannot map composite primary key #{model.primary_key} to #{attribute.name}"
+          else
+            value = value.select(value.table[model.primary_key])
+          end
+        end
+
+        attribute.in(value.arel)
+      end
+    end
+  end
+end

data/lib/active_record/relation/predicate_builder.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
+    require "active_record/relation/predicate_builder/array_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"
+
+    def initialize(table)
+      @table = table
+      @handlers = []
+
+      register_handler(BasicObject, BasicObjectHandler.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, &block)
+      attributes = convert_dot_notation_to_hash(attributes)
+      expand_from_hash(attributes, &block)
+    end
+
+    def self.references(attributes)
+      attributes.each_with_object([]) do |(key, value), result|
+        if value.is_a?(Hash)
+          result << Arel.sql(key, retryable: true)
+        elsif (idx = key.rindex("."))
+          result << Arel.sql(key[0, idx], retryable: true)
+        end
+      end
+    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
+
+    def [](attr_name, value, operator = nil)
+      build(table.arel_table[attr_name], value, operator)
+    end
+
+    def build(attribute, value, operator = nil)
+      value = value.id if value.respond_to?(:id)
+      if operator ||= table.type(attribute.name).force_equality?(value) && :eq
+        bind = build_bind_attribute(attribute.name, value)
+        attribute.public_send(operator, bind)
+      else
+        handler_for(value).call(attribute, value)
+      end
+    end
+
+    def build_bind_attribute(column_name, value)
+      Relation::QueryAttribute.new(column_name, value, table.type(column_name))
+    end
+
+    def resolve_arel_attribute(table_name, column_name, &block)
+      table.associated_table(table_name, &block).arel_table[column_name]
+    end
+
+    protected
+      def expand_from_hash(attributes, &block)
+        return ["1=0"] if attributes.empty?
+
+        attributes.flat_map do |key, value|
+          if key.is_a?(Array) && key.size == 1
+            key = key.first
+            value = value.flatten
+          end
+
+          if key.is_a?(Array)
+            queries = Array(value).map do |ids_set|
+              raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
+              expand_from_hash(key.zip(ids_set).to_h)
+            end
+            grouping_queries(queries)
+          elsif value.is_a?(Hash) && !table.has_column?(key)
+            table.associated_table(key, &block)
+              .predicate_builder.expand_from_hash(value.stringify_keys)
+          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?
+              value = [value] unless value.is_a?(Array)
+              klass = PolymorphicArrayValue
+            elsif associated_table.through_association?
+              next associated_table.predicate_builder.expand_from_hash(
+                associated_table.primary_key => value
+              )
+            end
+
+            klass ||= AssociationQueryValue
+            queries = klass.new(associated_table, value).queries.map! do |query|
+              # If the query produced is identical to attributes don't go any deeper.
+              # Prevents stack level too deep errors when association and foreign_key are identical.
+              query == attributes ? self[key, value] : expand_from_hash(query)
+            end
+
+            grouping_queries(queries)
+          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
+              self[column_name, values]
+            else
+              queries = values.map do |object|
+                mapping.map do |field_attr, aggregate_attr|
+                  self[field_attr, object.try!(aggregate_attr)]
+                end
+              end
+
+              grouping_queries(queries)
+            end
+          else
+            self[key, value]
+          end
+        end
+      end
+
+    private
+      attr_reader :table
+
+      def grouping_queries(queries)
+        if queries.one?
+          queries.first
+        else
+          queries.map! { |query| query.reduce(&:and) }
+          queries = queries.reduce { |result, query| Arel::Nodes::Or.new([result, query]) }
+          Arel::Nodes::Grouping.new(queries)
+        end
+      end
+
+      def convert_dot_notation_to_hash(attributes)
+        attributes.each_with_object({}) do |(key, value), converted|
+          if value.is_a?(Hash)
+            if (existing = converted[key])
+              existing.merge!(value)
+            else
+              converted[key] = value.dup
+            end
+          elsif (idx = key.rindex("."))
+            table_name, column_name = key[0, idx], key[idx + 1, key.length]
+
+            if (existing = converted[table_name])
+              existing[column_name] = value
+            else
+              converted[table_name] = { column_name => value }
+            end
+          else
+            converted[key] = value
+          end
+        end
+      end
+
+      def handler_for(object)
+        @handlers.detect { |klass, _| klass === object }.last
+      end
+  end
+end

data/lib/active_record/relation/query_attribute.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveRecord
+  class Relation
+    class QueryAttribute < ActiveModel::Attribute # :nodoc:
+      def initialize(...)
+        super
+
+        # The query attribute value may be mutated before we actually "compile" the query.
+        # To avoid that if the type uses a serializer we eagerly compute the value for database
+        if value_before_type_cast.is_a?(StatementCache::Substitute)
+          # we don't need to serialize StatementCache::Substitute
+        elsif @type.serialized?
+          value_for_database
+        elsif @type.mutable? # If the type is simply mutable, we deep_dup it.
+          @value_before_type_cast = @value_before_type_cast.deep_dup
+        end
+      end
+
+      def type_cast(value)
+        value
+      end
+
+      def value_for_database
+        @value_for_database = _value_for_database unless defined?(@value_for_database)
+        @value_for_database
+      end
+
+      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) && serializable? && value_for_database.nil?
+        end
+      end
+
+      def infinite?
+        infinity?(value_before_type_cast) || serializable? && infinity?(value_for_database)
+      end
+
+      def unboundable?
+        unless defined?(@_unboundable)
+          serializable? { |value| @_unboundable = value <=> 0 } && @_unboundable = nil
+        end
+        @_unboundable
+      end
+
+      def ==(other)
+        super && value_for_database == other.value_for_database
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, name, value_for_database, type].hash
+      end
+
+      private
+        def infinity?(value)
+          value.respond_to?(:infinite?) && value.infinite?
+        end
+    end
+  end
+end