mongo 2.3.1 → 2.16.0

data/lib/mongo/collection.rb

@@ -1,4 +1,7 @@
-# Copyright (C) 2014-2016 MongoDB, Inc.
+# frozen_string_literal: true
+# encoding: utf-8
+
+# 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.
@@ -50,13 +53,16 @@ module Mongo
     # Delegate to the cluster for the next primary.
     def_delegators :cluster, :next_primary
 
-    # Convenience delegators to find.
-    def_delegators :find, :parallel_scan
-
     # Options that can be updated on a new Collection instance via the #with method.
     #
     # @since 2.1.0
-    CHANGEABLE_OPTIONS = [ :read, :read_concern, :write ].freeze
+    CHANGEABLE_OPTIONS = [ :read, :read_concern, :write, :write_concern ].freeze
+
+    # Options that can be used for creating a time-series collection.
+    TIME_SERIES_OPTIONS = {
+      :time_series => :timeseries,
+      :expire_after => :expireAfterSeconds
+    }
 
     # Check if a collection is equal to another object. Will check the name and
     # the database for equality.
@@ -83,12 +89,33 @@ module Mongo
     # @param [ String, Symbol ] name The collection name.
     # @param [ Hash ] options The collection options.
     #
+    # @option options [ Hash ] :write Deprecated. Equivalent to :write_concern
+    #   option.
+    # @option options [ Hash ] :write_concern The write concern options.
+    #   Can be :w => Integer|String, :fsync => Boolean, :j => Boolean.
+    # @option options [ Hash ] :time_series Create a time-series collection.
+    #   See https://docs.mongodb.com/manual/core/timeseries-collections/ for more
+    #   information about time-series collection.
+    # @option options [ Integer ] :expire_after Number indicating
+    #   after how many seconds old time-series data should be deleted.
+    #
     # @since 2.0.0
     def initialize(database, name, options = {})
       raise Error::InvalidCollectionName.new unless name
+      if options[:write] && options[:write_concern] && options[:write] != options[:write_concern]
+        raise ArgumentError, "If :write and :write_concern are both given, they must be identical: #{options.inspect}"
+      end
       @database = database
       @name = name.to_s.freeze
-      @options = options.freeze
+      @options = options.dup
+=begin WriteConcern object support
+      if @options[:write_concern].is_a?(WriteConcern::Base)
+        # Cache the instance so that we do not needlessly reconstruct it.
+        @write_concern = @options[:write_concern]
+        @options[:write_concern] = @write_concern.options
+      end
+=end
+      @options.freeze
     end
 
     # Get the read concern for this collection instance.
@@ -100,7 +127,19 @@ module Mongo
     #
     # @since 2.2.0
     def read_concern
-      @read_concern ||= options[:read_concern]
+      options[:read_concern] || database.read_concern
+    end
+
+    # Get the server selector on this collection.
+    #
+    # @example Get the server selector.
+    #   collection.server_selector
+    #
+    # @return [ Mongo::ServerSelector ] The server selector.
+    #
+    # @since 2.0.0
+    def server_selector
+      @server_selector ||= ServerSelector.get(read_preference || database.server_selector)
     end
 
     # Get the read preference on this collection.
@@ -108,11 +147,11 @@ module Mongo
     # @example Get the read preference.
     #   collection.read_preference
     #
-    # @return [ Mongo::ServerSelector ] The read preference.
+    # @return [ Hash ] The read preference.
     #
     # @since 2.0.0
     def read_preference
-      @read_preference ||= ServerSelector.get(options[:read] || database.read_preference)
+      @read_preference ||= options[:read] || database.read_preference
     end
 
     # Get the write concern on this collection.
@@ -124,18 +163,40 @@ module Mongo
     #
     # @since 2.0.0
     def write_concern
-      @write_concern ||= options[:write] ? WriteConcern.get(options[:write]) :
-        database.write_concern
+      @write_concern ||= WriteConcern.get(
+        options[:write_concern] || options[:write] || database.write_concern)
+    end
+
+    # Get the write concern for the collection, given the session.
+    #
+    # If the session is in a transaction and the collection
+    # has an unacknowledged write concern, remove the write
+    # concern's :w option. Otherwise, return the unmodified
+    # write concern.
+    #
+    # @return [ Mongo::WriteConcern ] The write concern.
+    #
+    # @api private
+    def write_concern_with_session(session)
+      wc = write_concern
+      if session && session.in_transaction?
+        if wc && !wc.acknowledged?
+          opts = wc.options.dup
+          opts.delete(:w)
+          return WriteConcern.get(opts)
+        end
+      end
+      wc
     end
 
     # Provides a new collection with either a new read preference or new write concern
     # merged over the existing read preference / write concern.
     #
