mongoid 9.0.11 → 9.1.1

data/lib/mongoid/association/eager_loadable.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
-require "mongoid/association/eager"
+require 'mongoid/association/eager'
+require 'mongoid/association/eager_load/embedded_distributor'
+require 'mongoid/association/eager_load/polymorphic_preloader'
+require 'mongoid/association/eager_load/lookup_pipeline'
 
 module Mongoid
   module Association
-
     # This module defines the eager loading behavior for criteria.
     module EagerLoadable
-
       # Indicates whether the criteria has association
       # inclusions which should be eager loaded.
       #
@@ -24,10 +24,55 @@ module Mongoid
       # @return [ Array<Mongoid::Document> ] The given documents.
       def eager_load(docs)
         docs.tap do |d|
-          if eager_loadable?
-            preload(criteria.inclusions, d)
+          preload(criteria.inclusions, d) if eager_loadable?
+        end
+      end
+
+      # Load the associations for the given documents using $lookup.
+      #
+      # If any of the associated collections reside in a different cluster or
+      # database than the root class, falls back to the #includes behavior and
+      # logs a warning.
+      #
+      # @return [ Array<Mongoid::Document> ] The given documents.
+      def eager_load_with_lookup
+        offenders = inclusions_unreachable_by_lookup
+        if offenders.any?
+          offender_descriptions = offenders.map do |offender|
+            "#{offender.name} (client: #{offender.klass.client_name}, database: #{offender.klass.database_name})"
           end
+          Mongoid.logger.warn(
+            'eager_load cannot use $lookup aggregation because the following associations ' \
+            "reside in a different cluster or database than #{klass} " \
+            "(client: #{klass.client_name}, database: #{klass.database_name}): " \
+            "#{offender_descriptions.join(', ')}. Falling back to #includes behavior."
+          )
+          return eager_load(docs_for_lookup_fallback)
         end
+
+        through_inclusions = criteria.inclusions.select do |association|
+          association.is_a?(Association::Referenced::HasOneThrough) ||
+            association.is_a?(Association::Referenced::HasManyThrough)
+        end
+
+        if through_inclusions.any?
+          through_names = through_inclusions.map { |association| ":#{association.name}" }
+          Mongoid.logger.warn(
+            "#{through_names.join(', ')} are :through associations and do not support " \
+            '$lookup-based eager loading. All inclusions for this query will be preloaded ' \
+            'using separate queries.'
+          )
+          return eager_load(docs_for_lookup_fallback)
+        end
+
+        documents = preload_for_lookup(criteria)
+        # A polymorphic belongs_to cannot be expressed as a $lookup: its target
+        # collection varies per document. It is resolved after the roots are
+        # materialized, each inclusion by its own preloader.
+        criteria.inclusions.select(&:polymorphic?).each do |association|
+          EagerLoad::PolymorphicPreloader.new(association, klass).preload_into(documents)
+        end
+        documents
       end
 
       # Load the associations for the given documents. This will be done
@@ -46,26 +91,66 @@ module Mongoid
         queue.push(klass.root_class.to_s) if klass != klass.root_class
 
         while klass = queue.shift
-          if as = assoc_map.delete(klass)
-            as.each do |assoc|
-              queue << assoc.class_name
-
-              # If this class is nested in the inclusion tree, only load documents
-              # for the association above it. If there is no parent association,
-              # we will include documents from the documents passed to this method.
-              ds = docs
-              if assoc.parent_inclusions.length > 0
-                ds = assoc.parent_inclusions.map{ |p| docs_map[p].to_a }.flatten
-              end
-
-              res = assoc.relation.eager_loader([assoc], ds).run
-
-              docs_map[assoc.name] ||= [].to_set
-              docs_map[assoc.name].merge(res)
-            end
+          next unless as = assoc_map.delete(klass)
+
+          as.each do |assoc|
+            queue << assoc.class_name
+
+            # If this class is nested in the inclusion tree, only load documents
+            # for the association above it. If there is no parent association,
+            # we will include documents from the documents passed to this method.
+            ds = docs
+            ds = assoc.parent_inclusions.map { |p| docs_map[p].to_a }.flatten if assoc.parent_inclusions.length > 0
+
+            res = assoc.relation.eager_loader([ assoc ], ds).run
+
+            docs_map[assoc.name] ||= [].to_set
+            docs_map[assoc.name].merge(res)
           end
         end
       end
