mongo 2.4.3 → 2.5.0.beta

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

@@ -50,7 +50,7 @@ module Mongo
         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,10 +66,10 @@ 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, view.options)
+          write_with_retry(session, Proc.new { server_selector.select_server(cluster, false) }) do |server|
+            result = send_initial_query(server, session)
+            @cursor = Cursor.new(view, result, server, session: session)
           end
           @cursor.each do |doc|
             yield doc
@@ -182,20 +182,24 @@ module Mongo
 
         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)
+          Builder::MapReduce.new(map, reduce, view, options.merge(session: session)).specification
         end
 
         def new(options)
           MapReduce.new(view, map, reduce, options)
         end
 
-        def initial_query_op
-          Operation::Commands::MapReduce.new(map_reduce_spec)
+        def initial_query_op(session)
+          Operation::Commands::MapReduce.new(map_reduce_spec(session))
         end
 
         def valid_server?(server)
@@ -206,34 +210,34 @@ module Mongo
           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)
           end
           validate_collation!(server)
-          result = initial_query_op.execute(server)
-          inline? ? result : send_fetch_query(server)
+          result = initial_query_op(session).execute(server)
+          inline? ? result : send_fetch_query(server, session)
         end
 
         def fetch_query_spec
           Builder::MapReduce.new(map, reduce, 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, reduce, view, options.merge(session: session)).command_specification
         end
 
-        def fetch_query_op(server)
+        def fetch_query_op(server, session)
           if server.features.find_command_enabled?
-            Operation::Commands::Find.new(find_command_spec)
+            Operation::Commands::Find.new(find_command_spec(session))
           else
             Operation::Read::Query.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)
         end
 
         def validate_collation!(server)

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

@@ -133,20 +133,24 @@ module Mongo
           cmd[:limit] = opts[:limit] if opts[:limit]
           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)
+          read_pref = opts[:read] || read_preference
+          selector = ServerSelector.get(read_pref || server_selector)
           read_with_retry do
-            server = preference.select_server(cluster, false)
+            server = selector.select_server(cluster, false)
             apply_collation!(cmd, server, opts)
-            Operation::Commands::Command.new({
-                                               :selector => cmd,
-                                               :db_name => database.name,
-                                               :options => { :limit => -1 },
-                                               :read => preference,
-                                             }).execute(server).n.to_i
-
+            with_session do |session|
+              Operation::Commands::Command.new({
+                                                   :selector => cmd,
+                                                   :db_name => database.name,
+                                                   :options => {:limit => -1},
+                                                   :read => read_pref,
+                                                   :session => session
+                                               }).execute(server)
+            end.n.to_i
           end
         end
 
+
         # Get a list of distinct values for a specific field.
         #
         # @example Get the distinct values.
@@ -169,17 +173,20 @@ module Mongo
                   :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)
+          read_pref = opts[:read] || read_preference
+          selector = ServerSelector.get(read_pref || server_selector)
           read_with_retry do
-            server = preference.select_server(cluster, false)
+            server = selector.select_server(cluster, false)
             apply_collation!(cmd, server, opts)
-            Operation::Commands::Command.new({
-                                               :selector => cmd,
-                                               :db_name => database.name,
-                                               :options => { :limit => -1 },
-                                               :read => preference
-                                             }).execute(server).first['values']
-
+            with_session do |session|
+              Operation::Commands::Command.new({
+                                                   :selector => cmd,
+                                                   :db_name => database.name,
+                                                   :options => {:limit => -1},
+                                                   :read => read_pref,
+                                                   :session => session
+                                               }).execute(server)
+            end.first['values']
           end
         end
 
@@ -313,9 +320,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.
@@ -457,33 +463,41 @@ module Mongo
           configure(:collation, doc)
         end
 
-        def default_read
-          options[:read] || collection.read_preference
+        def read_preference
+          @read_preference ||= (options[:read] || collection.read_preference)
+        end
+
+        def server_selector
+          @server_selector ||= ServerSelector.get(read_preference || collection.server_selector)
         end
 
         def parallel_scan(cursor_count, options = {})