-    # @example Get a collection with changed read preference.
-    #   collection.with(:read => { :mode => :primary_preferred })
+    # @example Get a collection with a changed read preference.
+    #   collection.with(read: { mode: :primary_preferred })
     #
-    # @example Get a collection with changed write concern.
-    #   collection.with(:write => { w:  3 })
+    # @example Get a collection with a changed write concern.
+    #   collection.with(write_concern: { w:  3 })
 
     # @param [ Hash ] new_options The new options to use.
     #
@@ -146,7 +207,14 @@ module Mongo
       new_options.keys.each do |k|
         raise Error::UnchangeableCollectionOption.new(k) unless CHANGEABLE_OPTIONS.include?(k)
       end
-      Collection.new(database, name, options.merge(new_options))
+      options = @options.dup
+      if options[:write] && new_options[:write_concern]
+        options.delete(:write)
+      end
+      if options[:write_concern] && new_options[:write]
+        options.delete(:write_concern)
+      end
+      Collection.new(database, name, options.update(new_options))
     end
 
     # Is the collection capped?
@@ -158,7 +226,7 @@ module Mongo
     #
     # @since 2.0.0
     def capped?
-      database.command(:collstats => name).documents[0][CAPPED]
+      database.read_command(:collstats => name).documents[0][CAPPED]
     end
 
     # Force the collection to be created in the database.
@@ -166,11 +234,53 @@ module Mongo
     # @example Force the collection to be created.
     #   collection.create
     #
+    # @param [ Hash ] opts The options for the create operation.
+    #
+    # @option opts [ Session ] :session The session to use for the operation.
+    # @option opts [ Hash ] :write_concern The write concern options.
+    # @option opts [ Hash ] :time_series Create a time-series collection.
+    # @option opts [ Integer ] :expire_after Number indicating
+    #   after how many seconds old time-series data should be deleted.
+    #
     # @return [ Result ] The result of the command.
     #
     # @since 2.0.0
-    def create
-      database.command({ :create => name }.merge(options))
+    def create(opts = {})
+      # Passing read options to create command causes it to break.
+      # Filter the read options out.
+      # TODO put the list of read options in a class-level constant when
+      # we figure out what the full set of them is.
+      options = Hash[self.options.reject do |key, value|
+        %w(read read_preference read_concern).include?(key.to_s)
+      end]
+      options.update(Utils.slice_hash(opts, *TIME_SERIES_OPTIONS.keys))
+      # Converting Ruby spelled time series options to server style.
+      TIME_SERIES_OPTIONS.each do |ruby_key, server_key|
+        if options.key?(ruby_key)
+          options[server_key] = options.delete(ruby_key)
+        end
+      end
+      operation = { :create => name }.merge(options)
+      operation.delete(:write)
+      operation.delete(:write_concern)
+      client.send(:with_session, opts) do |session|
+        write_concern = if opts[:write_concern]
+          WriteConcern.get(opts[:write_concern])
+        else
+          self.write_concern
+        end
+
+        context = Operation::Context.new(client: client, session: session)
+        Operation::Create.new(
+          selector: operation,
+          db_name: database.name,
+          write_concern: write_concern,
+          session: session,
+          # Note that these are collection options, collation isn't
+          # taken from options passed to the create method.
+          collation: options[:collation] || options['collation'],
+        ).execute(next_primary(nil, session), context: context)
+      end
     end
 
     # Drop the collection. Will also drop all indexes associated with the
@@ -181,14 +291,36 @@ module Mongo
     # @example Drop the collection.
     #   collection.drop
     #
+    # @param [ Hash ] opts The options for the drop operation.
+    #
+    # @option options [ Session ] :session The session to use for the operation.
+    # @option opts [ Hash ] :write_concern The write concern options.
+    #
     # @return [ Result ] The result of the command.
     #
     # @since 2.0.0
