mongo 2.14.0.rc1 → 2.16.0.alpha1

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,16 +24,6 @@ module Mongo
       # @since 2.0.0
       module Readable
 
-        # The query modifier constant.
-        #
-        # @since 2.2.0
-        QUERY = '$query'.freeze
-
-        # The modifiers option constant.
-        #
-        # @since 2.2.0
-        MODIFIERS = 'modifiers'.freeze
-
         # Execute an aggregation on the collection view.
         #
         # @example Aggregate documents.
@@ -166,14 +159,16 @@ module Mongo
           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)
+                selector: cmd,
+                db_name: database.name,
+                options: {:limit => -1},
+                read: read_pref,
+                session: session,
+                # For some reason collation was historically accepted as a
+                # string key. Note that this isn't documented as valid usage.
+                collation: opts[:collation] || opts['collation'] || collation,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end.n.to_i
           end
         end
@@ -226,24 +221,56 @@ module Mongo
         #
         # @since 2.6.0
         def estimated_document_count(opts = {})
-          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)
+          unless view.filter.empty?
+            raise ArgumentError, "Cannot call estimated_document_count when querying with a filter"
           end
+
+          %i[limit skip].each do |opt|
+            if @options.key?(opt)
+              raise ArgumentError, "Cannot call estimated_document_count when querying with #{opt}"
+            end
+          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
+              context = Operation::Context.new(client: client, session: session)
+              if server.description.server_version_gte?('5.0')
+                pipeline = [
+                  {'$collStats' => {'count' => {}}},
+                  {'$group' => {'_id' => 1, 'n' => {'$sum' => '$count'}}},
+                ]
+                spec = Builder::Aggregation.new(pipeline, self, options.merge(session: session)).specification
+                result = Operation::Aggregate.new(spec).execute(server, context: context)
+                result.documents.first.fetch('n')
+              else
+                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
+                result = Operation::Count.new(
+                  selector: cmd,
+                  db_name: database.name,
+                  read: read_pref,
+                  session: session,
+                ).execute(server, context: context)
+                result.n.to_i
+              end
+            end
+          end
+        rescue Error::OperationFailure => exc
+          if exc.code == 26
+            # NamespaceNotFound
+            # This should only happen with the aggregation pipeline path
+            # (server 4.9+). Previous servers should return 0 for nonexistent
+            # collections.
+            0
+          else
+            raise
           end
         end
 
@@ -280,14 +307,16 @@ module Mongo
           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)
+              Operation::Distinct.new(
+                selector: cmd,
+                db_name: database.name,
+                options: {:limit => -1},
+                read: read_pref,
+                session: session,
+                # For some reason collation was historically accepted as a
+                # string key. Note that this isn't documented as valid usage.
+                collation: opts[:collation] || opts['collation'] || collation,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end.first['values']
           end
         end
@@ -507,7 +536,11 @@ module Mongo
           configure(:sort, spec)
         end
 
-        # “meta” operators that let you modify the output or behavior of a query.
+        # If called without arguments or with a nil argument, returns
+        # the legacy (OP_QUERY) server modifiers for the current view.
+        # If called with a non-nil argument, which must be a Hash or a
+        # subclass, merges the provided modifiers into the current view.
+        # Both string and symbol keys are allowed in the input hash.
         #
         # @example Set the modifiers document.
         #   view.modifiers(:$orderby => Mongo::Index::ASCENDING)
@@ -518,8 +551,11 @@ module Mongo
         #
         # @since 2.1.0
         def modifiers(doc = nil)
-          return Builder::Modifiers.map_server_modifiers(options) if doc.nil?
-          new(options.merge(Builder::Modifiers.map_driver_options(doc)))
+          if doc.nil?
+            Operation::Find::Builder::Modifiers.map_server_modifiers(options)
+          else
+            new(options.merge(Operation::Find::Builder::Modifiers.map_driver_options(BSON::Document.new(doc))))
+          end
         end
 
         # A cumulative time limit in milliseconds for processing get more operations
@@ -601,43 +637,51 @@ module Mongo
         end
 
         def server_selector
-          if options[:session] && options[:session].in_transaction?
+          @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)
+            ServerSelector.get(read_preference || collection.server_selector)
           end
         end
 
         def parallel_scan(cursor_count, options = {})
           if options[:session]
+            # The session would be overwritten by the one in +options+ later.
             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 => read_concern,
