mongo 2.13.0.beta1 → 2.14.0

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

@@ -89,6 +89,16 @@ module Mongo
           self.class.new(view, pipeline, options.merge(explain: true)).first
         end
 
+        # Whether this aggregation will write its result to a database collection.
+        #
+        # @return [ Boolean ] Whether the aggregation will write its result
+        #   to a collection.
+        #
+        # @api private
+        def write?
+          pipeline.any? { |op| op.key?('$out') || op.key?(:$out) || op.key?('$merge') || op.key?(:$merge) }
+        end
+
         private
 
         def server_selector
@@ -114,10 +124,6 @@ module Mongo
           description.standalone? || description.mongos? || description.primary? || secondary_ok?
         end
 
-        def write?
-          pipeline.any? { |op| op.key?('$out') || op.key?(:$out) || op.key?('$merge') || op.key?(:$merge) }
-        end
-
         def secondary_ok?
           !write?
         end
@@ -136,6 +142,21 @@ module Mongo
             raise Error::UnsupportedCollation.new
           end
         end
+
+        # Skip, sort, limit, projection are specified as pipeline stages
+        # rather than as options.
+        def cache_options
+          {
+            namespace: collection.namespace,
+            selector: pipeline,
+            read_concern: view.read_concern,
+            read_preference: view.read_preference,
+            collation: options[:collation],
+            # Aggregations can read documents from more than one collection,
+            # so they will be cleared on every write operation.
+            multi_collection: true,
+          }
+        end
       end
     end
   end

data/lib/mongo/collection/view/builder/find_command.rb

@@ -52,21 +52,6 @@ module Mongo
             collation: 'collation'
           ).freeze
 
-          def_delegators :@view, :collection, :database, :filter, :options, :read
-
-          # Get the specification for an explain command that wraps the find
-          # command.
-          #
-          # @example Get the explain spec.
-          #   builder.explain_specification
-          #
-          # @return [ Hash ] The specification.
-          #
-          # @since 2.2.0
-          def explain_specification
-            { selector: { explain: find_command }, db_name: database.name, read: read, session: @session }
-          end
-
           # Create the find command builder.
           #
           # @example Create the find command builder.
@@ -81,6 +66,8 @@ module Mongo
             @session = session
           end
 
+          def_delegators :@view, :collection, :database, :filter, :options, :read
+
           # Get the specification to pass to the find command operation.
           #
           # @example Get the specification.
@@ -90,18 +77,51 @@ module Mongo
           #
           # @since 2.2.0
           def specification
-            { selector: find_command, db_name: database.name, read: read, session: @session }
+            {
+              selector: find_command,
+              db_name: database.name,
+              read: read,
+              session: @session,
+            }
+          end
+
+          # Get the specification for an explain command that wraps the find
+          # command.
+          #
+          # @example Get the explain spec.
+          #   builder.explain_specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def explain_specification
+            {
+              selector: {
+                explain: find_command,
+              },
+              db_name: database.name,
+              read: read,
+              session: @session,
+              # We should always have options{:explain] set if we are explaining.
+              # The explain field is not sent to the server, it will be
+              # processed in the operation layer.
+              explain: options[:explain],
+            }
           end
 
           private
 
           def find_command
-            document = BSON::Document.new('find' => collection.name, 'filter' => filter)
+            document = BSON::Document.new(
+              find: collection.name,
+              filter: filter,
+            )
             if collection.read_concern
               document[:readConcern] = Options::Mapper.transform_values_to_strings(
                 collection.read_concern)
             end
-            command = Options::Mapper.transform_documents(convert_flags(options), MAPPINGS, document)
+            command = Options::Mapper.transform_documents(
+              convert_flags(options), MAPPINGS, document)
             if command['oplogReplay']
               log_warn("oplogReplay is deprecated and ignored by MongoDB 4.4 and later")
             end

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

@@ -36,16 +36,25 @@ module Mongo
         # @since 2.2.0
         ALL_PLANS_EXECUTION = 'allPlansExecution'.freeze
 