-    def drop
-      database.command(:drop => name)
+    def drop(opts = {})
+      client.send(:with_session, opts) do |session|
+        temp_write_concern = write_concern
+        write_concern = if opts[:write_concern]
+          WriteConcern.get(opts[:write_concern])
+        else
+          temp_write_concern
+        end
+        Operation::Drop.new({
+                              selector: { :drop => name },
+                              db_name: database.name,
+                              write_concern: write_concern,
+                              session: session,
+                              }).execute(next_primary(nil, session), context: Operation::Context.new(client: client, session: session))
+      end
     rescue Error::OperationFailure => ex
-      raise ex unless ex.message =~ /ns not found/
-      false
+      # NamespaceNotFound
+      if ex.code == 26 || ex.code.nil? && ex.message =~ /ns not found/
+        false
+      else
+        raise
+      end
     end
 
     # Find documents in the collection.
@@ -202,24 +334,30 @@ module Mongo
     # @param [ Hash ] filter The filter to use in the find.
     # @param [ Hash ] options The options for the find.
     #
+    # @option options [ true, false ] :allow_disk_use When set to true, the
+    #   server can write temporary data to disk while executing the find
+    #   operation. This option is only available on MongoDB server versions
+    #   4.4 and newer.
     # @option options [ true, false ] :allow_partial_results Allows the query to get partial
     #   results if some shards are down.
     # @option options [ Integer ] :batch_size The number of documents returned in each batch
     #   of results from MongoDB.
+    # @option options [ Hash ] :collation The collation to use.
     # @option options [ String ] :comment Associate a comment with the query.
     # @option options [ :tailable, :tailable_await ] :cursor_type The type of cursor to use.
     # @option options [ Integer ] :limit The max number of docs to return from the query.
-    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the query
-    #   to run in milliseconds.
+    # @option options [ Integer ] :max_time_ms
+    #   The maximum amount of time to allow the query to run, in milliseconds.
     # @option options [ Hash ] :modifiers A document containing meta-operators modifying the
     #   output or behavior of a query.
     # @option options [ true, false ] :no_cursor_timeout The server normally times out idle
     #   cursors after an inactivity period (10 minutes) to prevent excess memory use.
     #   Set this option to prevent that.
-    # @option options [ true, false ] :oplog_replay Internal replication use only - driver
-    #   should not set.
+    # @option options [ true, false ] :oplog_replay For internal replication
+    #   use only, applications should not set this option.
     # @option options [ Hash ] :projection The fields to include or exclude from each doc
     #   in the result set.
+    # @option options [ Session ] :session The session to use.
     # @option options [ Integer ] :skip The number of docs to skip before returning results.
     # @option options [ Hash ] :sort The key and direction pairs by which the result set
     #   will be sorted.
@@ -239,24 +377,71 @@ module Mongo
     # @param [ Array<Hash> ] pipeline The aggregation pipeline.
     # @param [ Hash ] options The aggregation options.
     #
-    # @option options [ true, false ] :allow_disk_use Set to true if disk usage is allowed during
-    #   the aggregation.
-    # @option options [ Integer ] :batch_size The number of documents to return per batch.
-    # @option options [ Integer ] :max_time_ms The maximum amount of time in milliseconds to allow the
-    #   aggregation to run.
-    # @option options [ true, false ] :use_cursor Indicates whether the command will request that the server
-    #   provide results using a cursor.
+    # @option options [ true, false ] :allow_disk_use Set to true if disk
+    #   usage is allowed during the aggregation.
+    # @option options [ Integer ] :batch_size The number of documents to return
+    #   per batch.
     # @option options [ true, false ] :bypass_document_validation Whether or
     #   not to skip document level validation.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ String ] :comment Associate a comment with the aggregation.
+    # @option options [ String ] :hint The index to use for the aggregation.
+    # @option options [ Integer ] :max_time_ms The maximum amount of time in
+    #   milliseconds to allow the aggregation to run.
+    # @option options [ true, false ] :use_cursor Indicates whether the command
+    #   will request that the server provide results using a cursor. Note that
+    #   as of server version 3.6, aggregations always provide results using a
+    #   cursor and this option is therefore not valid.
+    # @option options [ Session ] :session The session to use.
     #
     # @return [ Aggregation ] The aggregation object.
     #
     # @since 2.1.0
     def aggregate(pipeline, options = {})
