Exclua documentos

Nesta página

Excluir todos os documentos

Excluir todos os documentos que correspondem a uma condição
Excluir apenas um documento que corresponda a uma condição
Excluir um documento com Atlas MongoDB
Excluir comportamento

Você pode excluir documentos no MongoDB com os seguintes métodos:

O driver da sua linguagem de programação.
A IU doMongoDB Atlas. Para saber mais, consulte Excluir um documento com Atlas MongoDB.
MongoDB Compass.

➤ Use o menu suspenso Selecione a linguagem no canto superior direito para definir a linguagem dos exemplos a seguir ou selecione MongoDB Compass.

Esta página usa os seguintes métodos mongosh:

Os exemplos nesta página utilizam a collection inventory. Para preencher a collection inventory, execute o seguinte:

Esta página usa o MongoDB Compass para excluir os documentos.

Preencha a coleção inventory com os seguintes documentos:

Esta página usa o seguinte MongoDB C Driver métodos:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver C# do MongoDB:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa as seguintes funções do driver Go do MongoDB:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver Java Reactive Streams:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página utiliza os seguintes métodos Java Synchronous Driver:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver Kotlin Coroutine :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver Motor:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver do MongoDB Node.js :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver Perl do MongoDB:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos da biblioteca PHP do MongoDB:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes Métodos do driver Python PyMongo :

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver do MongoDB Ruby:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção inventory:

Esta página usa os seguintes métodos do driver Scala do MongoDB:

Os exemplos nesta página utilizam a coleção inventory. Conecte a um banco de dados de teste em sua instância MongoDB e, em seguida, crie a coleção 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 obter instruções sobre como inserir documentos no MongoDB Compass, consulte Insira documentos.

Observação

Para obter referência completa sobre como inserir documentos no MongoDB Compass, consulte a documentação do 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 := []interface{}{
	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'
  }
]);

$db->coll("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"
        }
    ]
);

$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()

Excluir todos os documentos

Para excluir todos os documentos de uma collection, passe um documento filtro vazio {} para o método db.collection.deleteMany().

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma collection, passe mongoc_collection_t e um bson_t que corresponda a todos os documentos para mongoc_collection_delete_many método.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um filtro vazio Builders<BsonDocument>.Filter.Empty para o método IMongoCollection.DeleteMany().

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um documento de filtro vazio para a função Collection.DeleteMany.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um objeto org.bson.Document vazio como filtro para o método com.mongodb.reactivestreams.client.MongoCollection.deleteMany.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um objeto org.bson.Document vazio como filtro para o método com.mongodb.client.MongoCollection.deleteMany.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma collection, passe um Bson objeto vazio como filtro para o MongoCollection.deleteMany() método.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um documento de filtro vazio {} para o método motor.motor_asyncio.AsyncIOMotorCollection.delete_many.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma collection, passe um documento com filtro vazio {} para o arquivo com o método Collection.deleteMany() .

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um documento de filtro vazio {} para o método MongoDB: :Collection: :delete_many ().

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um documento [] com filtro vazio para o método MongoDB\\Collection::deleteMany().

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um documento de filtro vazio {} para o método pymongo.collection.Collection.delete_many.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um documento de filtro vazio {} para o método Mongo::Collection#delete_many().

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir todos os documentos de uma coleção, passe um Document() com filtro vazio para o método collection.deleteMany() .

O exemplo a seguir exclui todos os documentos da collection inventory:

db.inventory.deleteMany({})

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({});

$db->coll("inventory")->delete_many( {} );

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

db.inventory.delete_many({})

client[:inventory].delete_many({})

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

O método retorna um documento com o status da operação. Para obter mais informações e exemplos, consulte deleteMany().

A mongoc_collection_delete_many método retorna true se for bem-sucedido ou retorna false e define um erro se houver argumentos inválidos ou se ocorrer um erro de servidor ou rede.

Após a execução bem-sucedida, o método IMongoCollection.DeleteMany() retorna uma instância de DeleteResult cuja propriedade DeletedCount contém o número de documentos removidos que atendiam ao critério do filtro.

Após a execução bem-sucedida, a função Collection.deleteMany retorna uma instância de DeleteResult cuja DeletedCount propriedade contém o número de documentos que corresponderam ao filtro.

com.mongodb.reactivestreams.client.MongoCollection.deleteMany retorna um Publisher objeto do tipo com.mongodb.client.result.DeleteResult se for bem-sucedido. Retorna uma instância de com.mongodb.MongoException se não for bem-sucedido.

O método com.mongodb.client.MongoCollection.deleteMany retorna uma instância de com.mongodb.client.result.DeleteResult com o status da operação.

O arquivo MongoCollection.deleteMany() método retorna uma instância de com.mongodb. cliente.result.DeleteResult que descreve o status da operação e a contagem de documentos excluídos.

A corrotina delete_many retorna de forma assíncrona uma instância de pymongo.results.DeleteResult com o status da operação.

Collection.deleteMany() retorna uma promessa que fornece um result. A result.deletedCount propriedade contém o número de documentos que correspondem ao filtro.

