mongo 2.23.0 → 2.24.0

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -20,7 +19,6 @@ require 'mongo/cursor_host'
 module Mongo
   class Collection
     class View
-
       # Defines iteration related behavior for collection views, including
       # cursor instantiation.
       #
@@ -40,23 +38,22 @@ module Mongo
         # @since 2.0.0
         #
         # @yieldparam [ Hash ] Each matching document.
-        def each
+        def each(&block)
           @cursor = prefer_cached_cursor? ? cached_cursor : new_cursor_for_iteration
           return @cursor.to_enum unless block_given?
 
           limit_for_cached_query = compute_limit_for_cached_query
 
-          # Ruby versions 2.5 and older do not support arr[0..nil] syntax, so
-          # this must be a separate conditional.
+          # TODO: rather than pulling the entire (limited) result set into
+          # memory, this should tell the cursor about the limit and then let
+          # the cursor limit the iteration as necessary.
           cursor_to_iterate = if limit_for_cached_query
-            @cursor.to_a[0...limit_for_cached_query]
-          else
-            @cursor
-          end
+                                @cursor.to_a[0...limit_for_cached_query]
+                              else
+                                @cursor
+                              end
 
-          cursor_to_iterate.each do |doc|
-            yield doc
-          end
+          cursor_to_iterate.each(&block)
         end
 
         # Cleans up resources associated with this query.
@@ -73,11 +70,11 @@ module Mongo
         #
         # @since 2.1.0
         def close_query
-          if @cursor
-            @cursor.close
-          end
+          return unless @cursor
+
+          @cursor.close
         end
-        alias :kill_cursors :close_query
+        alias kill_cursors close_query
 
         private
 
@@ -91,13 +88,16 @@ module Mongo
           op = initial_query_op(session)
           tracer.trace_operation(op, context) do
             if respond_to?(:write?, true) && write?
-              server = server_selector.select_server(cluster, nil, session, write_aggregation: true)
-              result = send_initial_query(server, context, operation: op)
-
-              if use_query_cache?
-                CachingCursor.new(view, result, server, session: session, context: context)
-              else
-                Cursor.new(view, result, server, session: session, context: context)
+              retry_enabled = collection.client.options[:retry_writes] != false
+              with_overload_retry(context: context, retry_enabled: retry_enabled) do
+                server = server_selector.select_server(cluster, nil, session, write_aggregation: true)
+                result = send_initial_query(server, context, operation: op)
+
+                if use_query_cache?
+                  CachingCursor.new(view, result, server, session: session, context: context)
+                else
+                  Cursor.new(view, result, server, session: session, context: context)
+                end
               end
             else
               read_with_retry_cursor(session, server_selector, view, context: context) do |server|
@@ -156,7 +156,7 @@ module Mongo
           }
 
           if spec[:oplog_replay]
-            collection.client.log_warn("The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later")
+            collection.client.log_warn('The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later')
           end
 
           maybe_set_tailable_options(spec)
@@ -172,8 +172,15 @@ module Mongo
         def send_initial_query(server, context, operation: nil)
           operation ||= initial_query_op(context.session)
           if server.load_balancer?
-            # Connection will be checked in when cursor is drained.
-            connection = server.pool.check_out(context: context)
+            # Connection will be checked in when cursor is drained,
+            # unless the connection is pinned to a transaction (in which
+            # case it stays checked out for the transaction duration).
+            if context.connection_global_id
+              connection = server.pool.check_out_pinned_connection(
+                context.connection_global_id
+              )
+            end
+            connection ||= server.pool.check_out(context: context)
             operation.execute_with_connection(connection, context: context)
           else
             operation.execute(server, context: context)
@@ -212,10 +219,10 @@ module Mongo
           # 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.
-          return QueryCache.normalized_limit(limit)
+          QueryCache.normalized_limit(limit)
         end
 
-        # Add tailable cusror options to the command specifiction if needed.
+        # Add tailable cursor options to the command specification if needed.
         #
         # @param [ Hash ] spec The command specification.
         def maybe_set_tailable_options(spec)

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -18,7 +17,6 @@
 module Mongo
   class Collection
     class View
-
       # Provides behavior around a map/reduce operation on the collection
       # view.
       #
@@ -33,13 +31,13 @@ module Mongo
         # The inline option.
         #
         # @since 2.1.0
-        INLINE = 'inline'.freeze
+        INLINE = 'inline'
 
         # Reroute message.
         #
         # @since 2.1.0
         # @deprecated
-        REROUTE = 'Rerouting the MapReduce operation to the primary server.'.freeze
+        REROUTE = 'Rerouting the MapReduce operation to the primary server'
 
         # @return [ View ] view The collection view.
         attr_reader :view
@@ -68,11 +66,12 @@ module Mongo
         # @since 2.0.0
         #
         # @yieldparam [ Hash ] Each matching document.
-        def each
+        def each(&block)
           @cursor = nil
           session = client.get_session(@options)
           server = cluster.next_primary(nil, session)