-      View.new(self, {}).aggregate(pipeline, options)
+      View.new(self, {}, options).aggregate(pipeline, options)
+    end
+
+    # As of version 3.6 of the MongoDB server, a ``$changeStream`` pipeline
+    # stage is supported in the aggregation framework. This stage allows users
+    # to request that notifications are sent for all changes to a particular
+    # collection.
+    #
+    # @example Get change notifications for a given collection.
+    #   collection.watch([{ '$match' => { operationType: { '$in' => ['insert', 'replace'] } } }])
+    #
+    # @param [ Array<Hash> ] pipeline Optional additional filter operators.
+    # @param [ Hash ] options The change stream options.
+    #
+    # @option options [ String ] :full_document Allowed values: ‘default’,
+    #   ‘updateLookup’. Defaults to ‘default’. When set to ‘updateLookup’,
+    #   the change notification for partial updates will include both a delta
+    #   describing the changes to the document, as well as a copy of the entire
+    #   document that was changed from some time after the change occurred.
+    # @option options [ BSON::Document, Hash ] :resume_after Specifies the
+    #   logical starting point for the new change stream.
+    # @option options [ Integer ] :max_await_time_ms The maximum amount of time
+    #   for the server to wait on new documents to satisfy a change stream query.
+    # @option options [ Integer ] :batch_size The number of documents to return
+    #   per batch.
+    # @option options [ BSON::Document, Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ BSON::Timestamp ] :start_at_operation_time Only return
+    #   changes that occurred at or after the specified timestamp. Any command run
+    #   against the server will return a cluster time that can be used here.
+    #   Only recognized by server versions 4.0+.
+    #
+    # @note A change stream only allows 'majority' read concern.
+    # @note This helper method is preferable to running a raw aggregation with
+    #   a $changeStream stage, for the purpose of supporting resumability.
+    #
+    # @return [ ChangeStream ] The change stream object.
+    #
+    # @since 2.5.0
+    def watch(pipeline = [], options = {})
+      View::ChangeStream.new(View.new(self, {}, options), pipeline, nil, options)
     end
 
-    # Get a count of matching documents in the collection.
+    # Gets an estimated number of matching documents in the collection.
     #
     # @example Get the count.
     #   collection.count(name: 1)
@@ -269,12 +454,66 @@ module Mongo
     # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command to run.
     # @option options [ Integer ] :skip The number of documents to skip before counting.
     # @option options [ Hash ] :read The read preference options.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
     #
     # @return [ Integer ] The document count.
     #
     # @since 2.1.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(filter = nil, options = {})
-      View.new(self, filter || {}).count(options)
+      View.new(self, filter || {}, options).count(options)
+    end
+
+    # Gets the number of documents matching the query. Unlike the deprecated
+    # #count method, this will return the exact number of documents matching
+    # the filter (or exact number of documents in the collection, if no filter
+    # is provided) rather than an estimate.
+    #
+    # Use #estimated_document_count to retrieve an estimate of the number
+    # of documents in the collection using the collection metadata.
+    #
+    # @param [ Hash ] filter A filter for matching documents.
+    # @param [ Hash ] options Options for the operation.
+    #
+    # @option options :skip [ Integer ] The number of documents to skip.
+    # @option options :hint [ Hash ] Override default index selection and force
+    #   MongoDB to use a specific index for the query. Requires server version 3.6+.
+    # @option options :limit [ Integer ] Max number of docs to count.
+    # @option options :max_time_ms [ Integer ] The maximum amount of time to allow the
+    #   command to run.
+    # @option options :read [ Hash ] The read preference options.
+    # @option options :collation [ Hash ] The collation to use.
+    #
+    # @return [ Integer ] The document count.
+    #
+    # @since 2.6.0
+    def count_documents(filter = {}, options = {})
+      View.new(self, filter, options).count_documents(options)
+    end
+
+    # Gets an estimate of the number of documents in the collection using the
+    # collection metadata.
+    #
+    # Use #count_documents to retrieve the exact number of documents in the
+    # collection, or to count documents matching a filter.
+    #
+    # @param [ Hash ] options Options for the operation.
+    #
+    # @option opts :max_time_ms [ Integer ] The maximum amount of time to allow
+    #   the command to run for on the server.
+    # @option opts [ Hash ] :read The read preference options.
+    #
+    # @return [ Integer ] The document count.
+    #
+    # @since 2.6.0
+    def estimated_document_count(options = {})
+      View.new(self, {}, options).estimated_document_count(options)
     end
 
     # Get a list of distinct values for a specific field.
@@ -288,12 +527,14 @@ module Mongo
     #
     # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command to run.
     # @option options [ Hash ] :read The read preference options.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
     #
     # @return [ Array<Object> ] The list of distinct values.
     #
     # @since 2.1.0
     def distinct(field_name, filter = nil, options = {})