Após a execução bem-sucedida, o método delete_many() retorna uma instância de MongoDB::DeleteResult cujo atributo deleted_count contém o número de documentos que correspondem ao filtro.

Após a execução bem-sucedida, o método deleteMany() retorna uma instância de MongoDB\\DeleteResult cujo método getDeletedCount() retorna o número de documentos que atendiam ao critério do filtro.

O método delete_many retorna uma instância de pymongo.results.DeleteResult com o status da operação.

Após a execução bem-sucedida, o método exclua_many() retorna uma instância de Mongo::Operation::Result, cujo atributo deleted_count contém o número de documentos que corresponderam ao filtro.

Após a execução bem-sucedida, o collection.deleteMany() O método retorna um Observável com um único elemento com um DeleteResult parâmetro do tipo ou com um com.mongodb.MongoException.

Excluir todos os documentos que correspondem a uma condição

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Além do filtro de igualdade, o MongoDB fornece vários operadores de consulta para especificar as condições do filtro. Use os métodos do FilterDefinitionBuilder para criar um documento de filtro. Por exemplo:

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

Além da condição de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Por exemplo:

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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Além da condição de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use os métodos auxiliares com.mongodb.client.model.Filters_ para facilitar a criação de documentos de filtro. Por exemplo:

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

Para excluir todos os documentos correspondentes a um critério de exclusão, passe um parâmetro de filtro para o método deleteMany().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe mongoc_collection_t e um bson_t que corresponde aos documentos a serem excluídos para mongoc_collection_delete_many método.

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método IMongoCollection.DeleteMany().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondam a um critério de exclusão, passe um parâmetro de filtro para a função Collection.DeleteMany.

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método com.mongodb.reactivestreams.client.MongoCollection.deleteMany.

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondam aos critérios de exclusão, passe um parâmetro filtro para o método com.mongodb.client.MongoCollection.deleteMany.

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondam a um critério de exclusão, passe um parâmetro de filtro para o MongoCollection.deleteMany() método.

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método delete_many.

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondam a um critério de exclusão, passe um parâmetro de filtro para o método deleteMany ().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método delete_many().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método deleteMany().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método delete_many.

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método delete_many().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

Você pode especificar critérios ou filtros que identifiquem os documentos a serem excluídos. Os filtros utilizam a mesma sintaxe das operações de leitura.

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, construa um filtro usando o método Eq:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq para criar o documento do filtro de consulta:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Para especificar condições de igualdade, use o método Filters.eq() método para criar o documento de filtro de query :

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field>:<value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize expressões <field> => <value> no documento do filtro de queries:

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

Para especificar condições de igualdade, utilize o método com.mongodb.client.model.Filters.eq_ para criar o documento de filtro de query:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

var builder = Builders<BsonDocument>.Filter;
builder.And(builder.Eq(<field1>, <value1>), builder.Lt(<field2>, <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>))

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de queries pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

Para excluir todos os documentos que correspondem a um critério de exclusão, passe um parâmetro de filtro para o método deleteMany().

O exemplo a seguir remove todos os documentos da collection inventory em que o campo status é igual a "A":