-          server = read.select_server(cluster, false)
+          session = client.send(:get_session, @options)
+          server = server_selector.select_server(cluster, false)
           cmd = Operation::Commands::ParallelScan.new({
                   :coll_name => collection.name,
                   :db_name => database.name,
                   :cursor_count => cursor_count,
-                  :read_concern => collection.read_concern
+                  :read_concern => collection.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)
+                       Operation::Commands::GetMore.new({
+                         :selector => {:getMore => cursor_id,
+                                       :collection => collection.name},
+                         :db_name => database.name,
+                         :session => session
+                       }).execute(server)
+                     else
+                       Operation::Read::GetMore.new({
+                         :to_return => 0,
+                         :cursor_id => cursor_id,
+                         :db_name => database.name,
+                         :coll_name => collection.name
+                     }).execute(server)
             end
-            Cursor.new(self, result, server)
+            Cursor.new(self, result, server, session: session)
           end
         end
 

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

@@ -21,6 +21,11 @@ module Mongo
       # @since 2.0.0
       module Writable
 
+        # The array filters field constant.
+        #
+        # @since 2.5.0
+        ARRAY_FILTERS = 'array_filters'.freeze
+
         # Finds a single document in the database via findAndModify and deletes
         # it, returning the original document.
         #
@@ -41,15 +46,16 @@ module Mongo
           cmd[:maxTimeMS] = max_time_ms if max_time_ms
           cmd[:writeConcern] = write_concern.options if write_concern
 
-          write_with_retry do
-            server = next_primary
-            apply_collation!(cmd, server, opts)
-
-            Operation::Commands::Command.new({
-                                              :selector => cmd,
-                                              :db_name => database.name
-                                             }).execute(server).first['value']
-          end
+          with_session do |session|
+            write_with_retry(session, Proc.new { next_primary }) do |server|
+              apply_collation!(cmd, server, opts)
+              Operation::Commands::Command.new({
+                                                :selector => cmd,
+                                                :db_name => database.name,
+                                                :session => session
+                                               }).execute(server)
+            end
+          end.first['value']
         end
 
         # Finds a single document and replaces it.
@@ -67,7 +73,7 @@ module Mongo
         # @option opts [ true, false ] :upsert Whether to upsert if the document doesn't exist.
         # @option opts [ true, false ] :bypass_document_validation Whether or
         #   not to skip document level validation.
-        # @option options [ Hash ] :write_concern The write concern options.
+        # @option opts [ Hash ] :write_concern The write concern options.
         #   Defaults to the collection's write concern.
         # @option opts [ Hash ] :collation The collation to use.
         #
@@ -93,6 +99,8 @@ module Mongo
         # @option opts [ Hash ] :write_concern The write concern options.
         #   Defaults to the collection's write concern.
         # @option opts [ Hash ] :collation The collation to use.
+        # @options opts [ Array ] :array_filters A set of filters specifying to which array elements
+        # an update should apply.
         #
         # @return [ BSON::Document ] The document.
         #
@@ -108,15 +116,17 @@ module Mongo
           cmd[:bypassDocumentValidation] = !!opts[:bypass_document_validation]
           cmd[:writeConcern] = write_concern.options if write_concern
 
-          value = write_with_retry do
-            server = next_primary
-            apply_collation!(cmd, server, opts)
-
-            Operation::Commands::Command.new({
-                                              :selector => cmd,
-                                              :db_name => database.name
-                                             }).execute(server).first['value']
-          end
+          value = with_session do |session|
+            write_with_retry(session, Proc.new { next_primary }) do |server|
+              apply_collation!(cmd, server, opts)
+              apply_array_filters!(cmd, server, opts)
+              Operation::Commands::Command.new(
+                                               :selector => cmd,
+                                               :db_name => database.name,
+                                               :session => session
+                                              ).execute(server)
+            end
+          end.first['value']
           value unless value.nil? || value.empty?
         end
 
@@ -182,6 +192,8 @@ module Mongo
         # @option opts [ true, false ] :upsert Whether to upsert if the
         #   document doesn't exist.
         # @option opts [ Hash ] :collation The collation to use.
+        # @option opts [ Array ] :array_filters A set of filters specifying to which array elements
+        #   an update should apply.
         #
         # @return [ Result ] The response from the database.
         #
@@ -201,6 +213,8 @@ module Mongo
         # @option opts [ true, false ] :upsert Whether to upsert if the
         #   document doesn't exist.
         # @option opts [ Hash ] :collation The collation to use.
+        # @option opts [ Array ] :array_filters A set of filters specifying to which array elements
+        #   an update should apply.
         #
         # @return [ Result ] The response from the database.
         #
@@ -213,16 +227,18 @@ module Mongo
 
         def remove(value, opts = {})
           delete_doc = { Operation::Q => filter, Operation::LIMIT => value }
-          write_with_retry do
-            server = next_primary
-            apply_collation!(delete_doc, server, opts)
-
-            Operation::Write::Delete.new(
-              :delete => delete_doc,
-              :db_name => collection.database.name,
-              :coll_name => collection.name,
-              :write_concern => collection.write_concern
-            ).execute(server)
+
+          with_session do |session|
+            write_with_retry(session, Proc.new { next_primary }) do |server|
+              apply_collation!(delete_doc, server, opts)
+              Operation::Write::Delete.new(
+                :delete => delete_doc,
+                :db_name => collection.database.name,
+                :coll_name => collection.name,
+                :write_concern => collection.write_concern,
+                :session => session
+              ).execute(server)
+            end
           end
         end
 
@@ -231,17 +247,33 @@ module Mongo
                          Operation::U => spec,
                          Operation::MULTI => multi,
                          Operation::UPSERT => !!opts[:upsert] }
