Exclua documentos

No MongoDB, uma operação de excluir consiste em excluir documentos de uma coleção. Esta página fornece exemplos.

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

O driver da sua linguagem de programação.
The MongoDB Atlas UI. To learn more, see Query for Null or Missing Fields with MongoDB Atlas.
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.

This page uses the following mongosh methods:

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 os seguintes métodos do driver MongoDB C:

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:

This page uses the following MongoDB .NET/C# Driver methods:

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

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

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

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

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

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

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

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

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

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

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 coleção, clique no botão DELETE na aba Documents.

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

Para excluir todos os documentos de uma collection, passe o mongoc_collection_t e um bson_t que corresponda a todos os documentos para o método mongoc_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 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 objeto Bson vazio como filtro para o MongoCollection.deleteMany() método.

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

To delete all documents from a collection, pass an empty filter document {} to the motor.motor_asyncio.AsyncIOMotorCollection.delete_many method.

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

To delete all documents from a collection, pass an empty filter document {} to the Collection.deleteMany() method.

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

To delete all documents from a collection, pass an empty filter document [] to the MongoDB\\Collection::deleteMany() method.

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

To delete all documents from a collection, pass an empty filter document {} to the pymongo.collection.Collection.delete_many method.

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

MongoDB Compass mostrando a aba Documentos com o botão Excluir destacado.

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

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

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

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

collection.deleteMany(new Document());

collection.deleteMany(empty())

await db.inventory.delete_many({})

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

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

db.inventory.delete_many({})

client[:inventory].delete_many({})

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

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

Quando você confirma a exclusão na janela pop-up que aparece quando você clica em DELETE, o MongoDB Compass exclui todos os documentos e exibe uma mensagem indicando quantos documentos foram excluídos.

The mongoc_collection_delete_many method returns true if successful, or returns false and sets an error if there are invalid arguments or a server or network error occurs.

Upon successful execution, the IMongoCollection.DeleteMany() method returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

Upon successful execution, the Collection.DeleteMany function returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

com.mongodb.reactivestreams.client.MongoCollection.deleteMany returns a Publisher object of type com.mongodb.client.result.DeleteResult if successful. Returns an instance of com.mongodb.MongoException if unsuccessful.

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 método MongoCollection.deleteMany() retorna uma instância de com.mongodb.client.result.DeleteResult que descreve o status da operação e a contagem de documentos excluídos.

The delete_many coroutine asynchronously returns an instance of pymongo.results.DeleteResult with the status of the operation.

Collection.deleteMany() returns a promise that provides a result. The result.deletedCount property contains the number of documents that matched the filter.

Upon successful execution, the deleteMany() method returns an instance of MongoDB\\DeleteResult whose getDeletedCount() method returns the number of documents that matched the filter.

The delete_many method returns an instance of pymongo.results.DeleteResult with the status of the operation.

Upon successful execution, the delete_many() method returns an instance of Mongo::Operation::Result, whose deleted_count attribute contains the number of documents that matched the filter.

Upon successful execution, the collection.deleteMany() method returns an Observable with a single element with a DeleteResult type parameter or with an 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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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 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 do filtro de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use o pacote BSON para criar operadores de query para documentos de filtro. Por exemplo:

filter := bson.D{
    {"$and", bson.A{
        bson.D{{"field1", bson.D{{"$eq", value1}}}},
        bson.D{{"field2", bson.D{{"$lt", 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> }, ... }

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, grave seu filtro de queries na barra de query do Compass e clique no botão DELETE na aba Documents. O exemplo a seguir exclui todos os documentos em que { status: "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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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 o mongoc_collection_t e um bson_t que corresponda aos documentos que você deseja excluir para o método mongoc_collection_delete_many.

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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

To delete all documents that match a deletion criteria, pass a filter parameter to the delete_many method.

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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

To delete all documents that match a deletion criteria, pass a filter parameter to the deleteMany() method.

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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

To delete all documents that match a deletion criteria, pass a filter parameter to the deleteMany() method.

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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

To delete all documents that match a deletion criteria, pass a filter parameter to the delete_many method.

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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, use o tipo bson.D para criar um documento de filtro:

filter := bson.D{{"<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 queries:

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

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

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

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

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

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

Aba Documentos do MongoDB Compass com o botão EXCLUIR destacado.

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

var filter = Builders<BsonDocument>.Filter.Eq("status", "A");
var result = collection.DeleteMany(filter);

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

deleteManyPublisher = collection.deleteMany(eq("status", "A"));

collection.deleteMany(eq("status", "A"));

collection.deleteMany(eq("status", "A"));

await db.inventory.delete_many({"status": "A"})

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

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

db.inventory.delete_many({"status": "A"})

client[:inventory].delete_many(status: 'A')

collection.deleteMany(equal("status", "A")).execute()

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

The mongoc_collection_delete_many method returns true if successful, or returns false and sets an error if there are invalid arguments or a server or network error occurs.

Upon successful execution, the IMongoCollection.DeleteMany() method returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

Upon successful execution, the Collection.DeleteMany function returns an instance of DeleteResult whose DeletedCount property contains the number of documents that matched the filter.

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 método MongoCollection.deleteMany() retorna uma instância de com.mongodb.client.result.DeleteResult que descreve o status da operação e a contagem de documentos excluídos.

The delete_many coroutine asynchronously returns an instance of pymongo.results.DeleteResult with the status of the operation.

Collection.deleteMany() returns a promise that provides a result. The result.deletedCount property contains the number of documents that matched the filter.

Upon successful execution, the deleteMany() method returns an instance of MongoDB\\DeleteResult whose getDeletedCount() method returns the number of documents that matched the filter.

The delete_many method returns an instance of pymongo.results.DeleteResult with the status of the operation.

Upon successful execution, the delete_many() method returns an instance of Mongo::Operation::Result, whose deleted_count attribute contains the number of documents that matched the filter.

Upon successful execution, the collection.deleteMany() method returns an Observable with a single element with a DeleteResult type parameter or with an 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":

Para excluir um único documento que corresponda a um filtro especificado:

Gravar seu filtro de queries na barra de queries do Compass e clique em Find.
Passe o mouse sobre o documento que deseja excluir.
Clique no botão no lado direito do documento.

O exemplo a seguir exclui um documento com { status: "A" } da coleção inventory:

Para excluir um único documento de uma coleção, passe o mongoc_collection_t e um bson_t que corresponda ao documento que você deseja excluir para o método mongoc_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 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.

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the motor.motor_asyncio.AsyncIOMotorCollection.delete_one method.

O exemplo a seguir exclui o primeiro documento em que status é "D":

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the Collection.deleteOne() method.

O exemplo a seguir exclui o primeiro documento em que status é "D":

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the MongoDB\\Collection::deleteOne() method.

O exemplo a seguir exclui o primeiro documento em que status é "D":

To delete at most a single document that matches a specified filter (even though multiple documents may match the specified filter) use the pymongo.collection.Collection.delete_one method.

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

MongoDB Compass Excluir um documento que corresponda a um filtro

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

Limpe 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"));

O exemplo a seguir exclui o primeiro documento em que status é "D":

await db.inventory.delete_one({"status": "D"})

await db.collection('inventory').deleteOne({ status: 'D' });

$deleteResult = $db->inventory->deleteOne(['status' => 'D']);

db.inventory.delete_one({"status": "D"})

client[:inventory].delete_one(status: 'D')

collection.deleteOne(equal("status", "D")).execute()

Excluir um documento com Atlas MongoDB

Observação

You can delete only one document at a time in the MongoDB Atlas UI. To delete multiple documents, connect to your Atlas deployment from mongosh or a MongoDB driver and follow the examples on this page for your preferred method.

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 Carregar 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.
Na barra lateral, clique em Clusters sob o título Database.
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.

Observação

Atomicidade e confirmação de gravar

As operações de gravação do MongoDB são atômicas no nível de um único documento. Para mais informações, consulte Atomicidade e transações.

Você também pode usar write concerns para especificar o nível de confirmação solicitado do MongoDB para operações de gravação. Para obter mais informações, consulte write concern.

Dica

Voltar

Diagramas de ciclo de vida

SQL para MongoDB

Exclua documentos

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

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

Receber um selo de habilidade