-                  :session => session,
-                }.merge!(options))
-          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
+          spec = {
+            coll_name: collection.name,
+            db_name: database.name,
+            cursor_count: cursor_count,
+            read_concern: read_concern,
+            session: session,
+          }.update(options)
+          session = spec[:session]
+          op = Operation::ParallelScan.new(spec)
+          # Note that the context object shouldn't be reused for subsequent
+          # GetMore operations.
+          context = Operation::Context.new(client: client, session: session)
+          result = op.execute(server, context: context)
+          result.cursor_ids.map do |cursor_id|
+            spec = {
+              cursor_id: cursor_id,
+              coll_name: collection.name,
+              db_name: database.name,
+              session: session,
+              batch_size: batch_size,
+              to_return: 0,
+              # max_time_ms is not being passed here, I assume intentionally?
+            }
+            op = Operation::GetMore.new(spec)
+            context = Operation::Context.new(
+              client: client,
+              session: session,
+              service_id: result.connection_description.service_id,
+            )
+            result = op.execute(server, context: context)
             Cursor.new(self, result, server, session: session)
           end
         end

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -43,34 +46,45 @@ 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.
         #
         # @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, client: client)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
+            if opts[:hint] && write_concern && !write_concern.acknowledged?
+              raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            end
+
+            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,
+            }.compact
+
+            write_with_retry(session, write_concern) do |server, txn_num|
+              Operation::WriteCommand.new(
+                selector: cmd,
+                db_name: database.name,
+                write_concern: write_concern,
+                session: session,
+                txn_num: txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end.first['value']
         end
@@ -93,6 +107,8 @@ 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.
         #
         # @return [ BSON::Document ] The document.
         #
@@ -124,38 +140,48 @@ 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.
         #
         # @return [ BSON::Document ] The document.
         #
         # @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, client: client)
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              write_concern_with_session(session)
+            end
+            if opts[:hint] && write_concern && !write_concern.acknowledged?
+              raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            end
+
+            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,
+            }.compact
+
+            write_with_retry(session, write_concern) do |server, txn_num|
+              Operation::WriteCommand.new(
+                selector: cmd,
+                db_name: database.name,
+                write_concern: write_concern,
+                session: session,
+                txn_num: txn_num,
+              ).execute(server, context: Operation::Context.new(client: client, session: session))
             end
           end.first['value']
           value unless value.nil? || value.empty?
@@ -179,27 +205,34 @@ module Mongo
         #
         # @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))
+            if opts[:hint] && write_concern && !write_concern.acknowledged?
+              raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            end
+
+            QueryCache.clear_namespace(collection.namespace)
+
+            delete_doc = {
+              Operation::Q => filter,
+              Operation::LIMIT => 0,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
 
+            nro_write_with_retry(session, write_concern) do |server|
               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, client: client)
+                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))
             end
           end
         end
@@ -222,28 +255,35 @@ module Mongo
         #
         # @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))
+            if opts[:hint] && write_concern && !write_concern.acknowledged?
+              raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            end
 
+            QueryCache.clear_namespace(collection.namespace)
+
+            delete_doc = {
+              Operation::Q => filter,
+              Operation::LIMIT => 1,
+              hint: opts[:hint],
+              collation: opts[:collation] || opts['collation'] || collation,
+            }.compact
+
+            write_with_retry(session, write_concern) do |server, txn_num|
               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, client: client)
+                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))
             end
           end
         end
@@ -271,35 +311,39 @@ module Mongo
         #
         # @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
+            if opts[:hint] && write_concern && !write_concern.acknowledged?
+              raise Error::UnsupportedOption.hint_error(unacknowledged_write: 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))
+            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|
               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, client: client)
+                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))
             end
           end
         end
@@ -329,34 +373,39 @@ module Mongo
         #
         # @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))
+            if opts[:hint] && write_concern && !write_concern.acknowledged?
+              raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            end
+
+            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
 
+            nro_write_with_retry(session, write_concern) do |server|
               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, client: client)
+                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))
             end
           end
         end
@@ -386,83 +435,40 @@ module Mongo
         #
         # @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))
-
-              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, client: client)
-            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?
+            if opts[:hint] && 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
+            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
 
-            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)
+            write_with_retry(session, write_concern) do |server, txn_num|
+              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))
+            end
           end
         end
       end