db.colección.deleteMany() (método de mongosh)

Colecciones fragmentadas

• Si deleteMany() se ejecuta fuera de una transacción, las operaciones que apuntan a más de una partición difunden la operación a todas las particiones del clúster.

• Si deleteMany() se ejecuta dentro de una transacción, las operaciones que apuntan a más de una partición solo afectan a las particiones relevantes.

Borrar un único documento

En cambio, para borrar un solo documento, use db.collection.deleteOne().

Como alternativa, utilice un campo que sea parte de un índice único como _id.

Transacciones

db.collection.deleteMany() puede usarse dentro de transacciones distribuidas.

No establezcas explícitamente el nivel de confirmación de escritura para la operación si se ejecuta en una transacción. Para usar el nivel de confirmación de escritura con transacciones, consulta Transacciones y nivel de confirmación de escritura.

Fallo del nodo primario

db.collection.deleteMany() borra documentos uno a la vez. Si el nodo primario falla durante una operación de db.collection.deleteMany(), los documentos que aún no se han borrados de los nodos secundarios no se borrarán de la colección.

Entradas de OpLog

Si una operación db.collection.deleteMany() borra correctamente uno o más documentos, la operación agrega una entrada para cada documento borrado en el oplog (registro de operaciones). Si la operación falla o no encuentra ningún documento para borrar, no agrega una entrada en el oplog.

Borra varios documentos

La colección orders tiene documentos con la siguiente estructura:

db.orders.insertOne(
   {
      _id: ObjectId("563237a41a4d68582c2509da"),
      stock: "Brent Crude Futures",
      qty: 250,
      type: "buy-limit",
      limit: 48.90,
      creationts: ISODate("2015-11-01T12:30:15Z"),
      expiryts: ISODate("2015-11-01T12:35:15Z"),
      client: "Crude Traders Inc."
   }
)

La siguiente operación borra todos los documentos donde client : "Crude Traders Inc.":

try {
   db.orders.deleteMany( { "client" : "Crude Traders Inc." } );
} catch (e) {
   print (e);
}

La operación arroja:

{ "acknowledged" : true, "deletedCount" : 10 }

La siguiente operación borra todos los documentos donde stock : "Brent Crude Futures" y limit son mayores que 48.88:

try {
   db.orders.deleteMany( { "stock" : "Brent Crude Futures", "limit" : { $gt : 48.88 } } );
} catch (e) {
   print (e);
}

La operación arroja:

{ "acknowledged" : true, "deletedCount" : 8 }

deleteMany() con un tiempo de espera y variables de query

La siguiente Operación borra todos los documentos donde client es igual a la variable targetClient y establece un límite de tiempo de 3 segundos:

try {
   db.orders.deleteMany(
       { $expr: { $eq: ["$client", "$$targetClient"] } },
       {
           let: { targetClient: "Crude Traders Inc." },
           maxTimeMS: 3000
       }
   );
} catch (e) {
   print(e);
}

La operación arroja:

{ "acknowledged" : true, "deletedCount" : 1 }

deleteMany() con nivel de confirmación de escritura (write concern)

Dado un set de réplicas de tres nodos, la siguiente operación especifica un w de majority y un wtimeout de 100:

try {
   db.orders.deleteMany(
       { "client" : "Crude Traders Inc." },
       { writeConcern: { w : "majority", wtimeout : 100 }}
   );
} catch (e) {
   print (e);
}

Si el reconocimiento tarda más que el límite de wtimeout, se obtiene la siguiente excepción:

WriteConcernError({
   "code" : 64,
   "errmsg" : "waiting for replication timed out",
   "errInfo" : {
     "wtimeout" : true,
     "writeConcern" : {
       "w" : "majority",
       "wtimeout" : 100,
       "provenance" : "getLastErrorDefaults"
     }
   }
})

Especificar la intercalación

La intercalación permite a los usuarios especificar reglas propias del lenguaje para la comparación de strings, como reglas para el uso de mayúsculas y minúsculas y marcas de acento.

Una colección restaurants tiene los siguientes documentos:

db.restaurants.insertMany( [
   { _id: 1, category: "café", status: "A" },
   { _id: 2, category: "cafe", status: "a" },
   { _id: 3, category: "cafE", status: "a" }
] )

La siguiente operación incluye la opción de intercalación:

db.restaurants.deleteMany(
   { category: "cafe", status: "A" },
   { collation: { locale: "fr", strength: 1 } }
)

Especifique hint para las operaciones de borrado

En mongosh, crea una colección de members con los siguientes documentos:

db.members.insertMany([
   { "_id" : 1, "member" : "abc123", "status" : "P", "points" :  0,  "misc1" : null, "misc2" : null },
   { "_id" : 2, "member" : "xyz123", "status" : "A", "points" : 60,  "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" },
   { "_id" : 3, "member" : "lmn123", "status" : "P", "points" :  0,  "misc1" : null, "misc2" : null },
   { "_id" : 4, "member" : "pqr123", "status" : "D", "points" : 20,  "misc1" : "Deactivated", "misc2" : null },
   { "_id" : 5, "member" : "ijk123", "status" : "P", "points" :  0,  "misc1" : null, "misc2" : null },
   { "_id" : 6, "member" : "cde123", "status" : "A", "points" : 86,  "misc1" : "reminder: ping me at 100pts", "misc2" : "Some random comment" }
])

Cree los siguientes índices en la colección:

db.members.createIndex( { status: 1 } )
db.members.createIndex( { points: 1 } )

La siguiente operación de eliminación indica explícitamente que se debe usar el índice { status: 1 }:

db.members.deleteMany(
   { "points": { $lte: 20 }, "status": "P" },
   { hint: { status: 1 } }
)

El comando para borrar devuelve lo siguiente:

{ "acknowledged" : true, "deletedCount" : 3 }

Para ver los índices utilizados, puede usar el pipeline $indexStats:

db.members.aggregate( [ { $indexStats: { } }, { $sort: { name: 1 } } ] )

El campo accesses.ops en el resultado $indexStats indica la cantidad de operaciones que usaron el índice.