mongo 2.4.1 → 2.14.0

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

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2016 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@ module Mongo
   class Collection
     class View
 
-      # Provides behaviour around a map/reduce operation on the collection
+      # Provides behavior around a map/reduce operation on the collection
       # view.
       #
       # @since 2.0.0
@@ -35,22 +35,23 @@ module Mongo
         # Reroute message.
         #
         # @since 2.1.0
+        # @deprecated
         REROUTE = 'Rerouting the MapReduce operation to the primary server.'.freeze
 
         # @return [ View ] view The collection view.
         attr_reader :view
 
         # @return [ String ] map The map function.
-        attr_reader :map
+        attr_reader :map_function
 
         # @return [ String ] reduce The reduce function.
-        attr_reader :reduce
+        attr_reader :reduce_function
 
         # Delegate necessary operations to the view.
         def_delegators :view, :collection, :read, :cluster
 
         # Delegate necessary operations to the collection.
-        def_delegators :collection, :database
+        def_delegators :collection, :database, :client
 
         # Iterate through documents returned by the map/reduce.
         #
@@ -66,15 +67,18 @@ module Mongo
         # @yieldparam [ Hash ] Each matching document.
         def each
           @cursor = nil
-          write_with_retry do
-            server = read.select_server(cluster, false)
-            result = send_initial_query(server)
-            @cursor = Cursor.new(view, result, server)
+          session = client.send(:get_session, @options)
+          server = cluster.next_primary(nil, session)
+          result = send_initial_query(server, session)
+          result = send_fetch_query(server, session) unless inline?
+          @cursor = Cursor.new(view, result, server, session: session)
+          if block_given?
+            @cursor.each do |doc|
+              yield doc
+            end
+          else
+            @cursor.to_enum
           end
-          @cursor.each do |doc|
-            yield doc
-          end if block_given?
-          @cursor.to_enum
         end
 
         # Set or get the finalize function for the operation.
@@ -105,8 +109,8 @@ module Mongo
         # @since 2.0.0
         def initialize(view, map, reduce, options = {})
           @view = view
-          @map = map.freeze
-          @reduce = reduce.freeze
+          @map_function = map.dup.freeze
+          @reduce_function = reduce.dup.freeze
           @options = BSON::Document.new(options).freeze
         end
 
@@ -180,64 +184,89 @@ module Mongo
           configure(:verbose, value)
         end
 
+        # Execute the map reduce, without doing a fetch query to retrieve the results
+        #   if outputted to a collection.
+        #
+        # @example Execute the map reduce and get the raw result.
+        #   map_reduce.execute
+        #
+        # @return [ Mongo::Operation::Result ] The raw map reduce result
+        #
+        # @since 2.5.0
+        def execute
+          view.send(:with_session, @options) do |session|
+            write_concern = view.write_concern_with_session(session)
+            nro_write_with_retry(session, write_concern) do |server|
+              send_initial_query(server, session)
+            end
+          end
+        end
+
         private
 
+        def server_selector
+          @view.send(:server_selector)
+        end
+
         def inline?
           out.nil? || out == { inline: 1 } || out == { INLINE => 1 }
         end
 
-        def map_reduce_spec
-          Builder::MapReduce.new(map, reduce, view, options).specification
+        def map_reduce_spec(session = nil)
+          Builder::MapReduce.new(map_function, reduce_function, view, options.merge(session: session)).specification
         end
 
         def new(options)
-          MapReduce.new(view, map, reduce, options)
+          MapReduce.new(view, map_function, reduce_function, options)
         end
 
-        def initial_query_op
-          Operation::Commands::MapReduce.new(map_reduce_spec)
+        def initial_query_op(session)
+          Operation::MapReduce.new(map_reduce_spec(session))
         end
 
         def valid_server?(server)
-          server.standalone? || server.mongos? || server.primary? || secondary_ok?
+          description = server.with_connection do |connection|
+            connection.description
+          end
+          description.standalone? || description.mongos? || description.primary? || secondary_ok?
         end
 
         def secondary_ok?
           out.respond_to?(:keys) && out.keys.first.to_s.downcase == INLINE
         end
 
-        def send_initial_query(server)
+        def send_initial_query(server, session)
           unless valid_server?(server)
-            log_warn(REROUTE)
-            server = cluster.next_primary(false)
+            msg = "Rerouting the MapReduce operation to the primary server - #{server.summary} is not suitable"
+            log_warn(msg)
+            server = cluster.next_primary(nil, session)
           end
           validate_collation!(server)