-          write_with_retry do
-            server = next_primary
-            apply_collation!(update_doc, server, opts)
-
-            Operation::Write::Update.new(
-              :update => update_doc,
-              :db_name => collection.database.name,
-              :coll_name => collection.name,
-              :write_concern => collection.write_concern,
-              :bypass_document_validation => !!opts[:bypass_document_validation]
-            ).execute(server)
+
+          with_session do |session|
+            write_with_retry(session, Proc.new { next_primary }) do |server|
+              apply_collation!(update_doc, server, opts)
+              apply_array_filters!(update_doc, server, opts)
+              Operation::Write::Update.new(
+                :update => update_doc,
+                :db_name => collection.database.name,
+                :coll_name => collection.name,
+                :write_concern => collection.write_concern,
+                :bypass_document_validation => !!opts[:bypass_document_validation],
+                :session => session
+              ).execute(server)
+            end
+          end
+        end
+
+        def apply_array_filters!(doc, server, opts = {})
+          if filters = opts[:array_filters] || opts[ARRAY_FILTERS]
+            validate_array_filters!(server, filters)
+            doc[:arrayFilters] = filters
+          end
+        end
+
+        def validate_array_filters!(server, filters)
+          if filters && !server.features.array_filters_enabled?
+            raise Error::UnsupportedArrayFilters.new
           end
         end
       end

data/lib/mongo/cursor.rb

@@ -35,7 +35,7 @@ module Mongo
     include Enumerable
     include Retryable
 
-    def_delegators :@view, :collection, :limit
+    def_delegators :@view, :collection
     def_delegators :collection, :client, :database
     def_delegators :@server, :cluster
 
@@ -50,15 +50,21 @@ module Mongo
     # @param [ CollectionView ] view The +CollectionView+ defining the query.
     # @param [ Operation::Result ] result The result of the first execution.
     # @param [ Server ] server The server this cursor is locked to.
+    # @param [ Hash ] options The cursor options.
+    #
+    # @option options [ true, false ] :disable_retry Whether to disable retrying on
+    #   error when sending getmores.
     #
     # @since 2.0.0
-    def initialize(view, result, server)
+    def initialize(view, result, server, options = {})
       @view = view
       @server = server
       @initial_result = result
       @remaining = limit if limited?
       @cursor_id = result.cursor_id
       @coll_name = nil
+      @options = options
+      @session = @options[:session]
       register
       ObjectSpace.define_finalizer(self, self.class.finalize(result.cursor_id,
                                                              cluster,
@@ -185,14 +191,18 @@ module Mongo
     end
 
     def get_more
-      read_with_retry do
+      if @options[:disable_retry]
         process(get_more_operation.execute(@server))
+      else
+        read_with_retry do
+          process(get_more_operation.execute(@server))
+        end
       end
     end
 
     def get_more_operation
       if @server.features.find_command_enabled?
-        Operation::Commands::GetMore.new(Builder::GetMoreCommand.new(self).specification)
+        Operation::Commands::GetMore.new(Builder::GetMoreCommand.new(self, @session).specification)
       else
         Operation::Read::GetMore.new(Builder::OpGetMore.new(self).specification)
       end
@@ -203,6 +213,13 @@ module Mongo
       read_with_one_retry do
         kill_cursors_operation.execute(@server)
       end
+    ensure
+      end_session
+      @cursor_id = 0
+    end
+
+    def end_session
+      @session.end_implicit_session if @session
     end
 
     def kill_cursors_operation
@@ -241,6 +258,10 @@ module Mongo
       limited? && batch_size >= @remaining
     end
 
+    def limit
+      @view.send(:limit)
+    end
+
     def register
       cluster.register_cursor(@cursor_id)
     end