-          context = Operation::Context.new(client: client, session: session, operation_timeouts: view.operation_timeouts)
+          context = Operation::Context.new(client: client, session: session,
+                                           operation_timeouts: view.operation_timeouts)
           if server.load_balancer?
             # Connection will be checked in when cursor is drained.
             connection = server.pool.check_out(context: context)
@@ -84,9 +83,7 @@ module Mongo
           end
           @cursor = Cursor.new(view, result, server, session: session)
           if block_given?
-            @cursor.each do |doc|
-              yield doc
-            end
+            @cursor.each(&block)
           else
             @cursor.to_enum
           end
@@ -124,7 +121,8 @@ module Mongo
           @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')
+          Deprecations.warn(:map_reduce,
+                            'The map_reduce operation is deprecated, please use the aggregation pipeline instead.')
         end
 
         # Set or get the jsMode flag for the operation.
@@ -179,12 +177,12 @@ module Mongo
         # 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
+          return unless options[:out]
+
+          if options[:out].respond_to?(:keys) && (db = options[:out][:db])
+            db
+          else
+            database.name
           end
         end
 
@@ -232,7 +230,7 @@ module Mongo
           view.send(:with_session, @options) do |session|
             write_concern = view.write_concern_with_session(session)
             context = Operation::Context.new(client: client, session: session)
-            nro_write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+            nro_write_with_retry(write_concern, context: context) do |connection, _txn_num, context|
               send_initial_query_with_connection(connection, session, context: context)
             end
           end
@@ -240,7 +238,7 @@ module Mongo
 
         private
 
-        OUT_ACTIONS = [ :replace, :merge, :reduce ].freeze
+        OUT_ACTIONS = %i[replace merge reduce].freeze
 
         def server_selector
           @view.send(:server_selector)
@@ -276,11 +274,7 @@ module Mongo
         end
 
         def valid_server?(description)
-          if secondary_ok?
-            true
-          else
-            description.standalone? || description.mongos? || description.primary? || description.load_balancer?
-          end
+          secondary_ok? || description.standalone? || description.mongos? || description.primary? || description.load_balancer?
         end
 
         def secondary_ok?
@@ -298,7 +292,7 @@ module Mongo
           if valid_server?(connection.description)
             op.execute_with_connection(connection, context: context)
           else
-            msg = "Rerouting the MapReduce operation to the primary server - #{connection.address} is not suitable because it is not currently the primray"
+            msg = "#{REROUTE} - #{connection.address} is not suitable because it is not currently the primary"
             log_warn(msg)
             server = cluster.next_primary(nil, session)
             op.execute(server, context: context)
@@ -310,7 +304,8 @@ module Mongo
         end
 
         def find_command_spec(session)
-          Builder::MapReduce.new(map_function, reduce_function, view, options.merge(session: session)).command_specification
+          Builder::MapReduce.new(map_function, reduce_function, view,
+                                 options.merge(session: session)).command_specification
         end
 
         def fetch_query_op(session)

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -18,12 +17,10 @@
 module Mongo
   class Collection
     class View
-
       # Defines read related behavior for collection view.
       #
       # @since 2.0.0
       module Readable
-
         # Execute an aggregation on the collection view.
         #
         # @example Aggregate documents.
@@ -169,18 +166,19 @@ module Mongo
         #
         # @deprecated Use #count_documents or #estimated_document_count instead. However, note that
         #   the following operators will need to be substituted when switching to #count_documents:
-        #     * $where should be replaced with $expr (only works on 3.6+)
+        #     * $where should be replaced with $expr
         #     * $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 = { count: collection.name, query: filter }
           cmd[:skip] = opts[:skip] if opts[:skip]
           cmd[:hint] = opts[:hint] if opts[:hint]
           cmd[:limit] = opts[:limit] if opts[:limit]
           if read_concern
             cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
-              read_concern)
+              read_concern
+            )
           end
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
@@ -195,13 +193,13 @@ module Mongo
             operation = Operation::Count.new(
               selector: cmd,
               db_name: database.name,
-              options: {:limit => -1},
+              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],
+              comment: opts[:comment]
             )
             tracer.trace_operation(operation, context) do
               read_with_retry(session, selector, context) do |server|
@@ -223,7 +221,7 @@ module Mongo
         #
         # @option opts :skip [ Integer ] The number of documents to skip.
         # @option opts :hint [ Hash ] Override default index selection and force
-        #   MongoDB to use a specific index for the query. Requires server version 3.6+.
+        #   MongoDB to use a specific index for the query.
         # @option opts :limit [ Integer ] Max number of docs to count.
         # @option opts :max_time_ms [ Integer ] The maximum amount of time to allow the
         #   command to run. This option is deprecated, use
@@ -231,7 +229,7 @@ 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 ops [ Object ] :comment A user-provided
+        # @option opts [ Object ] :comment A user-provided
         #   comment to attach to this command.
         # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
         #    Must be a non-negative integer. An explicit value of 0 means infinite.
@@ -243,16 +241,17 @@ module Mongo
         # @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 } } }