-          result = initial_query_op.execute(server)
-          inline? ? result : send_fetch_query(server)
+          initial_query_op(session).execute(server, client: client)
         end
 
         def fetch_query_spec
-          Builder::MapReduce.new(map, reduce, view, options).query_specification
+          Builder::MapReduce.new(map_function, reduce_function, view, options).query_specification
         end
 
-        def find_command_spec
-          Builder::MapReduce.new(map, reduce, view, options).command_specification
+        def find_command_spec(session)
+          Builder::MapReduce.new(map_function, reduce_function, view, options.merge(session: session)).command_specification
         end
 
-        def fetch_query_op(server)
-          if server.features.find_command_enabled?
-            Operation::Commands::Find.new(find_command_spec)
+        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::Read::Query.new(fetch_query_spec)
+            Operation::Find.new(fetch_query_spec)
           end
         end
 
-        def send_fetch_query(server)
-          fetch_query_op(server).execute(server)
+        def send_fetch_query(server, session)
+          fetch_query_op(server, session).execute(server, client: client)
         end
 
         def validate_collation!(server)
-          if (view.options[:collation] || options[:collation]) && !server.features.collation_enabled?
+          if (view.options[:collation] || options[:collation]) && !server.with_connection { |connection| connection.features }.collation_enabled?
             raise Error::UnsupportedCollation.new
           end
         end

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

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2016 MongoDB, Inc.
+# Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@ module Mongo
   class Collection
     class View
 
-      # Defines read related behaviour for collection view.
+      # Defines read related behavior for collection view.
       #
       # @since 2.0.0
       module Readable
@@ -45,7 +45,25 @@ 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
+        # a find operation.
+        #
+        # @return [ View ] The new view.
+        def allow_disk_use
+          configure(:allow_disk_use, true)
         end
 
         # Allows the query to get partial results if some shards are down.
@@ -82,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)
@@ -112,38 +130,124 @@ module Mongo
         # @example Get the number of documents in the collection.
         #   collection_view.count
         #
-        # @param [ Hash ] opts Options for the count command.
+        # @param [ Hash ] opts Options for the operation.
         #
         # @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.
-        # @option opts :limit [ Integer ] Max number of docs to return.
+        # @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.
         # @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.
         #
         # @return [ Integer ] The document count.
         #
         # @since 2.0.0
+        #
+        # @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+)
+        #     * $near should be replaced with $geoWithin with $center
+        #     * $nearSphere should be replaced with $geoWithin with $centerSphere
         def count(opts = {})
           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)
+          end
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = collection.read_concern if collection.read_concern
-          preference = ServerSelector.get(opts[:read] || read)
-          server = preference.select_server(cluster)
-          apply_collation!(cmd, server, opts)
-          read_with_retry do
-            Operation::Commands::Command.new({
-                                               :selector => cmd,
-                                               :db_name => database.name,
-                                               :options => { :limit => -1 },
-                                               :read => preference,
-                                             }).execute(server).n.to_i
+          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|
+            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
+              ).execute(server, client: client)
+            end.n.to_i
+          end
+        end
+
+        # Get a count of matching documents in the collection.
+        #
+        # @example Get the number of documents in the collection.
+        #   collection_view.count
+        #
+        # @param [ Hash ] opts Options for the operation.
+        #
+        # @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+.
+        # @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.
+        # @option opts [ Hash ] :read The read preference options.
+        # @option opts [ Hash ] :collation The collation to use.
+        #
+        # @return [ Integer ] The document count.
+        #
+        # @since 2.6.0
+        def count_documents(opts = {})
+          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[:collation] ||= collation
 
+          first = aggregate(pipeline, opts).first
+          return 0 unless first
+          first['n'].to_i
+        end
+
+        # Gets an estimate of the count of documents in a collection using collection metadata.
+        #
+        # @example Get the number of documents in the collection.
+        #   collection_view.estimated_document_count
+        #
+        # @param [ Hash ] opts Options for the operation.
+        #
+        # @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.
+        #
+        # @return [ Integer ] The document count.
+        #
+        # @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
+            cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+              read_concern)
+          end
+          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|
+            read_with_retry(session, selector) do |server|
+              Operation::Count.new(
+                selector: cmd,
+                db_name: database.name,
+                read: read_pref,
+                session: session
+              ).execute(server, client: client)
+            end.n.to_i
           end
         end
 
