Menu Docs

Página inicial do Docs

/

Manual do MongoDB

/

Operações CRUD

/

Consulta para campos nulos ou ausentes

Nesta página

Filtro de equalização

Filtro de não igualdade
Verificação de Tipo
Verificação de existência
Query de campos null ou ausentes com o MongoDB Atlas

Você pode fazer query de null ou campos ausentes no MongoDB usando os seguintes métodos:

O driver da sua linguagem de programação.
O MongoDB Atlas UI. Para saber mais, consulte Fazer query de campos nulos ou ausentes com o 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.

Diversos operadores de query no MongoDB tratam valores null de forma diferente.

Esta página fornece exemplos de operações de query que buscam valores null usando o método db.collection.find() em mongosh.

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 fornece exemplos de operações de consulta para valores null usando MongoDB Compass.

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 fornece exemplos de operações que solicitam null valores usando mongoc_collection_find_with_opts. .. include:: /includes/driver-examples/examples-intro.rst

Esta página fornece exemplos de operações com queries de valores null usando o método MongoCollection.Find() no Driver C# do MongoDB.

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

Esta página fornece exemplos de operações que consultam valores de null usando a função Collection.Find no 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 fornece exemplos de operações de query que buscam null valores usando o com.mongodb.reactivestreams. cliente.MongoCollection.find no MongoDB Java Reactive Streams 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 fornece exemplos de operações de consulta que buscam valores de null utilizando o método com.mongodb.client.MongoCollection.find no Java Synchronous Driver do MongoDB.

Dica

O driver fornece os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Os exemplos nesta página usam esses métodos para criar os documentos de filtro.

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 fornece exemplos de operações que solicitam null valores usando o método MongoCollection.find() no MongoDB Kotlin Coroutine Driver.

Dica

O driver fornece os métodos auxiliares com.mongodb.client.model.Filters para facilitar a criação de documentos de filtro. Os exemplos nesta página usam esses métodos para criar os documentos de filtro.

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 fornece exemplos de operações que consultam valores de null usando o método motor.motor_asyncio.AsyncIOMotorCollection.find no 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 fornece exemplos de operações que solicitam valores null usando o método Collection.find() no MongoDB Node.js 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 fornece exemplos de operações de query que buscam valores null usando o método MongoDB\\Collection::find() na 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 fornece exemplos de operações que consultam valores de null usando o método pymongo.collection.Collection.find no driver PyMongo 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 fornece exemplos de operações de consulta que buscam valores de null utilizando o método Mongo::Collection#find() no MongoDB Ruby 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 fornece exemplos de operações que solicitam null valores usando o método collection.find() no MongoDB Scala 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:

Importante

Use BCON_NULL com o driver MongoDB C para solicitar null ou campos ausentes no MongoDB.

Importante

Use BsonNull.Value com o driver C# do MongoDB para solicitar null ou campos ausentes no MongoDB.

Importante

Use nil com o driver Go do MongoDB para consultar null ou campos ausentes no MongoDB.

Importante

Use null com o driver Kotlin Coroutine para fazer query de null ou campos ausentes no MongoDB.

Importante

Use None com o driver Motor para solicitar null ou campos ausentes no MongoDB.

Importante

Use None com o driver PyMongo Python para consultar null ou campos ausentes no MongoDB.

Importante

Use nil com o driver Ruby do MongoDB para solicitar null ou campos ausentes no MongoDB.

Importante

Use BsonNull() com o driver MongoDB Scala para solicitar null ou campos ausentes no MongoDB.

db.inventory.insertMany([
   { _id: 1, item: null },
   { _id: 2 }
])

[
   { "_id": 1, "item": null },
   { "_id": 2 }
]

Para obter instruções sobre como inserir documentos no MongoDB Compass, consulte Insira documentos.

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 (
   "_id", BCON_INT64 (1),
   "item", BCON_NULL);
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 ("_id", BCON_INT64 (2));
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 { { "_id", 1 }, { "item", BsonNull.Value } },
    new BsonDocument { { "_id", 2 } }
};
collection.InsertMany(documents);

docs := []interface{}{
	bson.D{
		{"_id", 1},
		{"item", nil},
	},
	bson.D{
		{"_id", 2},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)

Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{'_id': 1, 'item': null}"),
        Document.parse("{'_id': 2}")
));

collection.insertMany(asList(
        Document.parse("{'_id': 1, 'item': null}"),
        Document.parse("{'_id': 2}")
));

collection.insertMany(
    listOf(
        Document("_id", 1)
            .append("item", null),
        Document("_id", 2)
    )
)

await db.inventory.insert_many([{"_id": 1, "item": None}, {"_id": 2}])

await db.collection('inventory').insertMany([{ _id: 1, item: null }, { _id: 2 }]);

