mongo 2.15.0 → 2.17.0

data/lib/mongo/collection/view/iterable.rb

@@ -25,6 +25,13 @@ module Mongo
       # @since 2.0.0
       module Iterable
 
+        # Returns the cursor associated with this view, if any.
+        #
+        # @return [ nil | Cursor ] The cursor, if any.
+        #
+        # @api private
+        attr_reader :cursor
+
         # Iterate through documents returned by a query with this +View+.
         #
         # @example Iterate through the result of the view.
@@ -38,18 +45,28 @@ module Mongo
         #
         # @yieldparam [ Hash ] Each matching document.
         def each
-          @cursor = if use_query_cache? && cached_cursor
+          # If the caching cursor is closed and was not fully iterated,
+          # the documents we have in it are not the complete result set and
+          # we have no way of completing that iteration.
+          # Therefore, discard that cursor and start iteration again.
+          # The case of the caching cursor not being closed and not having
+          # been fully iterated isn't tested - see RUBY-2773.
+          @cursor = if use_query_cache? && cached_cursor && (
+            cached_cursor.fully_iterated? || !cached_cursor.closed?
+          )
             cached_cursor
           else
             session = client.send(:get_session, @options)
-            select_cursor(session)
+            select_cursor(session).tap do |cursor|
+              if use_query_cache?
+                # No need to store the cursor in the query cache if there is
+                # already a cached cursor stored at this key.
+                QueryCache.set(cursor, **cache_options)
+              end
+            end
           end
 
           if use_query_cache?
-            # No need to store the cursor in the query cache if there is
-            # already a cached cursor stored at this key.
-            QueryCache.set(@cursor, **cache_options) unless cached_cursor
-
             # If a query with a limit is performed, the query cache will
             # re-use results from an earlier query with the same or larger
             # limit, and then impose the lower limit during iteration.
@@ -97,11 +114,9 @@ module Mongo
 
         def select_cursor(session)
           if respond_to?(:write?, true) && write?
-            server = server_selector.select_server(cluster, nil, session)
+            server = server_selector.select_server(cluster, nil, session, write_aggregation: true)
             result = send_initial_query(server, session)
 
-            # RUBY-2367: This will be updated to allow the query cache to
-            # cache cursors with multi-batch results.
             if use_query_cache?
               CachingCursor.new(view, result, server, session: session)
             else
@@ -130,36 +145,54 @@ module Mongo
             projection: projection,
             collation: collation,
             read_concern: read_concern,
-            read_preference: read_preference
-
+            read_preference: read_preference,
           }
         end
 
         def initial_query_op(server, session)
-          if server.with_connection { |connection| connection.features }.find_command_enabled?
-            initial_command_op(session)
-          else
-            # Server versions that do not have the find command feature
-            # (versions older than 3.2) do not support the allow_disk_use option
-            # but perform no validation and will not raise an error if it is
-            # specified. If the allow_disk_use option is specified, raise an error
-            # to alert the user.
-            raise Error::UnsupportedOption.allow_disk_use_error if options.key?(:allow_disk_use)
-            Operation::Find.new(Builder::OpQuery.new(self).specification)
+          spec = {
+            coll_name: collection.name,
+            filter: filter,
+            projection: projection,
+            db_name: database.name,
+            session: session,
+            collation: collation,
+            sort: sort,
+            skip: skip,
+            let: options[:let],
+            limit: limit,
+            allow_disk_use: options[:allow_disk_use],
+            read: read,
+            read_concern: options[:read_concern] || read_concern,
+            batch_size: batch_size,
+            hint: options[:hint],
+            max_scan: options[:max_scan],
+            max_time_ms: options[:max_time_ms],
+            max_value: options[:max_value],
+            min_value: options[:min_value],
+            return_key: options[:return_key],
+            show_disk_loc: options[:show_disk_loc],
+            comment: options[:comment],
+            oplog_replay: if (v = options[:oplog_replay]).nil?
+              collection.options[:oplog_replay]
+            else
+              v
+            end,
+          }
+
+          if spec[:oplog_replay]
+            collection.client.log_warn("The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later")
           end