+          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.slice(:hint, :max_time_ms, :read, :collation, :session, :comment, :timeout_ms)
           opts[:collation] ||= collation
 
           first = aggregate(pipeline, opts).first
           return 0 unless first
+
           first['n'].to_i
         end
 
@@ -278,7 +277,7 @@ 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"
+            raise ArgumentError, 'Cannot call estimated_document_count when querying with a filter'
           end
 
           %i[limit skip].each do |opt|
@@ -299,31 +298,27 @@ module Mongo
             )
             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
+            cmd[:readConcern] = Options::Mapper.transform_values_to_strings(read_concern) if read_concern
             operation = Operation::Count.new(
               selector: cmd,
               db_name: database.name,
               read: read_pref,
               session: session,
-              comment: opts[:comment],
+              comment: opts[:comment]
             )
             tracer.trace_operation(operation, context, op_name: 'estimatedDocumentCount') do
               read_with_retry(session, selector, context) do |server|
                 result = operation.execute(server, context: context)
                 result.n.to_i
               end
-            rescue Error::OperationFailure::Family => exc
-              if exc.code == 26
-                # NamespaceNotFound
-                # This should only happen with the aggregation pipeline path
-                # (server 4.9+). Previous servers should return 0 for nonexistent
-                # collections.
-                0
-              else
-                raise
-              end
+            rescue Error::OperationFailure::Family => e
+              raise unless e.code == 26
+
+              # NamespaceNotFound
+              # This should only happen with the aggregation pipeline path
+              # (server 4.9+). Previous servers should return 0 for nonexistent
+              # collections.
+              0
             end
           end
         end
@@ -347,17 +342,17 @@ module Mongo
         #
         # @since 2.0.0
         def distinct(field_name, opts = {})
-          if field_name.nil?
-            raise ArgumentError, 'Field name for distinct operation must be not nil'
-          end
+          raise ArgumentError, 'Field name for distinct operation must be not nil' if field_name.nil?
+
           opts = @options.merge(opts) unless Mongo.broken_view_options
-          cmd = { :distinct => collection.name,
-                  :key => field_name.to_s,
-                  :query => filter, }
+          cmd = { distinct: collection.name,
+                  key: field_name.to_s,
+                  query: filter, }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
           if read_concern
             cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
-              read_concern)
+              read_concern
+            )
           end
           Mongo::Lint.validate_underscore_read_preference(opts[:read])
           read_pref = opts[:read] || read_preference
@@ -371,13 +366,13 @@ module Mongo
             operation = Operation::Distinct.new(
               selector: cmd,
               db_name: database.name,
-              options: {:limit => -1},
+              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,
+              collation: opts[:collation] || opts['collation'] || collation
             )
             tracer.trace_operation(operation, context) do
               read_with_retry(session, selector, context) do |server|
@@ -524,6 +519,7 @@ module Mongo
         # @since 2.0.0
         def read(value = nil)
           return read_preference if value.nil?
+
           configure(:read, value)
         end
 
@@ -555,7 +551,7 @@ module Mongo
         def show_disk_loc(value = nil)
           configure(:show_disk_loc, value)
         end
-        alias :show_record_id :show_disk_loc
+        alias show_record_id show_disk_loc
 
         # The number of docs to skip before returning results.
         #
@@ -697,24 +693,22 @@ module Mongo
             # collection read preference. If we are not in transaction we
             # look at collection read preference which defaults to client.
             rp = if options[:read]
-              options[:read]
-            elsif options[:session] && options[:session].in_transaction?
-              options[:session].txn_read_preference || collection.client.read_preference
-            else
-              collection.read_preference
-            end
+                   options[:read]
+                 elsif options[:session] && options[:session].in_transaction?
+                   options[:session].txn_read_preference || collection.client.read_preference
+                 else
+                   collection.read_preference
+                 end
             Lint.validate_underscore_read_preference(rp)
             rp
           end
         end
 
         def parallel_scan(cursor_count, options = {})
-          if options[:session]
-            # The session would be overwritten by the one in +options+ later.
-            session = client.get_session(@options)
-          else
-            session = nil
-          end
+          session = if options[:session]
+                      # The session would be overwritten by the one in +options+ later.
+                      client.get_session(@options)
+                    end
           server = server_selector.select_server(cluster, nil, session)
           spec = {
             coll_name: collection.name,
@@ -736,14 +730,13 @@ module Mongo
               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,
+              connection_global_id: result.connection_global_id
             )
             result = if server.load_balancer?
                        # Connection will be checked in when cursor is drained.
@@ -764,10 +757,10 @@ module Mongo
 
         def server_selector
           @server_selector ||= if options[:session] && options[:session].in_transaction?
-            ServerSelector.get(read_preference || client.server_selector)
-          else
-            ServerSelector.get(read_preference || collection.server_selector)
-          end
+                                 ServerSelector.get(read_preference || client.server_selector)
+                               else
+                                 ServerSelector.get(read_preference || collection.server_selector)
+                               end
         end
 
         def validate_doc!(doc)