Delete Documents

Puedes eliminar documentos en MongoDB mediante los siguientes métodos:

El driver de su lenguaje de programación.
El Interfaz de usuario de MongoDB Atlas. Para obtener más información,consulte Eliminar un documento con MongoDB Atlas.
MongoDB Compass.

➤ Use el menú desplegable Seleccionar su lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos o seleccione MongoDB Compass.

Esta página utiliza lo siguiente mongosh métodos:

Los ejemplos en esta página utilizan la colección inventory. Para poblar la colección inventory, ejecute lo siguiente:

Esta página usa MongoDB Compass para borrar los documentos.

Completa la colección inventory con los siguientes documentos:

Esta página utiliza el siguiente controlador MongoDB C métodos:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

En esta página, se utilizan los siguientes métodos del driver C# de MongoDB:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza las siguientes funciones del controlador MongoDB Go:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos del controlador Java Reactive Streams:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos del controlador Java Synchronous:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

En esta página, se utilizan los siguientes métodos del driver corrutina de Kotlin:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos del controlador Motor:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos del driver MongoDB Nodo.js:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos de la biblioteca PHP de MongoDB:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos PyMongo del controlador de Python:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos del controlador Ruby de MongoDB:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página utiliza los siguientes métodos del controlador MongoDB Scala:

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

db.inventory.insertMany( [
   { item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "P" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" },
] );

[
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "P" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

Para obtener instrucciones sobre cómo insertar documentos en MongoDB Compass, consulta Insertar documentos.

Nota

Para obtener una referencia completa sobre la inserción de documentos en MongoDB Compass, consulta la documentación de Compass.

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("P"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}

var documents = new[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "P" }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h", 8.5 }, { "w", 11 }, { "uom", "in" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30 }, { "uom", "cm" } } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, { "uom", "cm" } } },
        { "status", "A" }
    }
};
collection.InsertMany(documents);

docs := []any{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "P"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));

collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("size", Document("h", 14).append("w", 21).append("uom", "cm"))
            .append("status", "A"),
        Document("item", "notebook")
            .append("qty", 50)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "A"),
        Document("item", "paper")
            .append("qty", 100)
            .append("size", Document("h", 8.5).append("w", 11).append("uom", "in"))
            .append("status", "D"),
        Document("item", "planner")
            .append("qty", 75)
            .append("size", Document("h", 22.85).append("w", 30).append("uom", "cm"))
            .append("status", "D"),
        Document("item", "postcard")
            .append("qty", 45)
            .append("size", Document("h", 10).append("w", 15.25).append("uom", "cm"))
            .append("status", "A"),
    )
)

await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "P",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
    ]
)

await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'P'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  }
]);

$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'P',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);

db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "P",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
    ]
)

client[:inventory].insert_many([
                                { item: 'journal',
                                  qty: 25,
                                  size: { h: 14, w: 21, uom: 'cm' },
                                  status: 'A' },
                                { item: 'notebook',
                                  qty: 50,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'P' },
                                { item: 'paper',
                                  qty: 100,
                                  size: { h: 8.5, w: 11, uom: 'in' },
                                  status: 'D' },
                                { item: 'planner',
                                  qty: 75,
                                  size: { h: 22.85, w: 30, uom: 'cm' },
                                  status: 'D' },
                                { item: 'postcard',
                                  qty: 45,
                                  size: { h: 10, w: 15.25, uom: 'cm' },
                                  status: 'A' },
                               ])

collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""")
)).execute()

Borrar todos los documentos

Para borrar todos los documentos de una colección, pasa un documento de filtro vacío {} al método db.collection.deleteMany().

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para eliminar todos los documentos de una colección, haga clic en el icono DELETE botón debajo de la pestaña Documents.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa el mongoc_collection_t y un bson_t que coincida con todos los documentos al método mongoc_collection_delete_many.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un filtro vacío Builders<BsonDocument>.Filter.Empty al método IMongoCollection.DeleteMany().

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un documento filtro vacío a la función Collection.DeleteMany.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un objeto org.bson.Document vacío como filtro al método com.mongodb.reactivestreams.client.MongoCollection.deleteMany.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para eliminar todos los documentos de una colección, pasa un objeto vacío de org.bson.Document como filtro al método com.mongodb.client.MongoCollection.deleteMany.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un objeto Bson vacío como filtro al método MongoCollection.deleteMany() .

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un documento filtro vacío {} al método motor.motor_asyncio.AsyncIOMotorCollection.delete_many.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para eliminar todos los documentos de una colección, pasa un documento de filtro vacío {} al método Collection.deleteMany() .

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pase un documento filtro vacío [] al método MongoDB\\Collection::deleteMany().

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un documento filtro vacío {} al método pymongo.collection.Collection.delete_many.

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para borrar todos los documentos de una colección, pasa un documento de filtro vacío {} al método Mongo::Collection#delete_many().

El siguiente ejemplo borra todos los documentos de la colección inventory:

Para eliminar todos los documentos de una colección, pasa un filtro vacío Document() al método collection.borrarMuchos() .

El siguiente ejemplo borra todos los documentos de la colección inventory:

db.inventory.deleteMany({})

MongoDB Compass mostrando la pestaña Documentos con el botón ELIMINAR resaltado.

mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW (NULL);
r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.DeleteMany(filter);

result, err := coll.DeleteMany(context.TODO(), bson.D{})

Publisher<DeleteResult> deleteManyPublisher = collection.deleteMany(new Document());

collection.deleteMany(new Document());

collection.deleteMany(empty())

await db.inventory.delete_many({})

await db.collection('inventory').deleteMany({});

$deleteResult = $db->inventory->deleteMany([]);

db.inventory.delete_many({})

client[:inventory].delete_many({})

collection.deleteMany(Document()).execute()

El método devuelve un documento con el estado de la operación. Para obtener más información y ejemplos, consulte deleteMany().

Cuando confirma la eliminación en la ventana emergente que aparece al hacer clic en DELETE, MongoDB Compass elimina todos los documentos y muestra un mensaje que indica cuántos documentos se eliminaron.

El método mongoc_collection_delete_many devuelve true si es exitoso, o devuelve false y establece un error si hay argumentos no válidos o se produce un error de servidor o de red.

Tras una ejecución exitosa, el método IMongoCollection.DeleteMany() devuelve una instancia de DeleteResult cuya propiedad DeletedCount contiene el número de documentos que coincidieron con el filtro.

Tras una ejecución exitosa, la función Collection.DeleteMany devuelve una instancia de DeleteResult, cuya propiedad DeletedCount contiene la cantidad de documentos que coincidieron con el filtro.

com.mongodb.reactivestreams.client.MongoCollection.deleteMany devuelve un objeto de Publisher de tipo com.mongodb.client.result.DeleteResult si es exitoso. Devuelve una instancia de com.mongodb.MongoException si no es exitoso.

El método com.mongodb.client.MongoCollection.deleteMany devuelve una instancia de com.mongodb.client.result.DeleteResult con el estado de la operación.

El método MongoCollection.deleteMany() devuelve una instancia de com.mongodb.client.result.DeleteResult que describe el estado de la operación y el recuento de documentos eliminados.

La delete_many corrutina devuelve asíncronamente una instancia de pymongo.results.DeleteResult con el estado de la operación.

Collection.deleteMany() devuelve una promesa que proporciona un result. La propiedad result.deletedCount contiene el número de documentos que coincidieron con el filtro.

Tras una ejecución exitosa, el método deleteMany() devuelve una instancia de MongoDB\\DeleteResult cuyo método getDeletedCount() devuelve el número de documentos que coincidieron con el filtro.

El método delete_many devuelve una instancia de pymongo.results.DeleteResult con el estado de la operación.

Tras una ejecución exitosa, el método delete_many() devuelve una instancia de Mongo::Operación::Result, cuyo atributo deleted_count contiene la cantidad de documentos que coincidieron con el filtro.

Tras una ejecución exitosa, el método colección.deleteMany() devuelve un Observable con un único elemento que tiene un parámetro de tipo DeleteResult o un com.mongodb.MongoException.

Borra todos los documentos que cumplan con una condición

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Además del filtro de igualdad, MongoDB ofrece varios operadores de query para especificar las condiciones del filtro. Utiliza los métodos de FilterDefinitionBuilder para crear un documento de filtro. Por ejemplo:

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

Además del filtro de igualdad, MongoDB proporciona varios operadores de query para especificar las condiciones del filtro. Utilice el paquete bson para crear operadores de query para documentos de filtro. Por ejemplo:

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

Además de la condición de igualdad, MongoDB ofrece varios operadores de query para especificar condiciones de filtros. Utiliza los métodos asistentes de com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Por ejemplo:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

Además de la condición de igualdad, MongoDB proporciona varios operadores de la query para especificar las condiciones de filtro. Utiliza los métodos asistentes com.mongodb.client.model.Filters_ para facilitar la creación de documentos de filtro. Por ejemplo:

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro de filtro al método deleteMany().

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para eliminar todos los documentos que cumplen los criterios de eliminación, escriba su filtro de consulta en la barra de consulta de Compass y haga clic en el botón DELETE en la pestaña Documents. El siguiente ejemplo elimina todos los documentos donde { status: "A" }:

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de supresión, pasa el mongoc_collection_t y un bson_t que coincida con los documentos que desea borrar al método mongoc_collection_delete_many.

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro de filtro al método IMongoCollection.DeleteMany().

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de borrado, pasa un parámetro de filtro a la función colección.DeleteMany.

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para eliminar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro de filtro al método com.mongodb.reactivestreams.client.MongoCollection.deleteMany.

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro filtro al método com.mongodb.client.MongoCollection.deleteMany.

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro filtro al método MongoCollection.deleteMany() .

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que cumplan con un criterio de eliminación, pasa un parámetro de filtro al método delete_many.

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de borrado, pasa un parámetro de filtro al método deleteMany().

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro de filtro al método deleteMany().

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que cumplan con un criterio de eliminación, pasa un parámetro de filtro al método delete_many.

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para eliminar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro filtro al método delete_many().

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

Puedes especificar criterios o filtros que identifiquen los documentos a borrar. Los filtros usan la misma sintaxis que las operaciones de lectura.

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>);

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

[ <field1> => <value1>, ... ]

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

{ <field1>: <value1>, ... }

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

{ <field1> => <value1>, ... }

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <value2>));

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", value2}}}},
    }},
}

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

and(gte(<field1>, <value1>), lt(<field2>, <value2>), eq(<field3>, <value3>))

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

[ <field1> => [ <operator1> => <value1> ], ... ]

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1>: { <operator1>: <value1> }, ... }

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

{ <field1> => { <operator1> => <value1> }, ... }

and(gte(<field1>, <value1>), lt(<field2>, <value2>), equal(<field3>, <value3>))

Para borrar todos los documentos que coincidan con un criterio de eliminación, pasa un parámetro de filtro al método deleteMany().

El siguiente ejemplo remueve todos los documentos de la colección inventory donde el campo status es igual a "A":

db.inventory.deleteMany({ status : "A" })

MongoDB Compass muestra la pestaña Documentos con el botón ELIMINAR resaltado con un filtro de { status: "A" }.

mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("status", BCON_UTF8 ("A"));
r = mongoc_collection_delete_many (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var result = collection.DeleteMany(filter);

result, err := coll.DeleteMany(
	context.TODO(),
	bson.D{
		{"status", "A"},
	},
)

deleteManyPublisher = collection.deleteMany(eq("status", "A"));

collection.deleteMany(eq("status", "A"));

collection.deleteMany(eq("status", "A"));

await db.inventory.delete_many({"status": "A"})

await db.collection('inventory').deleteMany({ status: 'A' });

$deleteResult = $db->inventory->deleteMany(['status' => 'A']);

db.inventory.delete_many({"status": "A"})

client[:inventory].delete_many(status: 'A')

collection.deleteMany(equal("status", "A")).execute()

El método devuelve un documento con el estado de la operación. Para obtener más información y ejemplos, consulte deleteMany().

El método mongoc_collection_delete_many devuelve true si es exitoso, o devuelve false y establece un error si hay argumentos no válidos o se produce un error de servidor o de red.

Tras una ejecución exitosa, la función Collection.DeleteMany devuelve una instancia de DeleteResult, cuya propiedad DeletedCount contiene la cantidad de documentos que coincidieron con el filtro.

El método com.mongodb.client.MongoCollection.deleteMany devuelve una instancia de com.mongodb.client.result.DeleteResult con el estado de la operación.

El método MongoCollection.deleteMany() devuelve una instancia de com.mongodb.client.result.DeleteResult que describe el estado de la operación y el recuento de documentos eliminados.

La delete_many corrutina devuelve asíncronamente una instancia de pymongo.results.DeleteResult con el estado de la operación.

Collection.deleteMany() devuelve una promesa que proporciona un result. La propiedad result.deletedCount contiene el número de documentos que coincidieron con el filtro.

El método delete_many devuelve una instancia de pymongo.results.DeleteResult con el estado de la operación.

Tras una ejecución exitosa, el método colección.deleteMany() devuelve un Observable con un único elemento que tiene un parámetro de tipo DeleteResult o un com.mongodb.MongoException.

Borra solo un documento que cumpla con una condición

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), usa el método db.collection.deleteOne().

El siguiente ejemplo borra el primer documento donde status es "D":

Para eliminar un solo documento que coincida con un filtro específico:

Escriba su filtro de consulta en la barra de consulta de Compass y haga clic en Find.
Pase el ratón sobre el documento que desea eliminar.
Haga clic en el botón en el lado derecho de su documento.

El siguiente ejemplo elimina un documento con { status: "A" } de la colección inventory:

Para borrar un solo documento de una colección, pasa el mongoc_collection_t y un bson_t que coincida con el documento que deseas borrar al método mongoc_collection_delete_one.

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), utiliza el método IMongoCollection.DeleteOne().

El siguiente ejemplo borra el primer documento donde status es "D":

Para eliminar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), usa la función Collection.DeleteOne.

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un único documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado) utiliza el método com.mongodb.reactivestreams.client.MongoCollection.deleteMany.

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un único documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), utiliza el método com.mongodb.cliente.MongoCollection.deleteOne.

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un único documento que coincida con un filtro especificado, incluso si varios documentos coinciden con el filtro especificado, puedes usar el método MongoCollection.deleteOne() .

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), utiliza el método motor.motor_asyncio.AsyncIOMotorCollection.delete_one.

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), usa el método Collection.deleteOne() .

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), utilice el método MongoDB\\Collection::deleteOne().

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), utiliza el método pymongo.collection.Collection.delete_one.

El siguiente ejemplo borra el primer documento donde status es "D":

Para eliminar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado), utiliza el método Mongo::Collection#delete_one().

El siguiente ejemplo borra el primer documento donde status es "D":

Para borrar como máximo un solo documento que coincida con un filtro especificado (aunque varios documentos puedan coincidir con el filtro especificado) usa el método collection.deleteOne() .

El siguiente ejemplo borra el primer documento donde status es "D":

db.inventory.deleteOne( { status: "D" } )

MongoDB Compass Eliminar un documento que coincida con un filtro

mongoc_collection_t *collection;
bson_t *selector;
bool r;
bson_error_t error;
collection = mongoc_database_get_collection (db, "inventory");
selector = BCON_NEW ("status", BCON_UTF8 ("D"));
r = mongoc_collection_delete_one (collection, selector, NULL, NULL, &error);
bson_destroy (selector);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}

Limpie cualquier recurso abierto llamando a los siguientes métodos, según corresponda:

var filter = Builders<BsonDocument>.Filter.Eq("status", "D");
var result = collection.DeleteOne(filter);

result, err := coll.DeleteOne(
	context.TODO(),
	bson.D{
		{"status", "D"},
	},
)

Publisher<DeleteResult> deleteOnePublisher = collection.deleteOne(eq("status", "D"));

collection.deleteOne(eq("status", "D"));

El siguiente ejemplo borra el primer documento donde status es "D":

await db.inventory.delete_one({"status": "D"})

await db.collection('inventory').deleteOne({ status: 'D' });

$deleteResult = $db->inventory->deleteOne(['status' => 'D']);

db.inventory.delete_one({"status": "D"})

client[:inventory].delete_one(status: 'D')

collection.deleteOne(equal("status", "D")).execute()

Borra un documento con MongoDB Atlas

Nota

Solo se puede borrar un documento a la vez en la interfaz de usuario de MongoDB Atlas. Para borrar varios documentos, se debe realizar la conexión a la implementación de Atlas desde mongosh o un driver de MongoDB y seguir los ejemplos de esta página para el método que se prefiera.

El ejemplo en esta sección utiliza el conjunto de datos de películas de muestra. Para aprender a cargar el conjunto de datos de muestra en la implementación de MongoDB Atlas, se debe consultar Cargar datos de muestra.

Para eliminar un documento en MongoDB Atlas, sigue estos pasos:

En la interfaz de usuario de MongoDB Atlas, vaya a la Clusters página de su proyecto.

Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Clusters en la sección Database.
La página de clústeres se muestra.

Navega a la colección.

Para el clúster que contiene los datos de muestra, haz clic en Browse Collections.
En el panel de navegación izquierdo, seleccione la base de datos sample_mflix.
Seleccione la colección movies.

Especifica un documento de filtro de query.

Opcionalmente, puedes especificar un documento de filtro de query en el campo Filter. Un documento de filtro de query utiliza operadores del query para especificar condiciones de búsqueda.

Copia el siguiente documento de filtro de query en la barra de búsqueda Filter y haz clic en Apply:

{ genres: "Action", rated: { $in: [ "PG", "PG-13" ] } }

Este filtro de query devuelve todos los documentos en la colección sample_mflix.movies donde genres es igual a Action y rated es igual a PG o PG-13.

Borrar un documento.

Si deseas borrar un documento, coloca el cursor sobre él y haz clic en el ícono de la papelera que aparece a la derecha.
Después de hacer clic en el botón de borrar, MongoDB Atlas marca el documento para su eliminación y solicita confirmación.
Se debe hacer clic en Delete para confirmar la selección.

Para obtener más información, consulte Crear, ver, actualizar y borrar documentos.

Comportamiento de eliminación

Indexes

Las operaciones de eliminación no desechan índices, incluso si se borran todos los documentos de una colección.

Atomicidad

Todas las operaciones de guardado en MongoDB son atómicas a nivel de un solo documento. Para obtener más información sobre MongoDB y la atomicidad, consulta Atomicidad y Transacciones.

Guardar reconocimiento

Con los niveles de confirmación de escritura (write concern), se puede especificar el nivel de reconocimiento solicitado a MongoDB para las operaciones de escritura. Para obtener más detalles, consultar Nivel de confirmación de escritura.

Tip

Volver

Utilizar MQL para actualizar un arreglo

Métodos

Nota

Borrar todos los documentos

Borra todos los documentos que cumplan con una condición

Borra solo un documento que cumpla con una condición

Borra un documento con MongoDB Atlas

Nota

En la interfaz de usuario de MongoDB Atlas, vaya a la Clusters página de su proyecto.

Navega a la colección.

Especifica un documento de filtro de query.

Borrar un documento.

Comportamiento de eliminación

Indexes

Atomicidad

Guardar reconocimiento

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Tip

Obtén una insignia de habilidad