mongo 2.15.0 → 2.18.1

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

@@ -46,38 +46,60 @@ 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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @return [ BSON::Document, nil ] The document, if found.
         #
         # @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)
-            cmd[:writeConcern] = applied_write_concern.options if applied_write_concern
-            write_with_retry(session, applied_write_concern) do |server, txn_num|
-              apply_collation!(cmd, server, opts)
-              apply_hint!(cmd, server, opts.merge(write_concern: applied_write_concern))
-
-              Operation::Command.new(
-                  :selector => cmd,
-                  :db_name => database.name,
-                  :session => session,
-                  :txn_num => txn_num,
-              ).execute(server, context: Operation::Context.new(client: client, session: session))
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
             end
-          end.first['value']
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            cmd = {
+              findAndModify: collection.name,
+              query: filter,
+              remove: true,
+              fields: projection,
+              sort: sort,
+              maxTimeMS: max_time_ms,
+              bypassDocumentValidation: opts[:bypass_document_validation],
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+              let: opts[:let],
+              comment: opts[:comment],
+            }.compact
+
+            context = Operation::Context.new(client: client, session: session)
+            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_4 = connection.server.description.server_version_gte?('4.4')
+              if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
+
+              Operation::WriteCommand.new(
+                selector: cmd,
+                db_name: database.name,
+                write_concern: write_concern,
+                session: session,
+                txn_num: txn_num,
+              ).execute_with_connection(connection, context: context)
+            end
+          end.first&.fetch('value', nil)
         end
 
+        # db['users'].bulk_write([{insert_one: {x: 1}}, {insert_one: {x: 2}}])
+
         # Finds a single document and replaces it.
         #
         # @example Find a document and replace it, returning the original.
@@ -96,6 +118,10 @@ module Mongo
         # @option opts [ Hash ] :collation The collation 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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
         #
         # @return [ BSON::Document ] The document.
         #
@@ -127,40 +153,59 @@ 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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
-        # @return [ BSON::Document ] The document.
+        # @return [ BSON::Document | nil ] The document or nil if none is found.
         #
         # @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
-          cmd[:sort] = sort if sort
-          cmd[:new] = !!(opts[:return_document] && opts[:return_document] == :after)
-          cmd[:upsert] = opts[:upsert] if opts[:upsert]
-          cmd[:maxTimeMS] = max_time_ms if max_time_ms
-          if opts[:bypass_document_validation]
-            cmd[:bypassDocumentValidation] = true
-          end
-
           value = with_session(opts) do |session|
-            applied_write_concern = applied_write_concern(opts[:session])
-            cmd[:writeConcern] = applied_write_concern.options if applied_write_concern
-            write_with_retry(session, applied_write_concern) do |server, txn_num|
-              apply_collation!(cmd, server, opts)
-              apply_array_filters!(cmd, server, opts)
-              apply_hint!(cmd, server, opts.merge(write_concern: applied_write_concern))
-
-              Operation::Command.new(
-                  :selector => cmd,
-                  :db_name => database.name,
-                  :session => session,
-                  :txn_num => txn_num,
-              ).execute(server, context: Operation::Context.new(client: client, session: session))
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
             end
-          end.first['value']
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            cmd = {
+              findAndModify: collection.name,
+              query: filter,
+              arrayFilters: opts[:array_filters] || opts['array_filters'],
+              update: document,
+              fields: projection,
+              sort: sort,
+              new: !!(opts[:return_document] && opts[:return_document] == :after),
+              upsert: opts[:upsert],
+              maxTimeMS: max_time_ms,
+              bypassDocumentValidation: opts[:bypass_document_validation],
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+              let: opts[:let],
+              comment: opts[:comment]
+            }.compact
+
+            context = Operation::Context.new(client: client, session: session)
+            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_4 = connection.server.description.server_version_gte?('4.4')
+              if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
+
+              Operation::WriteCommand.new(
+                selector: cmd,
+                db_name: database.name,
+                write_concern: write_concern,
+                session: session,
+                txn_num: txn_num,
+              ).execute_with_connection(connection, context: context)
+            end
+          end.first&.fetch('value', nil)
           value unless value.nil? || value.empty?
         end
 