-        end
 
-        def initial_command_op(session)
-          builder = Builder::FindCommand.new(self, session)
           if explained?
-            Operation::Explain.new(builder.explain_specification)
+            spec[:explain] = options[:explain]
+            Operation::Explain.new(spec)
           else
-            Operation::Find.new(builder.specification)
+            Operation::Find.new(spec)
           end
         end
 
         def send_initial_query(server, session = nil)
-          validate_collation!(server, collation)
           initial_query_op(server, session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 

data/lib/mongo/collection/view/map_reduce.rb

@@ -115,6 +115,8 @@ module Mongo
           @map_function = map.dup.freeze
           @reduce_function = reduce.dup.freeze
           @options = BSON::Document.new(options).freeze
+
+          client.log_warn('The map_reduce operation is deprecated, please use the aggregation pipeline instead')
         end
 
         # Set or get the jsMode flag for the operation.
@@ -156,6 +158,28 @@ module Mongo
           configure(:out, location)
         end
 
+        # Returns the collection name where the map-reduce result is written to.
+        # If the result is returned inline, returns nil.
+        def out_collection_name
+          if options[:out].respond_to?(:keys)
+            options[:out][OUT_ACTIONS.find do |action|
+              options[:out][action]
+            end]
+          end || options[:out]
+        end
+
+        # Returns the database name where the map-reduce result is written to.
+        # If the result is returned inline, returns nil.
+        def out_database_name
+          if options[:out]
+            if options[:out].respond_to?(:keys) && (db = options[:out][:db])
+              db
+            else
+              database.name
+            end
+          end
+        end
+
         # Set or get a scope on the operation.
         #
         # @example Set the scope value.
@@ -207,6 +231,8 @@ module Mongo
 
         private
 
+        OUT_ACTIONS = [ :replace, :merge, :reduce ].freeze
+
         def server_selector
           @view.send(:server_selector)
         end
@@ -228,10 +254,12 @@ module Mongo
         end
 
         def valid_server?(server)
-          description = server.with_connection do |connection|
-            connection.description
+          if secondary_ok?
+            true
+          else
+            description = server.description
+            description.standalone? || description.mongos? || description.primary? || description.load_balancer?
           end
-          description.standalone? || description.mongos? || description.primary? || secondary_ok?
         end
 
         def secondary_ok?
@@ -244,7 +272,6 @@ module Mongo
             log_warn(msg)
             server = cluster.next_primary(nil, session)
           end
-          validate_collation!(server)
           initial_query_op(session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
 
@@ -257,22 +284,21 @@ module Mongo
         end
 
         def fetch_query_op(server, session)
-          if server.with_connection { |connection| connection.features }.find_command_enabled?
-            Operation::Find.new(find_command_spec(session))
-          else
-            Operation::Find.new(fetch_query_spec)
-          end
+          spec = {
+            coll_name: out_collection_name,
+            db_name: out_database_name,
+            filter: {},
+            session: session,
+            read: read,
+            read_concern: options[:read_concern] || collection.read_concern,
+            collation: options[:collation] || view.options[:collation],
+          }
+          Operation::Find.new(spec)
         end
 
         def send_fetch_query(server, session)
           fetch_query_op(server, session).execute(server, context: Operation::Context.new(client: client, session: session))
         end
-
-        def validate_collation!(server)
-          if (view.options[:collation] || options[:collation]) && !server.with_connection { |connection| connection.features }.collation_enabled?
-            raise Error::UnsupportedCollation.new
-          end
-        end
       end
     end
   end

data/lib/mongo/collection/view/readable.rb

@@ -24,16 +24,6 @@ module Mongo
       # @since 2.0.0
       module Readable
 
-        # The query modifier constant.
-        #
-        # @since 2.2.0
-        QUERY = '$query'.freeze
-
-        # The modifiers option constant.
-        #
-        # @since 2.2.0
-        MODIFIERS = 'modifiers'.freeze
-
         # Execute an aggregation on the collection view.
         #
         # @example Aggregate documents.
@@ -44,6 +34,25 @@ module Mongo
         # @param [ Array<Hash> ] pipeline The aggregation pipeline.
         # @param [ Hash ] options The aggregation options.
         #
+        # @option options [ true, false ] :allow_disk_use Set to true if disk
+        #   usage is allowed during the aggregation.
+        # @option options [ Integer ] :batch_size The number of documents to return
+        #   per batch.
+        # @option options [ true, false ] :bypass_document_validation Whether or
+        #   not to skip document level validation.
+        # @option options [ Hash ] :collation The collation to use.
+        # @option options [ String ] :comment Associate a comment with the aggregation.
+        # @option options [ String ] :hint The index to use for the aggregation.
+        # @option options [ Hash ] :let Mapping of variables to use in the pipeline.
+        #   See the server documentation for details.
+        # @option options [ Integer ] :max_time_ms The maximum amount of time in
+        #   milliseconds to allow the aggregation to run.
+        # @option options [ true, false ] :use_cursor Indicates whether the command
+        #   will request that the server provide results using a cursor. Note that
+        #   as of server version 3.6, aggregations always provide results using a
+        #   cursor and this option is therefore not valid.
+        # @option options [ Session ] :session The session to use.
+        #
         # @return [ Aggregation ] The aggregation object.
         #
         # @since 2.0.0
@@ -169,13 +178,15 @@ module Mongo
           selector = ServerSelector.get(read_pref || server_selector)
           with_session(opts) do |session|
             read_with_retry(session, selector) do |server|
-              apply_collation!(cmd, server, opts)
               Operation::Count.new(
-                                     :selector => cmd,
-                                     :db_name => database.name,
-                                     :options => {:limit => -1},
-                                     :read => read_pref,
-                                     :session => session,
+                selector: cmd,
+                db_name: database.name,
+                options: {:limit => -1},
+                read: read_pref,
+                session: session,
+                # For some reason collation was historically accepted as a
+                # string key. Note that this isn't documented as valid usage.
+                collation: opts[:collation] || opts['collation'] || collation,
               ).execute(server, context: Operation::Context.new(client: client, session: session))
             end.n.to_i
           end
@@ -243,14 +254,18 @@ module Mongo
           read_pref = opts[:read] || read_preference
           selector = ServerSelector.get(read_pref || server_selector)
           with_session(opts) do |session|
-            context = Operation::Context.new(client: client, session: session)
             read_with_retry(session, selector) do |server|
+              context = Operation::Context.new(client: client, session: session)
               if server.description.server_version_gte?('5.0')
                 pipeline = [
                   {'$collStats' => {'count' => {}}},
                   {'$group' => {'_id' => 1, 'n' => {'$sum' => '$count'}}},
                 ]
-                spec = Builder::Aggregation.new(pipeline, self, options.merge(session: session)).specification
+                spec = Builder::Aggregation.new(
+                  pipeline,
+                  self,
+                  options.merge(session: session)
+                ).specification
                 result = Operation::Aggregate.new(spec).execute(server, context: context)
                 result.documents.first.fetch('n')
               else
@@ -315,14 +330,16 @@ module Mongo
           selector = ServerSelector.get(read_pref || server_selector)
           with_session(opts) do |session|
             read_with_retry(session, selector) do |server|
-              apply_collation!(cmd, server, opts)
-              Operation::Distinct.new({
-                                        :selector => cmd,
-                                        :db_name => database.name,
-                                        :options => {:limit => -1},
-                                        :read => read_pref,
-                                        :session => session,
-                                       }).execute(server, context: Operation::Context.new(client: client, session: session))
+              Operation::Distinct.new(
+                selector: cmd,
+                db_name: database.name,
+                options: {:limit => -1},
+                read: read_pref,
+                session: session,
+                # For some reason collation was historically accepted as a
+                # string key. Note that this isn't documented as valid usage.
+                collation: opts[:collation] || opts['collation'] || collation,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end.first['values']
           end
         end
@@ -542,7 +559,11 @@ module Mongo
           configure(:sort, spec)
         end
 
-        # “meta” operators that let you modify the output or behavior of a query.
+        # If called without arguments or with a nil argument, returns
+        # the legacy (OP_QUERY) server modifiers for the current view.
+        # If called with a non-nil argument, which must be a Hash or a
+        # subclass, merges the provided modifiers into the current view.
+        # Both string and symbol keys are allowed in the input hash.
         #
         # @example Set the modifiers document.
         #   view.modifiers(:$orderby => Mongo::Index::ASCENDING)
@@ -553,8 +574,11 @@ module Mongo
         #
         # @since 2.1.0
         def modifiers(doc = nil)
-          return Builder::Modifiers.map_server_modifiers(options) if doc.nil?
-          new(options.merge(Builder::Modifiers.map_driver_options(doc)))
+          if doc.nil?
+            Operation::Find::Builder::Modifiers.map_server_modifiers(options)
+          else
+            new(options.merge(Operation::Find::Builder::Modifiers.map_driver_options(BSON::Document.new(doc))))
+          end
         end
 
         # A cumulative time limit in milliseconds for processing get more operations
@@ -645,34 +669,42 @@ module Mongo
 
         def parallel_scan(cursor_count, options = {})
           if options[:session]
+            # The session would be overwritten by the one in +options+ later.
             session = client.send(:get_session, @options)
           else
             session = nil
           end
           server = server_selector.select_server(cluster, nil, session)
-          cmd = Operation::ParallelScan.new({
-                  :coll_name => collection.name,
-                  :db_name => database.name,
-                  :cursor_count => cursor_count,
-                  :read_concern => read_concern,
-                  :session => session,
-                }.merge!(options))
-          cmd.execute(server, context: Operation::Context.new(client: client, session: session)).cursor_ids.map do |cursor_id|
-            result = if server.with_connection { |connection| connection.features }.find_command_enabled?
-              Operation::GetMore.new({
-                :selector => {:getMore => BSON::Int64.new(cursor_id),
-                             :collection => collection.name},
-                :db_name => database.name,
-                :session => session,
-              }).execute(server, context: Operation::Context.new(client: client, session: session))
-             else
-              Operation::GetMore.new({
-                :to_return => 0,
-                :cursor_id => BSON::Int64.new(cursor_id),
-                :db_name => database.name,
-                :coll_name => collection.name
-              }).execute(server, context: Operation::Context.new(client: client, session: session))
-            end
+          spec = {
+            coll_name: collection.name,
+            db_name: database.name,
+            cursor_count: cursor_count,
+            read_concern: read_concern,
+            session: session,
+          }.update(options)
+          session = spec[:session]
+          op = Operation::ParallelScan.new(spec)
+          # Note that the context object shouldn't be reused for subsequent
+          # GetMore operations.
+          context = Operation::Context.new(client: client, session: session)
+          result = op.execute(server, context: context)
+          result.cursor_ids.map do |cursor_id|
+            spec = {
+              cursor_id: cursor_id,
+              coll_name: collection.name,
+              db_name: database.name,
+              session: session,
+              batch_size: batch_size,
+              to_return: 0,
+              # max_time_ms is not being passed here, I assume intentionally?
+            }
+            op = Operation::GetMore.new(spec)
+            context = Operation::Context.new(
+              client: client,
+              session: session,
+              service_id: result.connection_description.service_id,
+            )
+            result = op.execute(server, context: context)
             Cursor.new(self, result, server, session: session)
           end
         end