mongo 2.15.0 → 2.18.1

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,10 +34,31 @@ 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 [ Object ] :comment A user-provided
+        #   comment to attach to this command.
+        # @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
         def aggregate(pipeline, options = {})
+          options = @options.merge(options) unless Mongo.broken_view_options
           aggregation = Aggregation.new(self, pipeline, options)
 
           # Because the $merge and $out pipeline stages write documents to the
@@ -118,7 +129,7 @@ module Mongo
         # @note Set profilingLevel to 2 and the comment will be logged in the profile
         #   collection along with the query.
         #
-        # @param [ String ] comment The comment to be associated with the query.
+        # @param [ Object ] comment The comment to be associated with the query.
         #
         # @return [ String, View ] Either the comment or a
         #   new +View+.
@@ -144,6 +155,8 @@ module Mongo
         # @option opts [ Hash ] :read The read preference options.
         # @option opts [ Hash ] :collation The collation to use.
         # @option opts [ Mongo::Session ] :session The session to use for the operation.
+        # @option opts [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @return [ Integer ] The document count.
         #
@@ -155,6 +168,7 @@ module Mongo
         #     * $near should be replaced with $geoWithin with $center
         #     * $nearSphere should be replaced with $geoWithin with $centerSphere
         def count(opts = {})
+          opts = @options.merge(opts) unless Mongo.broken_view_options
           cmd = { :count => collection.name, :query => filter }
           cmd[:skip] = opts[:skip] if opts[:skip]
           cmd[:hint] = opts[:hint] if opts[:hint]
@@ -169,13 +183,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::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,
+                comment: opts[:comment],
               ).execute(server, context: Operation::Context.new(client: client, session: session))
             end.n.to_i
           end
@@ -196,17 +213,21 @@ module Mongo
         #   command to run.
         # @option opts [ Hash ] :read The read preference options.
         # @option opts [ Hash ] :collation The collation to use.
+        # @option opts [ Mongo::Session ] :session The session to use for the operation.
+        # @option ops [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @return [ Integer ] The document count.
         #
         # @since 2.6.0
         def count_documents(opts = {})
+          opts = @options.merge(opts) unless Mongo.broken_view_options
           pipeline = [:'$match' => filter]
           pipeline << { :'$skip' => opts[:skip] } if opts[:skip]
           pipeline << { :'$limit' => opts[:limit] } if opts[:limit]
           pipeline << { :'$group' => { _id: 1, n: { :'$sum' => 1 } } }
 
-          opts = opts.select { |k, _| [:hint, :max_time_ms, :read, :collation, :session].include?(k) }
+          opts = opts.slice(:hint, :max_time_ms, :read, :collation, :session, :comment)
           opts[:collation] ||= collation
 
           first = aggregate(pipeline, opts).first
@@ -224,6 +245,8 @@ module Mongo
         # @option opts :max_time_ms [ Integer ] The maximum amount of time to allow the command to
         #   run.
         # @option opts [ Hash ] :read The read preference options.
+        # @option opts [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @return [ Integer ] The document count.
         #
@@ -234,42 +257,34 @@ module Mongo
           end
 
           %i[limit skip].each do |opt|
-            if @options.key?(opt)
+            if options.key?(opt) || opts.key?(opt)
               raise ArgumentError, "Cannot call estimated_document_count when querying with #{opt}"
             end
           end
 
+          opts = @options.merge(opts) unless Mongo.broken_view_options
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           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|
-              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
-                result = Operation::Aggregate.new(spec).execute(server, context: context)
-                result.documents.first.fetch('n')
-              else
-                cmd = { count: collection.name }
-                cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-                if read_concern
-                  cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
-                    read_concern)
+              context = Operation::Context.new(client: client, session: session)
+              cmd = { count: collection.name }
+              cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
+              if read_concern
+                cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+                  read_concern)
                 end
                 result = Operation::Count.new(
                   selector: cmd,
                   db_name: database.name,
                   read: read_pref,
                   session: session,
+                  comment: opts[:comment],
                 ).execute(server, context: context)
                 result.n.to_i
               end
             end
-          end
         rescue Error::OperationFailure => exc
           if exc.code == 26
             # NamespaceNotFound
@@ -294,6 +309,8 @@ module Mongo
         #   command to run.
         # @option opts [ Hash ] :read The read preference options.
         # @option opts [ Hash ] :collation The collation to use.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @return [ Array<Object> ] The list of distinct values.
         #
@@ -302,9 +319,10 @@ module Mongo
           if field_name.nil?
             raise ArgumentError, 'Field name for distinct operation must be not nil'
           end
+          opts = @options.merge(opts) unless Mongo.broken_view_options
           cmd = { :distinct => collection.name,
                   :key => field_name.to_s,
-                  :query => filter }
+                  :query => filter, }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
           if read_concern
             cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
@@ -315,14 +333,17 @@ 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,
+                comment: opts[:comment],
+                # 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 +563,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 +578,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 +673,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,
+              connection_global_id: result.connection_global_id,
+            )
+            result = op.execute(server, context: context)
             Cursor.new(self, result, server, session: session)
           end
         end