-        # Get the explain plan for the query.
+        # Get the query plan for the query.
         #
-        # @example Get the explain plan for the query.
-        #   view.explain
+        # @example Get the query plan for the query with execution statistics.
+        #   view.explain(verbosity: :execution_stats)
         #
-        # @return [ Hash ] A single document with the explain plan.
+        # @option opts [ true | false ] :verbose The level of detail
+        #   to return for MongoDB 2.6 servers.
+        # @option opts [ String | Symbol ] :verbosity The type of information
+        #   to return for MongoDB 3.0 and newer servers. If the value is a
+        #   symbol, it will be stringified and converted from underscore
+        #   style to camel case style (e.g. :query_planner => "queryPlanner").
+        #
+        # @return [ Hash ] A single document with the query plan.
+        #
+        # @see https://docs.mongodb.com/manual/reference/method/db.collection.explain/#db.collection.explain
         #
         # @since 2.0.0
-        def explain
-          self.class.new(collection, selector, options.merge(explain_options)).first
+        def explain(**opts)
+          self.class.new(collection, selector, options.merge(explain_options(**opts))).first
         end
 
         private
@@ -54,9 +63,19 @@ module Mongo
           !!options[:explain]
         end
 
-        def explain_options
+        # @option opts [ true | false ] :verbose The level of detail
+        #   to return for MongoDB 2.6 servers.
+        # @option opts [ String | Symbol ] :verbosity The type of information
+        #   to return for MongoDB 3.0 and newer servers. If the value is a
+        #   symbol, it will be stringified and converted from underscore
+        #   style to camel case style (e.g. :query_planner => "queryPlanner").
+        def explain_options(**opts)
           explain_limit = limit || 0
-          { :limit => -explain_limit.abs, :explain => true }
+          # Note: opts will never be nil here.
+          if Symbol === opts[:verbosity]
+            opts[:verbosity] = Utils.camelize(opts[:verbosity])
+          end
+          { limit: -explain_limit.abs, explain: opts }
         end
       end
     end

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

@@ -35,19 +35,34 @@ module Mongo
         #
         # @yieldparam [ Hash ] Each matching document.
         def each
-          @cursor = nil
-          session = client.send(:get_session, @options)
-          @cursor = if respond_to?(:write?, true) && write?
-            server = server_selector.select_server(cluster, nil, session)
-            result = send_initial_query(server, session)
-            Cursor.new(view, result, server, session: session)
+          @cursor = if use_query_cache? && cached_cursor
+            cached_cursor
           else
-            read_with_retry_cursor(session, server_selector, view) do |server|
-              send_initial_query(server, session)
-            end
+            session = client.send(:get_session, @options)
+            select_cursor(session)
+          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.
+            limit_for_cached_query = respond_to?(:limit) ? limit : nil
           end
+
           if block_given?
-            @cursor.each do |doc|
+            # Ruby versions 2.5 and older do not support arr[0..nil] syntax, so
+            # this must be a separate conditional.
+            cursor_to_iterate = if limit_for_cached_query
+              @cursor.to_a[0...limit_for_cached_query]
+            else
+              @cursor
+            end
+
+            cursor_to_iterate.each do |doc|
               yield doc
             end
           else
@@ -77,6 +92,46 @@ module Mongo
 
         private
 
+        def select_cursor(session)
+          if respond_to?(:write?, true) && write?
+            server = server_selector.select_server(cluster, nil, session)
+            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
+              Cursor.new(view, result, server, session: session)
+            end
+          else
+            read_with_retry_cursor(session, server_selector, view) do |server|
+              send_initial_query(server, session)
+            end
+          end
+        end
+
+        def cached_cursor
+          QueryCache.get(**cache_options)
+        end
+
+        def cache_options
+          # NB: this hash is passed as keyword argument and must have symbol
+          # keys.
+          {
+            namespace: collection.namespace,
+            selector: selector,
+            skip: skip,
+            sort: sort,
+            limit: limit,
+            projection: projection,
+            collation: collation,
+            read_concern: read_concern,
+            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)
@@ -92,10 +147,11 @@ module Mongo
         end
 
         def initial_command_op(session)
