omg-activerecord 8.0.0.alpha1

data/lib/active_record/associations/join_dependency.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class JoinDependency # :nodoc:
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :JoinBase
+        autoload :JoinAssociation
+      end
+
+      class Aliases # :nodoc:
+        def initialize(tables)
+          @tables = tables
+          @alias_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns.each_with_object({}) { |column, i|
+              i[column.name] = column.alias
+            }
+          }
+          @columns_cache = tables.each_with_object({}) { |table, h|
+            h[table.node] = table.columns
+          }
+        end
+
+        def columns
+          @tables.flat_map(&:column_aliases)
+        end
+
+        def column_aliases(node)
+          @columns_cache[node]
+        end
+
+        def column_alias(node, column)
+          @alias_cache[node][column]
+        end
+
+        Table = Struct.new(:node, :columns) do # :nodoc:
+          def column_aliases
+            t = node.table
+            columns.map { |column| t[column.name].as(column.alias) }
+          end
+        end
+        Column = Struct.new(:name, :alias)
+      end
+
+      def self.make_tree(associations)
+        hash = {}
+        walk_tree associations, hash
+        hash
+      end
+
+      def self.walk_tree(associations, hash)
+        case associations
+        when Symbol, String
+          hash[associations.to_sym] ||= {}
+        when Array
+          associations.each do |assoc|
+            walk_tree assoc, hash
+          end
+        when Hash
+          associations.each do |k, v|
+            cache = hash[k] ||= {}
+            walk_tree v, cache if v
+          end
+        else
+          raise ConfigurationError, associations.inspect
+        end
+      end
+
+      def initialize(base, table, associations, join_type)
+        tree = self.class.make_tree associations
+        @join_root = JoinBase.new(base, table, build(tree, base))
+        @join_type = join_type
+      end
+
+      def base_klass
+        join_root.base_klass
+      end
+
+      def reflections
+        join_root.drop(1).map!(&:reflection)
+      end
+
+      def join_constraints(joins_to_add, alias_tracker, references)
+        @alias_tracker = alias_tracker
+        @joined_tables = {}
+        @references = {}
+
+        references.each do |table_name|
+          @references[table_name.to_sym] = table_name if table_name.is_a?(Arel::Nodes::SqlLiteral)
+        end unless references.empty?
+
+        joins = make_join_constraints(join_root, join_type)
+
+        joins.concat joins_to_add.flat_map { |oj|
+          if join_root.match? oj.join_root
+            walk(join_root, oj.join_root, oj.join_type)
+          else
+            make_join_constraints(oj.join_root, oj.join_type)
+          end
+        }
+      end
+
+      def instantiate(result_set, strict_loading_value, &block)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |i, parent|
+          i[parent] = Hash.new { |j, child_class|
+            j[child_class] = {}
+          }
+        }.compare_by_identity
+
+        model_cache = Hash.new { |h, klass| h[klass] = {} }
+        parents = model_cache[join_root]
+
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = []
+
+        result_set.columns.each do |name|
+          column_names << name unless /\At\d+_r\d+\z/.match?(name)
+        end
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          unless column_types.empty?
+            attribute_types = join_root.attribute_types
+            column_types = column_types.slice(*column_names).delete_if { |k, _| attribute_types.key?(k) }
+          end
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
+        }
+
+        message_bus.instrument("instantiation.active_record", payload) do
+          result_set.each { |row_hash|
+            parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
+            construct(parent, join_root, row_hash, seen, model_cache, strict_loading_value)
+          }
+        end
+
+        parents.values
+      end
+
+      def apply_column_aliases(relation)
+        @join_root_alias = relation.select_values.empty?
+        relation._select!(-> { aliases.columns })
+      end
+
+      def each(&block)
+        join_root.each(&block)
+      end
+
+      protected
+        attr_reader :join_root, :join_type
+
+      private
+        attr_reader :alias_tracker, :join_root_alias
+
+        def aliases
+          @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
+            column_names = if join_part == join_root && !join_root_alias
+              primary_key = join_root.primary_key
+              primary_key ? [primary_key] : []
+            else
+              join_part.column_names
+            end
+
+            columns = column_names.each_with_index.map { |column_name, j|
+              Aliases::Column.new column_name, "t#{i}_r#{j}"
+            }
+            Aliases::Table.new(join_part, columns)
+          }
+        end
+
+        def make_join_constraints(join_root, join_type)
+          join_root.children.flat_map do |child|
+            make_constraints(join_root, child, join_type)
+          end
+        end
+
+        def make_constraints(parent, child, join_type)
+          foreign_table = parent.table
+          foreign_klass = parent.base_klass
+          child.join_constraints(foreign_table, foreign_klass, join_type, alias_tracker) do |reflection, remaining_reflection_chain|
+            table, terminated = @joined_tables[remaining_reflection_chain]
+            root = reflection == child.reflection
+
+            if table && (!root || !terminated)
+              @joined_tables[remaining_reflection_chain] = [table, root] if root
+              next table, true
+            end
+
+            table_name = @references[reflection.name.to_sym]&.to_s
+
+            table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
+              name = reflection.alias_candidate(parent.table_name)
+              root ? name : "#{name}_join"
+            end
+
+            @joined_tables[remaining_reflection_chain] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+            table
+          end.concat child.children.flat_map { |c| make_constraints(child, c, join_type) }
+        end
+
+        def walk(left, right, join_type)
+          intersection, missing = right.children.map { |node1|
+            [left.children.find { |node2| node1.match? node2 }, node1]
+          }.partition(&:first)
+
+          joins = intersection.flat_map { |l, r| r.table = l.table; walk(l, r, join_type) }
+          joins.concat missing.flat_map { |_, n| make_constraints(left, n, join_type) }
+        end
+
+        def find_reflection(klass, name)
+          klass._reflect_on_association(name) ||
+            raise(ConfigurationError, "Can't join '#{klass.name}' to association named '#{name}'; perhaps you misspelled it?")
+        end
+
+        def build(associations, base_klass)
+          associations.map do |name, right|
+            reflection = find_reflection base_klass, name
+            reflection.check_validity!
+            reflection.check_eager_loadable!
+
+            if reflection.polymorphic?
+              raise EagerLoadPolymorphicError.new(reflection)
+            end
+
+            JoinAssociation.new(reflection, build(right, reflection.klass))
+          end
+        end
+
+        def construct(ar_parent, parent, row, seen, model_cache, strict_loading_value)
+          return if ar_parent.nil?
+
+          parent.children.each do |node|
+            if node.reflection.collection?
+              other = ar_parent.association(node.reflection.name)
+              other.loaded!
+            elsif ar_parent.association_cached?(node.reflection.name)
+              model = ar_parent.association(node.reflection.name).target
+              construct(model, node, row, seen, model_cache, strict_loading_value)
+              next
+            end
+
+            if node.primary_key
+              keys = Array(node.primary_key).map { |column| aliases.column_alias(node, column) }
+              id = keys.map { |key| row[key] }
+            else
+              keys = Array(node.reflection.join_primary_key).map { |column| aliases.column_alias(node, column.to_s) }
+              id = keys.map { nil } # Avoid id-based model caching.
+            end
+
+            if keys.any? { |key| row[key].nil? }
+              nil_association = ar_parent.association(node.reflection.name)
+              nil_association.loaded!
+              next
+            end
+
+            unless model = seen[ar_parent][node][id]
+              model = construct_model(ar_parent, node, row, model_cache, id, strict_loading_value)
+              seen[ar_parent][node][id] = model if id
+            end
+
+            construct(model, node, row, seen, model_cache, strict_loading_value)
+          end
+        end
+
+        def construct_model(record, node, row, model_cache, id, strict_loading_value)
+          other = record.association(node.reflection.name)
+
+          unless model = model_cache[node][id]
+            model = node.instantiate(row, aliases.column_aliases(node)) do |m|
+              m.strict_loading! if strict_loading_value
+              other.set_inverse_instance(m)
+            end
+            model_cache[node][id] = model if id
+          end
+
+          if node.reflection.collection?
+            other.target.push(model)
+          else
+            other.target = model
+          end
+
+          model.readonly! if node.readonly?
+          model.strict_loading! if node.strict_loading?
+          model
+        end
+    end
+  end
+end