$insertManyResult = $db->inventory->insertMany([
    ['_id' => 1, 'item' => null],
    ['_id' => 2],
]);

db.inventory.insert_many([{"_id": 1, "item": None}, {"_id": 2}])

client[:inventory].insert_many([{ _id: 1, item: nil },
                                { _id: 2 }])

collection.insertMany(Seq(
  Document("""{"_id": 1, "item": null}"""),
  Document("""{"_id": 2}""")
)).execute()

Filtro de equalização

A query { item : null } encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query { item : null } encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query { item, BCON_NULL } encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A Eq("item", BsonNull.Value) query do utilizando o FilterDefinitionBuilder.Eq() método corresponde a documentos que contêm o item campo cujo valor é null ou que não contêm o item campo .

A query item => nil encontra documentos que contêm o campo item cujo valor é nil ou que não contêm o campo item.

A query eq("item", null) encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query eq("item", null) encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query eq("item", null) encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query { item : None } encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query { item : null } encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query [ item => undef ] encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query { item : None } encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

A query { item => nil } encontra documentos que contêm o campo item cujo valor é nil ou que não contêm o campo item.

A query equal("item", BsonNull) encontra documentos que contêm o campo item cujo valor é null ou que não contêm o campo item.

db.inventory.find( { item: null } )

Copie o seguinte documento de filtro de query na barra de query e clique em Find:

{ item: null }

Valor nulo da query ou campo ausente

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("item", BCON_NULL);
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("item", BsonNull.Value);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"item", nil},
	})

FindPublisher<Document> findPublisher = collection.find(eq("item", null));

FindIterable<Document> findIterable = collection.find(eq("item", null));

val findFlow = collection
    .find(eq("item", null))

cursor = db.inventory.find({"item": None})

const cursor = db.collection('inventory').find({
  item: null
});

$cursor = $db->inventory->find(['item' => null]);

cursor = db.inventory.find({"item": None})

client[:inventory].find(item: nil)

var findObservable = collection.find(equal("item", BsonNull()))

A query retorna ambos os documentos na coleção.

Filtro de não igualdade

Para query campo que existem e não são nulos, use o filtro { $ne : null } . A query { item : { $ne : null } } corresponde a documentos onde o campo item existe e tem um valor não nulo.

db.inventory.find( { item: { $ne : null } } )

{ item: { $ne : null } }

filter = BCON_NEW ("item", BCON_NULL);
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Ne("item", BsonNull.Value);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
  context.TODO(),
  bson.D{
    {"item", bson.D{"$ne": nil}},
  })

db.inventory.find( { item: { $ne : null} } )

collection.find(ne("item", null));

collection.find(ne("item", null))

cursor = db.inventory.find( { "item": { "$ne": None } } )

const cursor = db.collection('inventory')
  .find({ item: { $ne : null }
});

$cursor = $db->inventory->find(['item' => ['$ne' => null ]]);

cursor = db.inventory.find( { "item": { "$ne": None } } )

client[:inventory].find(item: { '$ne' => nil })

collection.find($ne("item", null));

Verificação de Tipo