+          builder = Builder::FindCommand.new(self, session)
           if explained?
-            Operation::Explain.new(Builder::FindCommand.new(self, session).explain_specification)
+            Operation::Explain.new(builder.explain_specification)
           else
-            Operation::Find.new(Builder::FindCommand.new(self, session).specification)
+            Operation::Find.new(builder.specification)
           end
         end
 
@@ -103,6 +159,10 @@ module Mongo
           validate_collation!(server, collation)
           initial_query_op(server, session).execute(server, client: client)
         end
+
+        def use_query_cache?
+          QueryCache.enabled? && !collection.system_collection?
+        end
       end
     end
   end

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

@@ -45,7 +45,17 @@ module Mongo
         #
         # @since 2.0.0
         def aggregate(pipeline, options = {})
-          Aggregation.new(self, pipeline, options)
+          aggregation = Aggregation.new(self, pipeline, options)
+
+          # Because the $merge and $out pipeline stages write documents to the
+          # collection, it is necessary to clear the cache when they are performed.
+          #
+          # Opt to clear the entire cache rather than one namespace because
+          # the $out and $merge stages do not have to write to the same namespace
+          # on which the aggregation is performed.
+          QueryCache.clear if aggregation.write?
+
+          aggregation
         end
 
         # Allows the server to write temporary data to disk while executing
@@ -90,7 +100,7 @@ module Mongo
         # @param [ Integer ] batch_size The size of each batch of results.
         #
         # @return [ Integer, View ] Either the batch_size value or a
-        # new +View+.
+        #   new +View+.
         #
         # @since 2.0.0
         def batch_size(batch_size = nil)
@@ -193,7 +203,9 @@ module Mongo
           pipeline << { :'$limit' => opts[:limit] } if opts[:limit]
           pipeline << { :'$group' => { _id: 1, n: { :'$sum' => 1 } } }
 
-          opts.select! { |k, _| [:hint, :max_time_ms, :read, :collation, :session].include?(k) }
+          opts = opts.select { |k, _| [:hint, :max_time_ms, :read, :collation, :session].include?(k) }
+          opts[:collation] ||= collation
+
           first = aggregate(pipeline, opts).first
           return 0 unless first
           first['n'].to_i
@@ -214,6 +226,10 @@ module Mongo
         #
         # @since 2.6.0
         def estimated_document_count(opts = {})
+          unless view.filter.empty?
+            raise ArgumentError, "Cannot call estimated_document_count when querying with a filter"
+          end
+
           cmd = { count: collection.name }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
           if read_concern

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