data/lib/active_record/associations/nested_error.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Validation error class to wrap association records' errors,
+# with index_errors support.
+module ActiveRecord
+  module Associations
+    class NestedError < ::ActiveModel::NestedError
+      def initialize(association, inner_error)
+        @base = association.owner
+        @association = association
+        @inner_error = inner_error
+        super(@base, inner_error, { attribute: compute_attribute(inner_error) })
+      end
+
+      private
+        attr_reader :association
+
+        def compute_attribute(inner_error)
+          association_name = association.reflection.name
+
+          if association.collection? && index_errors_setting && index
+            "#{association_name}[#{index}].#{inner_error.attribute}".to_sym
+          else
+            "#{association_name}.#{inner_error.attribute}".to_sym
+          end
+        end
+
+        def index_errors_setting
+          @index_errors_setting ||=
+            association.options.fetch(:index_errors, ActiveRecord.index_nested_attribute_errors)
+        end
+
+        def index
+          @index ||= ordered_records&.find_index(inner_error.base)
+        end
+
+        def ordered_records
+          case index_errors_setting
+          when true # default is association order
+            association.target
+          when :nested_attributes_order
+            association.nested_attributes_target
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/preloader/association.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+# :enddoc:
+
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association # :nodoc:
+        class LoaderQuery
+          attr_reader :scope, :association_key_name
+
+          def initialize(scope, association_key_name)
+            @scope = scope
+            @association_key_name = association_key_name
+          end
+
+          def eql?(other)
+            association_key_name == other.association_key_name &&
+              scope.table_name == other.scope.table_name &&
+              scope.model.connection_specification_name == other.scope.model.connection_specification_name &&
+              scope.values_for_queries == other.scope.values_for_queries
+          end
+
+          def hash
+            [association_key_name, scope.model.table_name, scope.model.connection_specification_name, scope.values_for_queries].hash
+          end
+
+          def records_for(loaders)
+            LoaderRecords.new(loaders, self).records
+          end
+
+          def load_records_in_batch(loaders)
+            raw_records = records_for(loaders)
+
+            loaders.each do |loader|
+              loader.load_records(raw_records)
+              loader.run
+            end
+          end
+
+          def load_records_for_keys(keys, &block)
+            return [] if keys.empty?
+
+            if association_key_name.is_a?(Array)
+              query_constraints = Hash.new { |hsh, key| hsh[key] = Set.new }
+
+              keys.each_with_object(query_constraints) do |values_set, constraints|
+                association_key_name.zip(values_set).each do |key_name, value|
+                  constraints[key_name] << value
+                end
+              end
+
+              scope.where(query_constraints)
+            else
+              scope.where(association_key_name => keys)
+            end.load(&block)
+          end
+        end
+
+        class LoaderRecords
+          def initialize(loaders, loader_query)
+            @loader_query = loader_query
+            @loaders = loaders
+            @keys_to_load = Set.new
+            @already_loaded_records_by_key = {}
+
+            populate_keys_to_load_and_already_loaded_records
+          end
+
+          def records
+            load_records + already_loaded_records
+          end
+
+          private
+            attr_reader :loader_query, :loaders, :keys_to_load, :already_loaded_records_by_key
+
+            def populate_keys_to_load_and_already_loaded_records
+              loaders.each do |loader|
+                loader.owners_by_key.each do |key, owners|
+                  if loaded_owner = owners.find { |owner| loader.loaded?(owner) }
+                    already_loaded_records_by_key[key] = loader.target_for(loaded_owner)
+                  else
+                    keys_to_load << key
+                  end
+                end
+              end
+
+              @keys_to_load.subtract(already_loaded_records_by_key.keys)
+            end
+
+            def load_records
+              loader_query.load_records_for_keys(keys_to_load) do |record|
+                loaders.each { |l| l.set_inverse(record) }
+              end
+            end
+
+            def already_loaded_records
+              already_loaded_records_by_key.values.flatten
+            end
+        end
+
+        attr_reader :klass
+
+        def initialize(klass, owners, reflection, preload_scope, reflection_scope, associate_by_default)
+          @klass         = klass
+          @owners        = owners.uniq(&:__id__)
+          @reflection    = reflection
+          @preload_scope = preload_scope
+          @reflection_scope = reflection_scope
+          @associate     = associate_by_default || !preload_scope || preload_scope.empty_scope?
+          @model         = owners.first && owners.first.class
+          @run = false
+        end
+
+        def table_name
+          @klass.table_name
+        end
+
+        def future_classes
+          if run?
+            []
+          else
+            [@klass]
+          end
+        end
+
+        def runnable_loaders
+          [self]
+        end
+
+        def run?
+          @run
+        end
+
+        def run
+          return self if run?
+          @run = true
+
+          records = records_by_owner
+
+          owners.each do |owner|
+            associate_records_to_owner(owner, records[owner] || [])
+          end if @associate
+
+          self
+        end
+
+        def records_by_owner
+          load_records unless defined?(@records_by_owner)
+
+          @records_by_owner
+        end
+
+        def preloaded_records
+          load_records unless defined?(@preloaded_records)
+
+          @preloaded_records
+        end
+
+        # The name of the key on the associated records
+        def association_key_name
+          reflection.join_primary_key(klass)
+        end
+
+        def loader_query
+          LoaderQuery.new(scope, association_key_name)
+        end
+
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            key = derive_key(owner, owner_key_name)
+            (result[key] ||= []) << owner if key
+          end
+        end
+
+        def loaded?(owner)
+          owner.association(reflection.name).loaded?
+        end
+
+        def target_for(owner)
+          Array.wrap(owner.association(reflection.name).target)
+        end
+
+        def scope
+          @scope ||= build_scope
+        end
+
+        def set_inverse(record)
+          if owners = owners_by_key[derive_key(record, association_key_name)]
+            # Processing only the first owner
+            # because the record is modified but not an owner
+            association = owners.first.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
+        end
+
+        def load_records(raw_records = nil)
+          # owners can be duplicated when a relation has a collection association join
+          # #compare_by_identity makes such owners different hash keys
+          @records_by_owner = {}.compare_by_identity
+          raw_records ||= loader_query.records_for([self])
+          @preloaded_records = raw_records.select do |record|
+            assignments = false
+
+            owners_by_key[derive_key(record, association_key_name)]&.each do |owner|
+              entries = (@records_by_owner[owner] ||= [])
+
+              if reflection.collection? || entries.empty?
+                entries << record
+                assignments = true
+              end
+            end
+
+            assignments
+          end
+        end
+
+        def associate_records_from_unscoped(unscoped_records)
+          return if unscoped_records.nil? || unscoped_records.empty?
+          return if !reflection_scope.empty_scope?
+          return if preload_scope && !preload_scope.empty_scope?
+          return if reflection.collection?
+
+          unscoped_records.select { |r| r[association_key_name].present? }.each do |record|
+            owners = owners_by_key[derive_key(record, association_key_name)]
+            owners&.each_with_index do |owner, i|
+              association = owner.association(reflection.name)
+              association.target = record
+
+              if i == 0 # Set inverse on first owner
+                association.set_inverse_instance(record)
+              end
+            end
+          end
+        end
+
+        private
+          attr_reader :owners, :reflection, :preload_scope, :model
+
+          # The name of the key on the model which declares the association
+          def owner_key_name
+            reflection.join_foreign_key
+          end
+
+          def associate_records_to_owner(owner, records)
+            return if loaded?(owner)
+
+            association = owner.association(reflection.name)
+
+            if reflection.collection?
+              not_persisted_records = association.target.reject(&:persisted?)
+              association.target = records + not_persisted_records
+            else
+              association.target = records.first
+            end
+          end
+
+          def key_conversion_required?
+            unless defined?(@key_conversion_required)
+              @key_conversion_required = (association_key_type != owner_key_type)
+            end
+
+            @key_conversion_required
+          end
+
+          def derive_key(owner, key)
+            if key.is_a?(Array)
+              key.map { |k| convert_key(owner._read_attribute(k)) }
+            else
+              convert_key(owner._read_attribute(key))
+            end
+          end
+
+          def convert_key(key)
+            if key_conversion_required?
+              key.to_s
+            else
+              key
+            end
+          end
+
+          def association_key_type
+            @klass.type_for_attribute(association_key_name).type
+          end
+
+          def owner_key_type
+            @model.type_for_attribute(owner_key_name).type
+          end
+
+          def reflection_scope
+            @reflection_scope ||= reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass).inject(klass.unscoped, &:merge!)
+          end
+
+          def build_scope
+            scope = klass.scope_for_association
+
+            if reflection.type && !reflection.through_reflection?
+              scope.where!(reflection.type => model.polymorphic_name)
+            end
+
+            scope.merge!(reflection_scope) unless reflection_scope.empty_scope?
+
+            if preload_scope && !preload_scope.empty_scope?
+              scope.merge!(preload_scope)
+            end
+
+            cascade_strict_loading(scope)
+          end
+
+          def cascade_strict_loading(scope)
+            preload_scope&.strict_loading_value ? scope.strict_loading : scope
+          end
+      end
+    end
+  end
+end