+
+      # Materialize the root documents with their inclusions eager-loaded by a
+      # single $lookup aggregation. The pipeline is built by LookupPipeline; the
+      # polymorphic inclusions it leaves out are resolved by the caller.
+      #
+      # @param [ Mongoid::Criteria ] criteria The criteria to load.
+      #
+      # @return [ Array<Mongoid::Document> ] The materialized root documents.
+      def preload_for_lookup(criteria)
+        pipeline = EagerLoad::LookupPipeline.new(criteria).stages
+        Eager.run(criteria.inclusions, [], true, pipeline)
+      end
+
+      private
+
+      # Returns the materialized documents to use when falling back from
+      # $lookup to #includes-style preloading. Must be implemented by each
+      # concrete context class.
+      #
+      # @return [ Array<Mongoid::Document> ] The materialized documents.
+      def docs_for_lookup_fallback
+        raise NotImplementedError, "#{self.class} must implement #docs_for_lookup_fallback"
+      end
+
+      # Returns the inclusions whose target class can't be reached by a $lookup
+      # from the root class, which joins only within the same client and database.
+      #
+      # @return [ Array<Mongoid::Association::Relatable> ] The offending inclusions.
+      def inclusions_unreachable_by_lookup
+        # Polymorphic associations have no single resolvable klass and are not
+        # loaded via $lookup, so they are never offenders.
+        criteria.inclusions.reject do |association|
+          association.polymorphic? || reachable_by_lookup?(association.klass)
+        end
+      end
+
+      # Whether a $lookup from a query on the root class can reach the model: it
+      # must live in the same client and database.
+      def reachable_by_lookup?(model)
+        model.client_name == klass.client_name &&
+          model.database_name == klass.database_name
+      end
     end
   end
 end

data/lib/mongoid/association/embedded/batchable.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
-
       # Contains behavior for executing operations in batch on embedded
       # documents.
       module Batchable
@@ -36,7 +34,7 @@ module Mongoid
           pre_process_batch_remove(docs, :delete)
           unless docs.empty?
             collection.find(selector).update_one(
-              positionally(selector, "$unset" => { path => true }),
+              positionally(selector, '$unset' => { path => true }),
               session: _session
             )
             # This solves the case in which a user sets, clears and resets an
@@ -61,32 +59,32 @@ module Mongoid
           # the id. Therefore we have to use pullAll with the documents'
           # attributes.
           removals = pre_process_batch_remove(docs, method)
-          pulls, pull_alls = removals.partition { |o| !o["_id"].nil? }
+          pulls, pull_alls = removals.partition { |o| !o['_id'].nil? }
 
-          if !_base.persisted?
+          unless _base.persisted?
             post_process_batch_remove(docs, method) unless docs.empty?
             return reindex
           end
 
-          if !docs.empty?
-            if !pulls.empty?
+          if docs.empty?
+            collection.find(selector).update_one(
+              positionally(selector, '$set' => { path => [] }),
+              session: _session
+            )
+          else
+            unless pulls.empty?
               collection.find(selector).update_one(
-                positionally(selector, "$pull" => { path => { "_id" => { "$in" => pulls.pluck("_id") } } }),
+                positionally(selector, '$pull' => { path => { '_id' => { '$in' => pulls.pluck('_id') } } }),
                 session: _session
               )
             end