@@ -164,22 +268,31 @@ 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
           cmd = { :distinct => collection.name,
                   :key => field_name.to_s,
                   :query => filter }
           cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-          cmd[:readConcern] = collection.read_concern if collection.read_concern
-          preference = ServerSelector.get(opts[:read] || read)
-          server = preference.select_server(cluster)
-          apply_collation!(cmd, server, opts)
-          read_with_retry do
-            Operation::Commands::Command.new({
-                                               :selector => cmd,
-                                               :db_name => database.name,
-                                               :options => { :limit => -1 },
-                                               :read => preference
-                                             }).execute(server).first['values']
-
+          if read_concern
+            cmd[:readConcern] = Options::Mapper.transform_values_to_strings(
+              read_concern)
+          end
+          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|
+            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, client: client)
+            end.first['values']
           end
         end
 
@@ -224,7 +337,7 @@ module Mongo
         #
         # @since 2.0.0
         def map_reduce(map, reduce, options = {})
-          MapReduce.new(self, map, reduce, options)
+          MapReduce.new(self, map, reduce, @options.merge(options))
         end
 
         # Set the max number of documents to scan.
@@ -237,6 +350,9 @@ module Mongo
         # @return [ Integer, View ] The value or a new +View+.
         #
         # @since 2.0.0
+        #
+        # @deprecated This option is deprecated as of MongoDB server
+        #   version 4.0.
         def max_scan(value = nil)
           configure(:max_scan, value)
         end
@@ -313,9 +429,8 @@ module Mongo
         #
         # @since 2.0.0
         def read(value = nil)
-          return default_read if value.nil?
-          selector = ServerSelector.get(value)
-          configure(:read, selector)
+          return read_preference if value.nil?
+          configure(:read, value)
         end
 
         # Set whether to return only the indexed field or fields.
@@ -374,6 +489,9 @@ module Mongo
         # @param [ true, false ] value The snapshot value.
         #
         # @since 2.0.0
+        #
+        # @deprecated This option is deprecated as of MongoDB server
+        #   version 4.0.
         def snapshot(value = nil)
           configure(:snapshot, value)
         end
@@ -451,39 +569,80 @@ module Mongo
           configure(:cursor_type, type)
         end
 
+        # @api private
+        def read_concern
+          if options[:session] && options[:session].in_transaction?
+            options[:session].send(:txn_read_concern) || collection.client.read_concern
+          else
+            collection.read_concern
+          end
+        end
+
+        # @api private
+        def read_preference
+          @read_preference ||= begin
+            # Operation read preference is always respected, and has the
+            # highest priority. If we are in a transaction, we look at
+            # transaction read preference and default to client, ignoring
+            # 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
+            Lint.validate_underscore_read_preference(rp)
+            rp
+          end
+        end
+
         private
 
         def collation(doc = nil)
           configure(:collation, doc)
         end
 
-        def default_read
-          options[:read] || collection.read_preference
+        def server_selector
+          if options[:session] && options[:session].in_transaction?
+            ServerSelector.get(read_preference || client.server_selector)
+          else
+            @server_selector ||= ServerSelector.get(read_preference || collection.server_selector)
+          end
         end
 
         def parallel_scan(cursor_count, options = {})
-          server = read.select_server(cluster, false)
-          cmd = Operation::Commands::ParallelScan.new({
+          if options[:session]
+            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 => collection.read_concern
+                  :read_concern => read_concern,
+                  :session => session,
                 }.merge!(options))
-          cmd.execute(server).cursor_ids.map do |cursor_id|
-            result = if server.features.find_command_enabled?
-                Operation::Commands::GetMore.new({
-                  :selector => { :getMore => cursor_id, :collection => collection.name },
-                  :db_name  => database.name
-                }).execute(server)
-              else
-                Operation::Read::GetMore.new({
-                  :to_return => 0,
-                  :cursor_id => cursor_id,
-                  :db_name   => database.name,
-                  :coll_name => collection.name
-                }).execute(server)
+          cmd.execute(server, client: client).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, client: client)
+             else
+              Operation::GetMore.new({
+                :to_return => 0,
+                :cursor_id => BSON::Int64.new(cursor_id),
+                :db_name => database.name,
+                :coll_name => collection.name
+              }).execute(server, client: client)
             end
-            Cursor.new(self, result, server)
+            Cursor.new(self, result, server, session: session)
           end
         end