data/lib/active_record/associations/preloader/batch.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Batch # :nodoc:
+        def initialize(preloaders, available_records:)
+          @preloaders = preloaders.reject(&:empty?)
+          @available_records = available_records.flatten.group_by { |r| r.class.base_class }
+        end
+
+        def call
+          branches = @preloaders.flat_map(&:branches)
+          until branches.empty?
+            loaders = branches.flat_map(&:runnable_loaders)
+
+            loaders.each { |loader| loader.associate_records_from_unscoped(@available_records[loader.klass.base_class]) }
+
+            if loaders.any?
+              future_tables = branches.flat_map do |branch|
+                branch.future_classes - branch.runnable_loaders.map(&:klass)
+              end.map(&:table_name).uniq
+
+              target_loaders = loaders.reject { |l| future_tables.include?(l.table_name)  }
+              target_loaders = loaders if target_loaders.empty?
+
+              group_and_load_similar(target_loaders)
+              target_loaders.each(&:run)
+            end
+
+            finished, in_progress = branches.partition(&:done?)
+
+            branches = in_progress + finished.flat_map(&:children)
+          end
+        end
+
+        private
+          attr_reader :loaders
+
+          def group_and_load_similar(loaders)
+            loaders.grep_v(ThroughAssociation).group_by(&:loader_query).each_pair do |query, similar_loaders|
+              query.load_records_in_batch(similar_loaders)
+            end
+          end
+      end
+    end
+  end
+end