-      View.new(self, filter || {}).distinct(field_name, options)
+      View.new(self, filter || {}, options).distinct(field_name, options)
     end
 
     # Get a view of all indexes for this collection. Can be iterated or has
@@ -304,6 +545,8 @@ module Mongo
     #
     # @param [ Hash ] options Options for getting a list of all indexes.
     #
+    # @option options [ Session ] :session The session to use.
+    #
     # @return [ View::Index ] The index view.
     #
     # @since 2.0.0
@@ -329,22 +572,40 @@ module Mongo
     #   collection.insert_one({ name: 'test' })
     #
     # @param [ Hash ] document The document to insert.
-    # @param [ Hash ] options The insert options.
+    # @param [ Hash ] opts The insert options.
+    #
+    # @option opts [ Session ] :session The session to use for the operation.
     #
     # @return [ Result ] The database response wrapper.
     #
     # @since 2.0.0
-    def insert_one(document, options = {})
-      write_with_retry do
-        Operation::Write::Insert.new(
-          :documents => [ document ],
-          :db_name => database.name,
-          :coll_name => name,
-          :write_concern => write_concern,
-          :bypass_document_validation => !!options[:bypass_document_validation],
-          :options => options,
-          :id_generator => client.options[:id_generator]
-        ).execute(next_primary)
+    def insert_one(document, opts = {})
+      QueryCache.clear_namespace(namespace)
+
+      client.send(:with_session, opts) do |session|
+        write_concern = if opts[:write_concern]
+          WriteConcern.get(opts[:write_concern])
+        else
+          write_concern_with_session(session)
+        end
+
+        if document.nil?
+          raise ArgumentError, "Document to be inserted cannot be nil"
+        end
+
+        write_with_retry(session, write_concern) do |server, txn_num|
+          Operation::Insert.new(
+            :documents => [ document ],
+            :db_name => database.name,
+            :coll_name => name,
+            :write_concern => write_concern,
+            :bypass_document_validation => !!opts[:bypass_document_validation],
+            :options => opts,
+            :id_generator => client.options[:id_generator],
+            :session => session,
+            :txn_num => txn_num,
+          ).execute(server, context: Operation::Context.new(client: client, session: session))
+        end
       end
     end
 
@@ -356,10 +617,16 @@ module Mongo
     # @param [ Array<Hash> ] documents The documents to insert.
     # @param [ Hash ] options The insert options.
     #
+    # @option options [ true | false ] :ordered Whether the operations
+    #   should be executed in order.
+    # @option options [ Session ] :session The session to use for the operation.
+    #
     # @return [ Result ] The database response wrapper.
     #
     # @since 2.0.0
     def insert_many(documents, options = {})
+      QueryCache.clear_namespace(namespace)
+
       inserts = documents.map{ |doc| { :insert_one => doc }}
       bulk_write(inserts, options)
     end
@@ -378,6 +645,7 @@ module Mongo
     #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
     # @option options [ true, false ] :bypass_document_validation Whether or
     #   not to skip document level validation.
+    # @option options [ Session ] :session The session to use for the set of operations.
     #
     # @return [ BulkWrite::Result ] The result of the operation.
     #
@@ -392,12 +660,18 @@ module Mongo
     #   collection.delete_one
     #
     # @param [ Hash ] filter The filter to use.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ Result ] The response from the database.
     #
     # @since 2.1.0
-    def delete_one(filter = nil)
-      find(filter).delete_one
+    def delete_one(filter = nil, options = {})
+      find(filter, options).delete_one(options)
     end
 
     # Remove documents from the collection.
@@ -406,12 +680,18 @@ module Mongo
     #   collection.delete_many
     #
     # @param [ Hash ] filter The filter to use.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ Result ] The response from the database.
     #
     # @since 2.1.0
-    def delete_many(filter = nil)
-      find(filter).delete_many
+    def delete_many(filter = nil, options = {})
+      find(filter, options).delete_many(options)
     end
 
     # Execute a parallel scan on the collection view.
@@ -424,12 +704,17 @@ module Mongo
     #   collection.parallel_scan(2)
     #
     # @param [ Integer ] cursor_count The max number of cursors to return.
+    # @param [ Hash ] options The parallel scan command options.
+    #
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command
+    #   to run in milliseconds.
+    # @option options [ Session ] :session The session to use.
     #
     # @return [ Array<Cursor> ] An array of cursors.
     #
     # @since 2.1