@@ -177,32 +222,48 @@ module Mongo
         #   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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @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 = 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))
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            delete_doc = {
+              Operation::Q => filter,
+              Operation::LIMIT => 0,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
+
+            context = Operation::Context.new(client: client, session: session)
+            nro_write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_4 = connection.server.description.server_version_gte?('4.4')
+              if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
 
               Operation::Delete.new(
-                  :deletes => [ delete_doc ],
-                  :db_name => collection.database.name,
-                  :coll_name => collection.name,
-                  :write_concern => write_concern,
-                  :bypass_document_validation => !!opts[:bypass_document_validation],
-                  :session => session,
-              ).execute(server, context: Operation::Context.new(client: client, session: session))
+                deletes: [ delete_doc ],
+                db_name: collection.database.name,
+                coll_name: collection.name,
+                write_concern: write_concern,
+                bypass_document_validation: !!opts[:bypass_document_validation],
+                session: session,
+                let: opts[:let],
+                comment: opts[:comment],
+              ).execute_with_connection(connection, context: context)
             end
           end
         end
@@ -220,33 +281,49 @@ module Mongo
         #   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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @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 = 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))
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            delete_doc = {
+              Operation::Q => filter,
+              Operation::LIMIT => 1,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
+
+            context = Operation::Context.new(client: client, session: session)
+            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_4 = connection.server.description.server_version_gte?('4.4')
+              if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
 
               Operation::Delete.new(
-                  :deletes => [ delete_doc ],
-                  :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, context: Operation::Context.new(client: client, session: session))
+                deletes: [ delete_doc ],
+                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,
+                let: opts[:let],
+                comment: opts[:comment],
+              ).execute_with_connection(connection, context: context)
             end
           end
         end
@@ -269,40 +346,54 @@ module Mongo
         #   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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @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,
-                        }
-          if opts[:upsert]
-            update_doc['upsert'] = true
-          end
           with_session(opts) do |session|
             write_concern = if opts[:write_concern]
               WriteConcern.get(opts[:write_concern])
             else
               write_concern_with_session(session)
             end
+            validate_replacement_documents!(replacement)
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            update_doc = {
+              Operation::Q => filter,
+              arrayFilters: opts[:array_filters] || opts['array_filters'],
+              Operation::U => replacement,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
+            if opts[:upsert]
+              update_doc['upsert'] = true
+            end
 
-            write_with_retry(session, write_concern) do |server, txn_num|
-              apply_collation!(update_doc, server, opts)
-              apply_array_filters!(update_doc, server, opts)
-              apply_hint!(update_doc, server, opts.merge(write_concern: write_concern))
+            context = Operation::Context.new(client: client, session: session)
+            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_2 = connection.server.description.server_version_gte?('4.2')
+              if !gte_4_2 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
 
               Operation::Update.new(
-                  :updates => [ update_doc ],
-                  :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, context: Operation::Context.new(client: client, session: session))
+                updates: [ update_doc ],
+                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,
+                let: opts[:let],
+                comment: opts[:comment],
+              ).execute_with_connection(connection, context: context)
             end
           end
         end
@@ -327,39 +418,54 @@ module Mongo
         #   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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @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,
-                         }
-          if opts[:upsert]
-            update_doc['upsert'] = true
-          end
           with_session(opts) do |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)
-              apply_hint!(update_doc, server, opts.merge(write_concern: write_concern))
+            validate_update_documents!(spec)
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            update_doc = {
+              Operation::Q => filter,
+              arrayFilters: opts[:array_filters] || opts['array_filters'],
+              Operation::U => spec,
+              Operation::MULTI => true,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
+            if opts[:upsert]
+              update_doc['upsert'] = true
+            end
+
+            context = Operation::Context.new(client: client, session: session)
+            nro_write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_2 = connection.server.description.server_version_gte?('4.2')
+              if !gte_4_2 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
 
               Operation::Update.new(
-                  :updates => [ update_doc ],
-                  :db_name => collection.database.name,
-                  :coll_name => collection.name,
-                  :write_concern => write_concern,
-                  :bypass_document_validation => !!opts[:bypass_document_validation],
-                  :session => session,
-              ).execute(server, context: Operation::Context.new(client: client, session: session))
+                updates: [ update_doc ],
+                db_name: collection.database.name,
+                coll_name: collection.name,
+                write_concern: write_concern,
+                bypass_document_validation: !!opts[:bypass_document_validation],
+                session: session,
+                let: opts[:let],
+                comment: opts[:comment],
+              ).execute_with_connection(connection, context: context)
             end
           end
         end