@@ -48,10 +48,15 @@ module Mongo
         #
         # @since 2.0.0
         def find_one_and_delete(opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           cmd = { :findAndModify => collection.name, :query => filter, :remove => true }
           cmd[:fields] = projection if projection
           cmd[:sort] = sort if sort
           cmd[:maxTimeMS] = max_time_ms if max_time_ms
+          if opts[:bypass_document_validation]
+            cmd[:bypassDocumentValidation] = true
+          end
 
           with_session(opts) do |session|
             applied_write_concern = applied_write_concern(session)
@@ -124,6 +129,8 @@ module Mongo
         #
         # @since 2.0.0
         def find_one_and_update(document, opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           cmd = { :findAndModify => collection.name, :query => filter }
           cmd[:update] = document
           cmd[:fields] = projection if projection
@@ -165,14 +172,22 @@ module Mongo
         # @option opts [ Session ] :session The session to use.
         # @option opts [ Hash | String ] :hint The index to use for this operation.
         #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
+        # @option opts [ Hash ] :write_concern The write concern options.
+        #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
         #
         # @return [ Result ] The response from the database.
         #
         # @since 2.0.0
         def delete_many(opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           delete_doc = { Operation::Q => filter, Operation::LIMIT => 0 }
           with_session(opts) do |session|
-            write_concern = write_concern_with_session(session)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
             nro_write_with_retry(session, write_concern) do |server|
               apply_collation!(delete_doc, server, opts)
               apply_hint!(delete_doc, server, opts.merge(write_concern: write_concern))
@@ -182,6 +197,7 @@ module Mongo
                   :db_name => collection.database.name,
                   :coll_name => collection.name,
                   :write_concern => write_concern,
+                  :bypass_document_validation => !!opts[:bypass_document_validation],
                   :session => session
               ).execute(server, client: client)
             end
@@ -199,14 +215,22 @@ module Mongo
         # @option opts [ Session ] :session The session to use.
         # @option opts [ Hash | String ] :hint The index to use for this operation.
         #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
+        # @option opts [ Hash ] :write_concern The write concern options.
+        #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
         #
         # @return [ Result ] The response from the database.
         #
         # @since 2.0.0
         def delete_one(opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           delete_doc = { Operation::Q => filter, Operation::LIMIT => 1 }
           with_session(opts) do |session|
-            write_concern = write_concern_with_session(session)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
             write_with_retry(session, write_concern) do |server, txn_num|
               apply_collation!(delete_doc, server, opts)
               apply_hint!(delete_doc, server, opts.merge(write_concern: write_concern))
@@ -216,6 +240,7 @@ module Mongo
                   :db_name => collection.database.name,
                   :coll_name => collection.name,
                   :write_concern => write_concern,
+                  :bypass_document_validation => !!opts[:bypass_document_validation],
                   :session => session,
                   :txn_num => txn_num
               ).execute(server, client: client)
@@ -239,11 +264,15 @@ module Mongo
         # @option opts [ Session ] :session The session to use.
         # @option opts [ Hash | String ] :hint The index to use for this operation.
         #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
+        # @option opts [ Hash ] :write_concern The write concern options.
+        #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
         #
         # @return [ Result ] The response from the database.
         #
         # @since 2.0.0
         def replace_one(replacement, opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           update_doc = { Operation::Q => filter,
                          Operation::U => replacement,
                         }
@@ -251,7 +280,12 @@ module Mongo
             update_doc['upsert'] = true
           end
           with_session(opts) do |session|
-            write_concern = write_concern_with_session(session)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
+
             write_with_retry(session, write_concern) do |server, txn_num|
               apply_collation!(update_doc, server, opts)
               apply_array_filters!(update_doc, server, opts)
@@ -288,11 +322,15 @@ module Mongo
         # @option opts [ Session ] :session The session to use.
         # @option opts [ Hash | String ] :hint The index to use for this operation.
         #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
+        # @option opts [ Hash ] :write_concern The write concern options.
+        #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
         #
         # @return [ Result ] The response from the database.
         #
         # @since 2.0.0
         def update_many(spec, opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           update_doc = { Operation::Q => filter,
                          Operation::U => spec,
                          Operation::MULTI => true,
@@ -301,7 +339,11 @@ module Mongo
             update_doc['upsert'] = true
           end
           with_session(opts) do |session|
-            write_concern = write_concern_with_session(session)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
             nro_write_with_retry(session, write_concern) do |server|
               apply_collation!(update_doc, server, opts)
               apply_array_filters!(update_doc, server, opts)
@@ -337,11 +379,15 @@ module Mongo
         # @option opts [ Session ] :session The session to use.
         # @option opts [ Hash | String ] :hint The index to use for this operation.
         #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
+        # @option opts [ Hash ] :write_concern The write concern options.
+        #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
         #
         # @return [ Result ] The response from the database.
         #
         # @since 2.0.0
         def update_one(spec, opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           update_doc = { Operation::Q => filter,
                          Operation::U => spec,
                          }
@@ -349,7 +395,11 @@ module Mongo
             update_doc['upsert'] = true
           end
           with_session(opts) do |session|
-            write_concern = write_concern_with_session(session)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
             write_with_retry(session, write_concern) do |server, txn_num|
               apply_collation!(update_doc, server, opts)
               apply_array_filters!(update_doc, server, opts)