-            if !pull_alls.empty?
+            unless pull_alls.empty?
               collection.find(selector).update_one(
-                positionally(selector, "$pullAll" => { path => pull_alls }),
+                positionally(selector, '$pullAll' => { path => pull_alls }),
                 session: _session
               )
             end
             post_process_batch_remove(docs, method)
-          else
-            collection.find(selector).update_one(
-              positionally(selector, "$set" => { path => [] }),
-              session: _session
-            )
           end
           reindex
         end
@@ -133,13 +131,13 @@ module Mongoid
         #
         # @param [ Array<Hash> ] sets The atomic sets.
         def add_atomic_sets(sets)
-          if _assigning?
-            _base.delayed_atomic_sets[path].try(:clear)
-            _base.collect_children.each do |child|
-              child.delayed_atomic_sets.clear
-            end
-            _base.delayed_atomic_sets[path] = sets
+          return unless _assigning?
+
+          _base.delayed_atomic_sets[path].try(:clear)
+          _base.collect_children.each do |child|
+            child.delayed_atomic_sets.clear
           end
+          _base.delayed_atomic_sets[path] = sets
         end
 
         # Perform a batch persist of the provided documents with a $set.
@@ -157,8 +155,8 @@ module Mongoid
           inserts = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$set' => { path => inserts }),
-                session: _session
+              positionally(selector, '$set' => { path => inserts }),
+              session: _session
             )
             post_process_batch_insert(docs)
           end
@@ -180,8 +178,8 @@ module Mongoid
           pushes = pre_process_batch_insert(docs)
           if insertable?
             collection.find(selector).update_one(
-                positionally(selector, '$push' => { path => { '$each' => pushes } }),
-                session: _session
+              positionally(selector, '$push' => { path => { '$each' => pushes } }),
+              session: _session
             )
             post_process_batch_insert(docs)
           end
@@ -259,10 +257,10 @@ module Mongoid
         # @return [ String ] The atomic path.
         def path
           @path ||= if _unscoped.empty?
-            Mongoid::Atomic::Paths::Embedded::Many.position_without_document(_base, _association)
-          else
-            _unscoped.first.atomic_path
-          end
+                      Mongoid::Atomic::Paths::Embedded::Many.position_without_document(_base, _association)
+                    else
+                      _unscoped.first.atomic_path
+                    end
         end
 
         # Clear the cache for path and atomic_paths. This method is used when
@@ -273,7 +271,7 @@ module Mongoid
         # @api private
         def clear_atomic_path_cache
           self.path = nil
-          _base.instance_variable_set("@atomic_paths", nil)
+          _base.instance_variable_set(:@atomic_paths, nil)
         end
 
         # Set the atomic path.

data/lib/mongoid/association/embedded/cyclic.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
-
       # This module provides convenience macros for using cyclic embedded
       # associations.
       module Cyclic
@@ -15,7 +13,6 @@ module Mongoid
         end
 
         module ClassMethods
-
           # Create a cyclic embedded association that creates a tree hierarchy for
           # the document and many embedded child documents.
           #
@@ -38,10 +35,10 @@ module Mongoid
           # or its children.
           def recursively_embeds_many(options = {})
             embeds_many(
-                cyclic_child_name,
-                options.merge(class_name: self.name, cyclic: true)
+              cyclic_child_name,
+              options.merge(class_name: name, cyclic: true)
             )
-            embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
+            embedded_in cyclic_parent_name, class_name: name, cyclic: true
           end
 
           # Create a cyclic embedded association that creates a single self
@@ -66,10 +63,10 @@ module Mongoid
           # or its children.
           def recursively_embeds_one(options = {})
             embeds_one(
-                cyclic_child_name(false),
-                options.merge(class_name: self.name, cyclic: true)
+              cyclic_child_name(false),
+              options.merge(class_name: name, cyclic: true)
             )
-            embedded_in cyclic_parent_name, class_name: self.name, cyclic: true
+            embedded_in cyclic_parent_name, class_name: name, cyclic: true
           end
 
           private
