Docs Menu

/ /

/

Manual de base de datos

/

Operaciones CRUD

/

/

Manual de base de datos

/

Operaciones CRUD

/

Query de campos nulos o faltantes

Esta versión de la documentación está archivada y ya no recibe soporte. Para actualizar su implementación 6.0, consulte Procedimientos de actualización de MongoDB.7.0

Puedes realizar consultas por null o campos faltantes en MongoDB utilizando los siguientes métodos:

El driver de su lenguaje de programación.
La interfaz de usuario de MongoDB Atlas. Para obtener más información, consulta Realizar query para campos nulos o faltantes con MongoDB Atlas.
MongoDB Compass.

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

Los diferentes operadores del query en MongoDB tratan los valores null de manera diferente.

Esta página proporciona ejemplos de operaciones que consultan valores null utilizando el db.collection.find() Método mongosh en.

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

En esta página, se proporcionan ejemplos de operaciones que realizan queries de valores null con MongoDB Compass.

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

Esta página proporciona ejemplos de operaciones que consultan null valores utilizando MongoCollection.Find()método en el controlador C# de MongoDB.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando la función Collection.Find en el controlador Go de MongoDB.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando el método com.mongodb.reactivestreams.client.MongoCollection.find en el controlador Java Reactive Streams de MongoDB.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando el método com.mongodb.client.MongoCollection.find en el controlador síncrono de Java de MongoDB.

Tip

El driver ofrece métodos asistentes com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Los ejemplos en esta página utilizan estos métodos para crear los documentos de filtro.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando el método motor.motor_asyncio.AsyncIOMotorCollection.find en el controlador Motor.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando el método colección.find() en el Node.js Driver de MongoDB.

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

Esta página proporciona ejemplos de operaciones que consultan valores de null utilizando el método MongoDB\\Collection::find() en la MongoDB PHP Library.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando el método pymongo.collection.Collection.find en el controlador de Python PyMongo.

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

Esta página proporciona ejemplos de operaciones que consultan valores null utilizando el método Mongo::Collection#find() en el MongoDB Ruby Driver.

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

Esta página ofrece ejemplos de operaciones de query en valores null utilizando el método collection.find() en el controlador Scala de MongoDB.

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

Importante

Utiliza BsonNull.Value con el driver C# de MongoDB para realizar un query por null o campos faltantes en MongoDB.

Importante

Utiliza nil con el controlador MongoDB Go para query null o campos faltantes en MongoDB.

Importante

Utilice None con el controlador Motor para query null o campos faltantes en MongoDB.

Importante

Utiliza None con el driver Python PyMongo para realizar un query por null o campos faltantes en MongoDB.

Importante

Utiliza nil con el controlador Ruby de MongoDB para realizar un query de null o campos faltantes en MongoDB.

Importante

Utilizar BsonNull() con el controlador de MongoDB Scala para realizar un query para null o campos faltantes en MongoDB.

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

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

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

var documents = new[]
{
    new BsonDocument { { "_id", 1 }, { "item", BsonNull.Value } },
    new BsonDocument { { "_id", 2 } }
};
collection.InsertMany(documents);

docs := []any{
	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}")
));

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 igualdad

La query { item : null } coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query { item : null } coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query Eq("item", BsonNull.Value) usando el método FilterDefinitionBuilder.Eq() coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query item => nil coincide con documentos que contienen el campo item cuyo valor es nil o que no contienen el campo item.

La query eq("item", null) coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query eq("item", null) coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query { item : None } coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query { item : null } coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query [ item => undef ] coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query { item : None } coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

La query { item => nil } coincide con documentos que contienen el campo item cuyo valor es nil o que no contienen el campo item.

La query equal("item", BsonNull) coincide con documentos que contienen el campo item cuyo valor es null o que no contienen el campo item.

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

Copie el siguiente documento de filtro de consulta en la barra de consulta y haga clic Find:

{ item: null }

Query valor nulo o campo ausente

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

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

El query devuelve ambos documentos de la colección.

Filtro de desigualdad

Para realizar las queries de campos que existen y no son nulas, utiliza el filtro { $ne : null }. La query { item : { $ne : null } } coincide con documentos en los que el campo item existe y tiene un valor no nulo.

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

{ item: { $ne : 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 : nul l} } )

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

Verificación de tipo

La { item : { $type: 10 } } consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La { item : { $type: 10 } } consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La Type("item", BsonType.Null) consulta que utiliza el método FilterDefinitionBuilder.Type() coincide únicamente con los documentos que contienen el item campo cuyo valor es;null es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La siguiente consulta coincide únicamente con documentos que contienen el item campo cuyo valor es de tipo BSON Null (número de 10 tipo):