db.inventory.deleteMany({ 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' });

$db->coll("inventory")->delete_many( { 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()

O método retorna um documento com o status da operação. Para obter mais informações e exemplos, consulte deleteMany().

A mongoc_collection_delete_many método retorna true se for bem-sucedido ou retorna false e define um erro se houver argumentos inválidos ou se ocorrer um erro de servidor ou rede.

Após a execução bem-sucedida, a função Collection.deleteMany retorna uma instância de DeleteResult cuja DeletedCount propriedade contém o número de documentos que corresponderam ao filtro.

O método com.mongodb.client.MongoCollection.deleteMany retorna uma instância de com.mongodb.client.result.DeleteResult com o status da operação.

O arquivo MongoCollection.deleteMany() método retorna uma instância de com.mongodb. cliente.result.DeleteResult que descreve o status da operação e a contagem de documentos excluídos.

A corrotina delete_many retorna de forma assíncrona uma instância de pymongo.results.DeleteResult com o status da operação.

Collection.deleteMany() retorna uma promessa que fornece um result. A result.deletedCount propriedade contém o número de documentos que correspondem ao filtro.

Após a execução bem-sucedida, o método delete_many() retorna uma instância de MongoDB::DeleteResult cujo atributo deleted_count contém o número de documentos que correspondem ao filtro.

O método delete_many retorna uma instância de pymongo.results.DeleteResult com o status da operação.

Após a execução bem-sucedida, o collection.deleteMany() O método retorna um Observável com um único elemento com um DeleteResult parâmetro do tipo ou com um com.mongodb.MongoException.

Excluir apenas um documento que corresponda a uma condição

Para excluir no máximo um único documento que corresponda a um filtro especificado (mesmo que vários documentos possam corresponder ao filtro especificado), use o método db.collection.deleteOne().

O exemplo a seguir exclui o primeiro documento em que status é "D":

O MongoDB Compass permite excluir facilmente um documento de uma coleção. O exemplo abaixo mostra como excluir um documento da coleção inventory onde item é igual a paper:

Observação

Neste exemplo, estamos usando a exibição de tabela do Compass para excluir o documento. O processo de exclusão usando a exibição de lista do Compass segue uma abordagem muito semelhante.

Para obter mais informações sobre as diferenças entre a Exibição de Tabela e a Exibição de Lista no Compass, consulte a documentação do Compass.

Para excluir um único documento de uma collection, passe mongoc_collection_t e um bson_t que corresponde ao documento que você deseja excluir para mongoc_collection_delete_one método.

O exemplo a seguir exclui todos os documentos da collection inventory:

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método IMongoCollection.DeleteOne().

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use a função Collection.DeleteOne.

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método com.mongodb.reactivestreams.client.MongoCollection.deleteMany.

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado, mesmo que vários documentos correspondam ao filtro especificado, você pode usar o método MongoCollection.deleteOne() método.

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método motor.motor_asyncio.AsyncIOMotorCollection.delete_one.

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use Collection.deleteOne() como método.

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método MongoDB::Collection::delete_one().

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (mesmo que vários documentos possam corresponder ao filtro especificado), use o método MongoDB\\Collection::deleteOne().

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método pymongo.collection.Collection.delete_one.

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (mesmo que vários documentos possam corresponder ao filtro especificado), use o método Mongo::Collection#delete_one().

O exemplo a seguir exclui o primeiro documento em que status é "D":

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método Collection.deleteOne() .

O exemplo a seguir exclui o primeiro documento em que status é "D":

db.inventory.deleteOne( { status: "D" } )

Clique no botão Table na navegação superior para acessar a Visualização de Tabela:
Use a barra de query do Compass para localizar o documento de destino.
Copie o seguinte documento de filtro na barra de consulta e clique em Find:
```
{ item: "paper" }
```
Passe o mouse sobre o documento e clique no ícone de lixeira que aparece no lado direito.
Após clicar no botão de exclusão, o documento é sinalizado para exclusão. O Compass solicita a confirmação de que você deseja remover o documento:
Clique em Delete para confirmar. O Compass exclui o documento da coleção.

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;
}

Certifique-se também de limpar quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:

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"));

await db.inventory.delete_one({"status": "D"})

await db.collection('inventory').deleteOne({ status: 'D' });

$db->coll("inventory")->delete_one( { 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()

Excluir um documento com Atlas MongoDB

Observação

Você pode excluir somente um documento de cada vez na IU do Atlas MongoDB. Para excluir vários documentos, conecte-se à sua implantação do Atlas a partir de mongosh ou de um driver do MongoDB e siga os exemplos nesta página para o método de sua preferência.

O exemplo nesta seção utiliza o conjunto de dados de filmes de amostra. Para saber como carregar o conjunto de dados de amostra em sua implantação do MongoDB Atlas, consulte Carregue dados de amostra.

Para excluir um documento no MongoDB Atlas, siga estas etapas:

Na IU do MongoDB Atlas, acesse a página Clusters do seu projeto.

Se ainda não tiver sido exibido, selecione a organização que contém seu projeto no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Se ainda não estiver exibido, clique em Clusters na barra lateral.
A página Clusters é exibida.

Navegue até a coleção.

Para o cluster que contém os dados de amostra, clique em Browse Collections.
No painel de navegação esquerdo, selecione o banco de dados sample_mflix.
Selecione a collection movies.

Especifique um documento de filtro de consulta.

Opcionalmente, você pode especificar um documento de filtro de query no campo Filter. Um documento de filtro de query usa operadores de query para especificar as condições de pesquisa.

Copie o seguinte documento de filtro de query na barra de pesquisa do Filter e clique em Apply:

{ genres: "Action", rated: { $in: [ "PG", "PG-13" ] } }

Este filtro de queries retorna todos os documentos da coleção sample_mflix.movies onde genres é igual a Action e rated é igual a PG ou PG-13.

Excluir um documento.

Para o documento que você deseja excluir, passe o mouse sobre o documento e clique no ícone de lixeira que aparece no lado direito.
Após clicar no botão excluir, o MongoDB Atlas sinaliza o documento para exclusão e solicita sua confirmação.
Clique em Delete para confirmar sua seleção.

Para saber mais, consulte Criar, exibir, atualizar e excluir documentos.

Excluir comportamento

Indexes

As operações de exclusão não eliminam índices, mesmo excluindo todos os documentos de uma coleção.

Atomicidade

Todas as operações de gravação no MongoDB são atômicas no nível de um único documento. Para obter mais informações sobre MongoDB e atomicidade, consulte Atomicidade e transações.

Escrever confirmação

Com preocupações de gravação, você pode especificar o nível de confirmação solicitado do MongoDB para operações de gravação. Para mais informações, consulte preocupação de gravação.

Observação

Excluir todos os documentos

Excluir todos os documentos que correspondem a uma condição

Excluir apenas um documento que corresponda a uma condição

Observação

Excluir um documento com Atlas MongoDB

Observação

Na IU do MongoDB Atlas, acesse a página Clusters do seu projeto.

Navegue até a coleção.

Especifique um documento de filtro de consulta.

Excluir um documento.

Excluir comportamento

Indexes

Atomicidade

Escrever confirmação

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também: