mongo 2.13.2 → 2.14.0.rc1

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)

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

@@ -48,6 +48,8 @@ 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
@@ -127,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
@@ -175,6 +179,8 @@ module Mongo
         #
         # @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 = if opts[:write_concern]
@@ -191,7 +197,7 @@ module Mongo
                   :db_name => collection.database.name,
                   :coll_name => collection.name,
                   :write_concern => write_concern,
-                  :bypass_document_validation => !!opts[:bypass_document_validation], 
+                  :bypass_document_validation => !!opts[:bypass_document_validation],
                   :session => session
               ).execute(server, client: client)
             end
@@ -216,6 +222,8 @@ module Mongo
         #
         # @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 = if opts[:write_concern]
@@ -263,6 +271,8 @@ module Mongo
         #
         # @since 2.0.0
         def replace_one(replacement, opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           update_doc = { Operation::Q => filter,
                          Operation::U => replacement,
                         }
@@ -319,6 +329,8 @@ module Mongo
         #
         # @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,
@@ -374,6 +386,8 @@ module Mongo
         #
         # @since 2.0.0
         def update_one(spec, opts = {})
+          QueryCache.clear_namespace(collection.namespace)
+
           update_doc = { Operation::Q => filter,
                          Operation::U => spec,
                          }

data/lib/mongo/crypt/encryption_io.rb

@@ -21,7 +21,7 @@ module Mongo
     # @api private
     class EncryptionIO
 
-      # Timeout used for SSL socket connection, reading, and writing.
+      # Timeout used for TLS socket connection, reading, and writing.
       # There is no specific timeout written in the spec. See SPEC-1394
       # for a discussion and updates on what this timeout should be.
       SOCKET_TIMEOUT = 10
@@ -236,10 +236,10 @@ module Mongo
         end
       end
 
-      # Provide an SSL socket to be used for KMS calls in a block API
+      # Provide a TLS socket to be used for KMS calls in a block API
       #
-      # @param [ String ] endpoint The URI at which to connect the SSL socket.
-      # @yieldparam [ OpenSSL::SSL::SSLSocket ] ssl_socket Yields an SSL socket
+      # @param [ String ] endpoint The URI at which to connect the TLS socket.
+      # @yieldparam [ OpenSSL::SSL::SSLSocket ] ssl_socket Yields a TLS socket
       #   connected to the specified endpoint.
       #
       # @raise [ Mongo::Error::KmsError ] If the socket times out or raises
@@ -277,7 +277,7 @@ module Mongo
               Timeout.timeout(
                 SOCKET_TIMEOUT,
                 Error::SocketTimeoutError,
-                'KMS SSL socket close timed out'
+                'KMS TLS socket close timed out'
               ) do
                 ssl_socket.sysclose
               end
@@ -285,7 +285,7 @@ module Mongo
             end
           end
         ensure
-          # Still close tcp socket manually in case ssl socket creation
+          # Still close tcp socket manually in case TLS socket creation
           # fails.
           begin
             Timeout.timeout(

data/lib/mongo/cursor.rb

@@ -138,6 +138,7 @@ module Mongo
     #
     # @since 2.0.0
     def each
+
       # If we already iterated past the first batch (i.e., called get_more
       # at least once), the cursor on the server side has advanced past
       # the first batch and restarting iteration from the beginning by