-    def parallel_scan(cursor_count)
-      find.send(:parallel_scan, cursor_count)
+    def parallel_scan(cursor_count, options = {})
+      find({}, options).send(:parallel_scan, cursor_count, options)
     end
 
     # Replaces a single document in the collection with the new document.
@@ -445,12 +730,16 @@ module Mongo
     #   document doesn't exist.
     # @option options [ true, false ] :bypass_document_validation Whether or
     #   not to skip document level validation.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ Result ] The response from the database.
     #
     # @since 2.1.0
     def replace_one(filter, replacement, options = {})
-      find(filter).replace_one(replacement, options)
+      find(filter, options).replace_one(replacement, options)
     end
 
     # Update documents in the collection.
@@ -459,19 +748,25 @@ module Mongo
     #   collection.update_many({ name: 'test'}, '$set' => { name: 'test1' })
     #
     # @param [ Hash ] filter The filter to use.
-    # @param [ Hash ] update The update statement.
+    # @param [ Hash | Array<Hash> ] update The update document or pipeline.
     # @param [ Hash ] options The options.
     #
     # @option options [ true, false ] :upsert Whether to upsert if the
     #   document doesn't exist.
     # @option options [ true, false ] :bypass_document_validation Whether or
     #   not to skip document level validation.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Array ] :array_filters A set of filters specifying to which array elements
+    #   an update should apply.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ Result ] The response from the database.
     #
     # @since 2.1.0
     def update_many(filter, update, options = {})
-      find(filter).update_many(update, options)
+      find(filter, options).update_many(update, options)
     end
 
     # Update a single document in the collection.
@@ -480,19 +775,25 @@ module Mongo
     #   collection.update_one({ name: 'test'}, '$set' => { name: 'test1'})
     #
     # @param [ Hash ] filter The filter to use.
-    # @param [ Hash ] update The update statement.
+    # @param [ Hash | Array<Hash> ] update The update document or pipeline.
     # @param [ Hash ] options The options.
     #
     # @option options [ true, false ] :upsert Whether to upsert if the
     #   document doesn't exist.
     # @option options [ true, false ] :bypass_document_validation Whether or
     #   not to skip document level validation.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Array ] :array_filters A set of filters specifying to which array elements
+    #   an update should apply.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ Result ] The response from the database.
     #
     # @since 2.1.0
     def update_one(filter, update, options = {})
-      find(filter).update_one(update, options)
+      find(filter, options).update_one(update, options)
     end
 
     # Finds a single document in the database via findAndModify and deletes
@@ -511,12 +812,16 @@ module Mongo
     #   will be sorted.
     # @option options [ Hash ] :write_concern The write concern options.
     #   Defaults to the collection's write concern.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ BSON::Document, nil ] The document, if found.
     #
     # @since 2.1.0
     def find_one_and_delete(filter, options = {})
-      find(filter, options).find_one_and_delete
+      find(filter, options).find_one_and_delete(options)
     end
 
     # Finds a single document via findAndModify and updates it, returning the original doc unless
@@ -529,7 +834,7 @@ module Mongo
     #   collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }}, :return_document => :after)
     #
     # @param [ Hash ] filter The filter to use.
-    # @param [ BSON::Document ] update The update statement.
+    # @param [ Hash | Array<Hash> ] update The update document or pipeline.
     # @param [ Hash ] options The options.
     #
     # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command
@@ -543,6 +848,12 @@ module Mongo
     #   not to skip document level validation.
     # @option options [ Hash ] :write_concern The write concern options.
     #   Defaults to the collection's write concern.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Array ] :array_filters A set of filters specifying to which array elements
+    #   an update should apply.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ BSON::Document ] The document.
     #
@@ -575,6 +886,10 @@ module Mongo
     #   not to skip document level validation.
     # @option options [ Hash ] :write_concern The write concern options.
     #   Defaults to the collection's write concern.
+    # @option options [ Hash ] :collation The collation to use.
+    # @option options [ Session ] :session The session to use.
+    # @option options [ 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_").
     #
     # @return [ BSON::Document ] The document.
     #
@@ -594,5 +909,14 @@ module Mongo
     def namespace
       "#{database.name}.#{name}"
     end
+
+    # Whether the collection is a system collection.
+    #
+    # @return [ Boolean ] Whether the system is a system collection.
+    #
+    # @api private
+    def system_collection?
+      name.start_with?('system.')
+    end
   end
 end