La type("item", BsonType.NULL) consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La type("item", BsonType.NULL) consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La type("item", BsonType.NULL) consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La { item : { $type: 10 } } consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La { item : { $type: 10 } } consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La [ item => [ $type => 10 ] ] consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La { item : { $type: 10 } } consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

La { item => { $type => 10 } } consulta coincide únicamente con los documentos que contienen el item campo cuyo valor null es; es decir, el valor del item campo es del tipo BSON Null (número de 10 tipo):

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

Copia el siguiente documento de filtro de query en la barra de query y haz clic en Find:

{ item : { $type: 10 } }

Buscar tipo nulo

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

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

El query devuelve solo el documento donde el campo item tiene un valor de null.

Comprobación de existencia

El siguiente ejemplo query documentos que no contienen un campo. [1]

El query { item : { $exists: false } } coincide con documentos que no contienen el campo item:

El query { item : { $exists: false } } coincide con documentos que no contienen el campo item:

La query Exists("item", false) usando el método FilterDefinitionBuilder.Exists() coincide con documentos que no contienen el campo item:

El query exists("item", false) coincide con documentos que no contienen el campo item:

El query exists("item", false) coincide con documentos que no contienen el campo item:

El query { item : { $exists: False } } coincide con documentos que no contienen el campo item:

El query { item : { $exists: false } } coincide con documentos que no contienen el campo item:

El query [ item => [ $exists => false ] ] coincide con documentos que no contienen el campo item:

El query { item : { $exists: False } } coincide con documentos que no contienen el campo item:

El query { item => { $exists => false } } coincide con documentos que no contienen el campo item:

El query exists("item", exists = false) coincide con documentos que no contienen el campo item:

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

Copia el siguiente documento de filtro de query en la barra de query y haz clic en Find:

{ item : { $exists: false } }

Query para valor nulo

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

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

El query solo devuelve el documento que no contiene el campo item.

Tip

Documentación de referencia para los operadores $type y $exists.

[1]	Los usuarios ya no pueden utilizar el filtro de query `$type: 0` como sinónimo de `$exists:false`. Para consultar campos nulos o faltantes, lee Consultar campos nulos o faltantes.

Consulta los campos nulos o faltantes con MongoDB Atlas

El ejemplo en esta sección utiliza el conjunto de datos de entrenamiento de muestra. Para aprender a cargar el conjunto de datos de muestra en la implementación de MongoDB Atlas, se debe consultar Cargar datos de muestra.

Para consultar un null o un campo faltante en MongoDB Atlas, sigue estos pasos:

1

En la interfaz de usuario de MongoDB Atlas, vaya a la Clusters página de su proyecto.

Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Clusters en la sección Database.
La página de clústeres se muestra.

2

Navega a la colección.

Para el clúster que contiene los datos de muestra, haz clic en Browse Collections.
En el panel de navegación izquierdo, seleccione la base de datos sample_training.
Seleccione la colección companies.

3

Inserte un documento en blanco.

Hacer clic en el botón Insert Document para mostrar el cuadro de diálogo y luego hacer clic en Insert para insertar un documento con solo el campo _id.

4

Especifica un documento de filtro de query.

Para encontrar un documento que contenga un null o un valor faltante, especificar un documento de filtro de query en el campo Filter. Un documento de filtro de query utiliza operadores del query para especificar las condiciones de búsqueda.

Los diferentes operadores del query en MongoDB tratan los valores null de manera diferente. Para aplicar un filtro de query, copie cada uno de los siguientes documentos en la barra de búsqueda Filter y haga clic en Apply.

Utilizar el siguiente filtro de query para hacer coincidir documentos que contengan un campo description con un valor null o que no contengan el campo description:

{ description : null }

Utiliza el siguiente filtro de query para hacer coincidir solo los documentos que contengan un campo description con un valor null. Este filtro especifica que el valor del campo debe ser del Tipo BSON Null (Tipo BSON 10):

{ description : { $type: 10 } }

Utiliza el siguiente filtro de query para que coincida solo con documentos que no contienen el campo description. Solo debe aparecer el documento que has insertado anteriormente:

{ description : { $exists: false } }

Volver

Resultados del Proyecto

Next

Instantáneas de larga duración

Seleccionar el lenguaje

Califique esta página

En esta página

Filtro de igualdad

Filtro de desigualdad
Verificación de tipo
Comprobación de existencia
Consulta los campos nulos o faltantes con MongoDB Atlas

En esta página

Filtro de igualdad
Filtro de desigualdad
Verificación de tipo
Comprobación de existencia
Consulta los campos nulos o faltantes con MongoDB Atlas