Exclua documentos

Nesta página

Excluir todos os documentos

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

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

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

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

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

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

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

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

Esta página usa 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:

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

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 o seguinte driver Java Reactive Streams métodos:

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

Esta página 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 a seguinte Motor métodos do 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 o seguinte driver MongoDB Node.js métodos:

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

Esta página usa o seguinte driver MongoDB Perl métodos:

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

Esta página usa os seguintes métodos 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 o seguinte PyMongo Métodos do driver Python:

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 do driver Ruby 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 o seguinte driver MongoDB Scala métodos:

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

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 a inserção de documentos no MongoDB Compass, consulte a documentação do Compass.

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

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

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

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

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

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

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

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

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

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

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

Excluir todos os documentos

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

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

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

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

Para excluir todos os documentos de uma collection, passe um documento com filtro vazio para o método Collection.DeleteMany função.

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

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

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

Para excluir todos os documentos de uma coleção, passe um 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 documento filtro vazio {} para o motor.motor_asyncio.AsyncIOMotorCollection.delete_many método.

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

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

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

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

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

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

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

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

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

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

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

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

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

db.inventory.deleteMany({})

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

await db.inventory.delete_many({})

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

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

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

db.inventory.delete_many({})

client[:inventory].delete_many({})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

Um documento de filtro de consulta 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 query para especificar condições de filtro. Use o Construtor de definições de filtro métodos para criar um documento de filtro. Por exemplo:

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

Além da condição de igualdade, o MongoDB fornece vários operadores de query para especificar condições de filtro. Use o com.mongodb.client.model.Filters métodos auxiliares 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>))

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 do 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 de filtro para com.mongodb.reactivestreams.client.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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 com.mongodb.client.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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 delete_many filtro para 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 delete_many() 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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 delete_many filtro para 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Para excluir todos os documentos que correspondam a um critério de exclusão, passe um parâmetro de filtro para o método 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 consulta:

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

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

{ <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 método com.mongodb.client.model.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 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, utilize expressões <field>:<value> no documento do filtro de consulta:

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

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

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

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

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

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

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

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

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

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

{ <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 consulta pode usar os operadores de consulta para especificar condições no seguinte formato:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Um documento de filtro de consulta 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" })

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Excluir apenas um documento que corresponda a uma condição

Para excluir no máximo um único documento que corresponda a um filtro especificado (mesmo que vários documentos possam corresponder ao filtro especificado), use o método db.collection.deleteOne().

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

O MongoDB Compass fornece uma maneira simples de excluir um documento de uma coleção. O exemplo a seguir mostra como excluir o documento com item igual a paper da collection inventory :

Observação

Neste exemplo, estamos usando a exibição de tabela do Compass para excluir o documento. O processo de exclusão usando a exibição de lista do Compass segue uma abordagem muito semelhante.

Para obter mais informações sobre as diferenças entre a Exibição de Tabela e a Exibição de Lista no Compass, consulte a documentação do Compass.

Para excluir 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() método.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use 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 com.mongodb.reactivestreams.client.MongoCollection.deleteMany método.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o com.mongodb.client.MongoCollection.deleteOne método.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método motor.motor_asyncio.AsyncIOMotorCollection.delete_one.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use Collection.deleteOne() método.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use MongoDB::Collection::delete_one() método.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (mesmo que vários documentos possam corresponder ao filtro especificado), use o método MongoDB\\Collection::deleteOne().

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora vários documentos possam corresponder ao filtro especificado), use o método pymongo.collection.Collection.delete_one.

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

Para excluir no máximo um único documento que corresponda a um filtro especificado (embora 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 collection.deleteOne() método.

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

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

Clique no botão Table na navegação superior para acessar a Visualização em tabela:
Use a barra de query do Compass para localizar o documento de destino.
Copie o seguinte documento de filtro na barra de query e clique em Find:
```
{ item: "paper" }
```
Passe o mouse sobre o documento e clique no ícone de lixeira que aparece no lado direito:
Após clicar no botão excluir, o documento é sinalizado para exclusão e o Compass solicita a confirmação de que você deseja remover o documento:
Clique em Delete para confirmar. O Compass exclui o documento da collection.

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

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

Publisher<DeleteResult> deleteOnePublisher = collection.deleteOne(eq("status", "D"));

collection.deleteOne(eq("status", "D"));

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

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

$db->coll("inventory")->delete_one( { status => "D" } );

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

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

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

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

Excluir um documento com Atlas MongoDB

Observação

Você pode excluir somente um documento de cada vez na IU do Atlas MongoDB. Para excluir vários documentos, conecte-se à sua implantação do Atlas a partir de mongosh ou de um driver do MongoDB e siga os exemplos nesta página para o método de sua preferência.

O exemplo nesta seção utiliza o conjunto de dados de filmes de amostra. Para saber como carregar o conjunto de dados de amostra em sua implantação do MongoDB Atlas, consulte Carregar Dados de Amostra.

Para excluir um documento no MongoDB Atlas, siga estas etapas:

Na interface do usuário do Atlas MongoDB, vá para a Clusters página para seu projeto.

Se ainda não estiver exibido, selecione a organização que contém o projeto desejado no menu Organizations na barra de navegação.
Se ainda não estiver exibido, selecione seu projeto no menu Projects na barra de navegação.
Se a página Clusters ainda não estiver exibida, clique em Database na barra lateral.
A página Clusters é exibida.

Navegue até a coleção.

Para o cluster que contém os dados de amostra, clique em Browse Collections.
No painel de navegação esquerdo, selecione o banco de dados sample_mflix.
Selecione a collection movies.

Especifique um documento de filtro de consulta.

Opcionalmente, você pode especificar um documento de filtro de query no campo Filter. Um documento de filtro de query usa operadores de query para especificar as condições de pesquisa.

Copie o seguinte documento de filtro de query na barra de pesquisa do Filter e clique em Apply:

{ genres: "Action", rated: { $in: [ "PG", "PG-13" ] } }

Este filtro de consulta 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

Índices

As operações de exclusão não eliminam índices, mesmo excluindo todos os documentos de uma coleção.

Atomicidade

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

Escrever confirmação

Com write concern, você pode especificar o nível de confirmação solicitado do MongoDB para operações de write. Para obter detalhes, consulte Preocupação de gravação.

Exclua documentos.leafygreen-ui-m0pgrr{-webkit-align-self:center;-ms-flex-item-align:center;align-self:center;padding:0 10px;visibility:hidden;}.leafygreen-ui-a30zj9{color:#889397;vertical-align:middle;margin-top:-2px;}.css-1l4s55v{margin-top:-175px;position:absolute;padding-bottom:2px;}

Observação

Excluir todos os documentos

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

Excluir apenas um documento que corresponda a uma condição

Observação

Excluir um documento com Atlas MongoDB

Observação

Na interface do usuário do Atlas MongoDB, vá para a Clusters página para seu projeto.

Navegue até a coleção.

Especifique um documento de filtro de consulta.

Excluir um documento.

Excluir comportamento

Índices

Atomicidade

Escrever confirmação

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Dica

Veja também:

Exclua documentos