@@ -81,7 +78,7 @@ module Mongoid
           #
           # @return [ String ] "parent_" plus the class name underscored.
           def cyclic_parent_name
-            ("parent_#{self.name.demodulize.underscore.singularize}").to_sym
+            :"parent_#{name.demodulize.underscore.singularize}"
           end
 
           # Determines the child name given the class.
@@ -94,7 +91,7 @@ module Mongoid
           # @return [ String ] "child_" plus the class name underscored in
           #   singular or plural form.
           def cyclic_child_name(many = true)
-            ("child_#{self.name.demodulize.underscore.send(many ? :pluralize : :singularize)}").to_sym
+            :"child_#{name.demodulize.underscore.send(many ? :pluralize : :singularize)}"
           end
         end
       end

data/lib/mongoid/association/embedded/eager.rb

@@ -1,23 +1,18 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
-
       # Eager class for embedded associations (embedded_in, embeds_many,
       # embeds_one).
       class Eager < Association::Eager
-
         private
 
         # Embedded associations have no preload phase, since the embedded
         # documents are loaded with the parent document. This method is
         # implemented as a no-op to represent that.
-        def preload
-        end
+        def preload; end
       end
-
     end
   end
 end

data/lib/mongoid/association/embedded/embedded_in/binding.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
       class EmbeddedIn
-
         # The Binding object for embedded_in associations.
         class Binding
           include Bindable
@@ -60,13 +58,12 @@ module Mongoid
           #
           # @param [ Document ] doc The document to check.
           def check_polymorphic_inverses!(doc)
-            if inverses = _association.inverses(doc)
-              if inverses.length > 1
-                raise Errors::InvalidSetPolymorphicRelation.new(
-                    _association.name, _base.class.name, _target.class.name
-                )
-              end
-            end
+            return unless inverses = _association.inverses(doc)
+            return unless inverses.length > 1
+
+            raise Errors::InvalidSetPolymorphicRelation.new(
+              _association.name, _base.class.name, _target.class.name
+            )
           end
         end
       end

data/lib/mongoid/association/embedded/embedded_in/buildable.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
       class EmbeddedIn
-
         # The Builder behavior for embedded_in associations.
         module Buildable
           include Threaded::Lifecycle
@@ -24,8 +22,9 @@ module Mongoid
           #   will not be accessible in the built document.
           #
           # @return [ Document ] A single document.
-          def build(base, object, type = nil, selected_fields = nil)
+          def build(_base, object, _type = nil, selected_fields = nil)
             return object unless object.is_a?(Hash)
+
             if _loading?
               Factory.from_db(klass, object, nil, selected_fields)
             else

data/lib/mongoid/association/embedded/embedded_in/proxy.rb

@@ -90,6 +90,8 @@ module Mongoid
             # @param [ Array<Mongoid::Document> ] docs The parent documents
             #   that possess the given associations, which ought to be
             #   populated by the eager-loaded documents.
+            # @param [ true | false ] use_lookup Whether to use a $lookup
+            #   aggregation stage to perform the eager load.
             #
             # @return [ Mongoid::Association::Embedded::Eager ]
             def eager_loader(associations, docs)

data/lib/mongoid/association/embedded/embedded_in.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 require 'mongoid/association/embedded/embedded_in/binding'
 require 'mongoid/association/embedded/embedded_in/buildable'
@@ -8,7 +7,6 @@ require 'mongoid/association/embedded/embedded_in/proxy'
 module Mongoid
   module Association
     module Embedded
-
       # The EmbeddedIn type association.
       class EmbeddedIn
         include Relatable
@@ -18,11 +16,11 @@ module Mongoid
         # common ones.
         #
         # @return [ Array<Symbol> ] The extra valid options.