@@ -384,88 +490,101 @@ module Mongo
         #   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.
+        # @option options [ Hash ] :let Mapping of variables to use in the command.
+        #   See the server documentation for details.
+        # @option options [ Object ] :comment A user-provided
+        #   comment to attach to this command.
         #
         # @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,
-                         }
-          if opts[:upsert]
-            update_doc['upsert'] = true
-          end
           with_session(opts) do |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)
-              apply_hint!(update_doc, server, opts.merge(write_concern: write_concern))
+            validate_update_documents!(spec)
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            update_doc = {
+              Operation::Q => filter,
+              arrayFilters: opts[:array_filters] || opts['array_filters'],
+              Operation::U => spec,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
+            if opts[:upsert]
+              update_doc['upsert'] = true
+            end
+
+            context = Operation::Context.new(client: client, session: session)
+            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+              gte_4_2 = connection.server.description.server_version_gte?('4.2')
+              if !gte_4_2 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+              end
 
               Operation::Update.new(
-                  :updates => [ update_doc ],
-                  :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, context: Operation::Context.new(client: client, session: session))
+                updates: [ update_doc ],
+                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,
+                let: opts[:let],
+                comment: opts[:comment],
+              ).execute_with_connection(connection, context: context)
             end
           end
         end
 
         private
 
-        def apply_hint!(doc, server, opts)
-          if hint = opts[:hint]
-            features = server.with_connection do |connection|
-              connection.description.features
-            end
-
-            write_concern = opts[:write_concern]
-            if write_concern && !write_concern.acknowledged?
-              raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
-            end
-
-            if doc.key?(:findAndModify) &&
-                !features.find_and_modify_option_validation_enabled?
-              raise Error::UnsupportedOption.hint_error
-            elsif !features.update_delete_option_validation_enabled?
-              raise Error::UnsupportedOption.hint_error
+        # Checks the update documents to make sure they only have atomic modifiers.
+        # Note that as per the spec, we only have to examine the first element
+        # in the update document.
+        #
+        # @param [ Hash | Array<Hash> ] spec The update document or pipeline.
+        #
+        # @raise [ Error::InvalidUpdateDocument ] if the first key in the
+        #   document does not start with a $.
+        def validate_update_documents!(spec)
+          if update = spec.is_a?(Array) ? spec&.first : spec
+            if key = update.keys&.first
+              unless key.to_s.start_with?("$")
+                if Mongo.validate_update_replace
+                  raise Error::InvalidUpdateDocument.new(key: key)
+                else
+                  Error::InvalidUpdateDocument.warn(Logger.logger, key)
+                end
+              end
             end
-
-            doc[:hint] = opts[:hint]
-          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.with_connection { |connection| connection.features }.array_filters_enabled?
-            raise Error::UnsupportedArrayFilters.new
-          end
-        end
-
-        # Get the write concern for an operation
-        #
-        # @return [ Mongo::WriteConcern ] The write concern.
-        def applied_write_concern(session)
-          if wco = options[:write_concern] || options[:write]
-            WriteConcern.get(wco)
-          else
-            write_concern_with_session(session)
+        # Check the replacement documents to make sure they don't have atomic
+        # modifiers. Note that as per the spec, we only have to examine the
+        # first element in the replacement document.
+        #
+        # @param [ Hash | Array<Hash> ] spec The replacement document or pipeline.
+        #
+        # @raise [ Error::InvalidUpdateDocument ] if the first key in the
+        #   document does not start with a $.
+        def validate_replacement_documents!(spec)
+          if replace = spec.is_a?(Array) ? spec&.first : spec
+            if key = replace.keys&.first
+              if key.to_s.start_with?("$")
+                if Mongo.validate_update_replace
+                  raise Error::InvalidReplacementDocument.new(key: key)
+                else
+                  Error::InvalidReplacementDocument.warn(Logger.logger, key)
+                end
+              end
+            end
           end
         end
       end