A query do { item : { $type: 10 } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do { item : { $type: 10 } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do { item, { $type, BCON_NULL } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query Type("item", BsonType.Null) utilizando o método FilterDefinitionBuilder.Type() corresponde a apenas documentos que contêm o campo item cujo valor é null. O valor do campo item é do tipo BSON Null (tipo BSON 10):

A query a seguir corresponde a apenas documentos que contêm o campo item cujo valor é de Tipos de BSON Null (Tipo de BSON 10):

A query do type("item", BsonType.NULL) corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do type("item", BsonType.NULL) corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do type("item", BsonType.NULL) corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10 :

A query type("item", BsonType.NULL) corresponde apenas a documentos que contêm o campo item cujo valor é null. Isso significa que o valor do item campo é de de BSON JSON Null (BSON Tipo 10 de):

A query do { item : { $type: 10 } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do { item : { $type: 10 } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do [ item => [ $type => 10 ] ] corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do { item : { $type: 10 } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

A query do { item => { $type => 10 } } corresponde a apenas documentos que contêm o campo item cujo valor é null; isto é, o valor do campo item é de Tipos de BSON Null (Tipo de BSON 10):

db.inventory.find( { item : { $type: 10 } } )

Copie o seguinte documento de filtro de consulta na barra de consulta e clique em Find:

{ item : { $type: 10 } }

Encontrar tipo nulo

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "item", "{",
   "$type", BCON_INT64 (10),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Type("item", BsonType.Null);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"item", bson.D{
			{"$type", 10},
		}},
	})

findPublisher = collection.find(type("item", BsonType.NULL));

findIterable = collection.find(type("item", BsonType.NULL));

val findFlow = collection
    .find(type("item", BsonType.NULL))

cursor = db.inventory.find({"item": {"$type": 10}})

const cursor = db.collection('inventory').find({
  item: { $type: 10 }
});

$cursor = $db->inventory->find(['item' => ['$type' => 10]]);

cursor = db.inventory.find({"item": {"$type": 10}})

client[:inventory].find(item: { '$type' => 10 })

findObservable = collection.find(bsonType("item", BsonType.NULL))

A query retorna somente o documento onde o campo item tem um valor de null.

Verificação de existência

As seguintes queries de exemplo para documentos que não contêm um campo. [1]

A query { item : { $exists: false } } corresponde a documentos que não contêm o campo item:

A query { item : { $exists: false } } corresponde a documentos que não contêm o campo item:

A query { item, { $exists, BCON_BOOL (false) } } corresponde a documentos que não contêm o campo item:

A query Exists("item", false) utilizando o método FilterDefinitionBuilder.Exists() corresponde a documentos que não contêm o campo item:

A query exists("item", false) corresponde a documentos que não contêm o campo item:

A query exists("item", false) corresponde a documentos que não contêm o campo item:

A query exists("item", false) corresponde a documentos que não contêm o campo item:

A query { item : { $exists: False } } corresponde a documentos que não contêm o campo item:

A query { item : { $exists: false } } corresponde a documentos que não contêm o campo item:

A query [ item => [ $exists => false ] ] corresponde a documentos que não contêm o campo item:

A query { item : { $exists: False } } corresponde a documentos que não contêm o campo item:

A query { item => { $exists => false } } corresponde a documentos que não contêm o campo item:

A query exists("item", exists = false) corresponde a documentos que não contêm o campo item:

db.inventory.find( { item : { $exists: false } } )

Copie o seguinte documento de filtro de consulta na barra de consulta e clique em Find:

{ item : { $exists: false } }

Query para valor nulo

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "item", "{",
   "$exists", BCON_BOOL (false),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

Certifique-se também de limpar quaisquer recursos abertos ligando para os seguintes métodos, conforme apropriado:

var filter = Builders<BsonDocument>.Filter.Exists("item", false);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"item", bson.D{
			{"$exists", false},
		}},
	})

findPublisher = collection.find(exists("item", false));

findIterable = collection.find(exists("item", false));

val findFlow = collection
    .find(exists("item", false))

cursor = db.inventory.find({"item": {"$exists": False}})

const cursor = db.collection('inventory').find({
  item: { $exists: false }
});

$cursor = $db->inventory->find(['item' => ['$exists' => false]]);

cursor = db.inventory.find({"item": {"$exists": False}})

client[:inventory].find(item: { '$exists' => false })

findObservable = collection.find(exists("item", exists = false))

A query retorna somente o documento que não contém o campo item.

Dica

Veja também:

Documentação de referência para os operadores $type e $exists.

[1]	Os usuários não podem mais utilizar a query `$type: 0` como sinônimo de `$exists:false`. Para fazer query de campos nulos ou ausentes, consulte Fazer query de campos nulos ou ausentes.

Query de campos null ou ausentes com o MongoDB Atlas

O exemplo nesta seção utiliza o conjunto de dados de treinamento 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 executar query de um null ou um campo ausente no MongoDB Atlas, siga estas etapas:

1

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

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.

2

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_training.
Selecione a collection companies.

3

Insira um documento em branco.

Clique no botão Insert Document para exibir a caixa de diálogo e, em seguida, em Insert para inserir um documento com o campo _id apenas.

4

Especifique um documento de filtro de consulta.

Para encontrar um documento que contenha um valor null ou ausente, especifique um query filter document no campo Filter. Um documento de filtro de query usa operadores de query para especificar as condições de pesquisa.

Diversos operadores de query no MongoDB tratam valores null de forma diferente. Para aplicar um filtro de query, copie cada um dos seguintes documentos na barra de pesquisa Filter e clique em Apply.

Utilize o seguinte filtro de query para combinar documentos que contêm um campo description com um valor null ou que não contêm o campo description:

{ description : null }

Utilize o seguinte filtro de query para corresponder apenas a documentos que contêm um campo description com um valor null. Esse filtro especifica que o valor do campo deve ser Tipo de BSON Null (Tipo de BSON 10):

{ description : { $type: 10 } }

Use o seguinte filtro de query para corresponder somente a documentos que não contêm o campo description. Somente o documento inserido anteriormente deve ser exibido:

{ description : { $exists: false } }

Voltar

Resultados do projeto

Próximo

Tempo limite

Selecione a linguagem

Nesta página

Filtro de equalização
Filtro de não igualdade
Verificação de Tipo
Verificação de existência
Query de campos null ou ausentes com o MongoDB Atlas