-        ASSOCIATION_OPTIONS = [
-            :autobuild,
-            :cyclic,
-            :polymorphic,
-            :touch,
+        ASSOCIATION_OPTIONS = %i[
+          autobuild
+          cyclic
+          polymorphic
+          touch
         ].freeze
 
         # The complete list of valid options for this association, including
@@ -44,7 +42,9 @@ module Mongoid
         # Is this association type embedded?
         #
         # @return [ true ] Always true.
-        def embedded?; true; end
+        def embedded?
+          true
+        end
 
         # The primary key
         #
@@ -54,12 +54,16 @@ module Mongoid
         # Does this association type store the foreign key?
         #
         # @return [ false ] Always false.
-        def stores_foreign_key?; false; end
+        def stores_foreign_key?
+          false
+        end
 
         # The default for validating the association object.
         #
         # @return [ false ] Always false.
-        def validation_default; false; end
+        def validation_default
+          false
+        end
 
         # The key that is used to get the attributes for the associated object.
         #
@@ -115,25 +119,24 @@ module Mongoid
         end
 
         def polymorphic_inverses(other = nil)
-          if other
-            matches = other.relations.values.select do |rel|
-              relation_complements.include?(rel.class) &&
-                  rel.as == name &&
-                  rel.relation_class_name == inverse_class_name
-            end
-
-            matches.map { |m| m.name }
+          return unless other
+
+          matches = other.relations.values.select do |rel|
+            relation_complements.include?(rel.class) &&
+              rel.as == name &&
+              rel.relation_class_name == inverse_class_name
           end
+
+          matches.map { |m| m.name }
         end
 
         def determine_inverses(other)
           matches = (other || relation_class).relations.values.select do |rel|
             relation_complements.include?(rel.class) &&
-                rel.relation_class_name == inverse_class_name
-          end
-          if matches.size > 1
-            raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches)
+              rel.relation_class_name == inverse_class_name
           end
+          raise Errors::AmbiguousRelationship.new(relation_class, @owner_class, name, matches) if matches.size > 1
+
           matches.collect { |m| m.name } unless matches.blank?
         end
       end

data/lib/mongoid/association/embedded/embeds_many/binding.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
       class EmbedsMany
-
         # Binding class for all embeds_many associations.
         class Binding
           include Bindable

data/lib/mongoid/association/embedded/embeds_many/buildable.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 module Mongoid
   module Association
     module Embedded
       class EmbedsMany
-
         # Builder class for embeds_many associations.
         module Buildable
           include Threaded::Lifecycle
@@ -27,9 +25,10 @@ module Mongoid
           #   will not be accessible in the built documents.
           #
           # @return [ Array<Document ] The documents.
-          def build(base, object, type = nil, selected_fields = nil)
+          def build(base, object, _type = nil, selected_fields = nil)
             return [] if object.blank?
             return object if object.first.is_a?(Document)
+
             docs = []
             object.each do |attrs|
               if _loading? && base.persisted?

data/lib/mongoid/association/embedded/embeds_many/proxy.rb

@@ -519,7 +519,7 @@ module Mongoid
           #
           # @return [ Criteria | Object ] A Criteria or return value from the target.
           #
-          # TODO: make sure we are consistingly using respond_to_missing
+          # TODO: make sure we are consistently using respond_to_missing
           #   anywhere we define method_missing.
           # rubocop:disable Style/MissingRespondToMissing
           ruby2_keywords def method_missing(name, *args, &block)
@@ -601,7 +601,12 @@ module Mongoid
           # @api private
           def update_attributes_hash
             if _target.empty?
-              _base.attributes.delete(_association.store_as)
+              # Only remove the key if it is absent or nil. If it is already
+              # an empty array, the caller explicitly set it to [] (e.g. via
+              # a raw write_attribute call), and that intent must be preserved
+              # so the empty array is persisted to the database.
+              stored = _association.store_as
+              _base.attributes.delete(stored) unless _base.attributes[stored] == []
             else
               _base.attributes.merge!(_association.store_as => _target.map(&:attributes))
             end