Docs Menu

/ /

/

/

Operaciones CRUD

/

/

/

Operaciones CRUD

/

Query de campos nulos o faltantes

Consulta para null o campos faltantes en MongoDB utilizando los siguientes métodos:

El driver de su lenguaje de programación.
El Interfaz de usuario de MongoDB Atlas. Para obtener más información, consulte Consulta de 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 operadores de consulta 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 mongoc_collection_find_with_opts.

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 MongoCollection.Find() en el MongoDB C# 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 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 proporciona ejemplos de operaciones que realizan un query de valores null utilizando el método MongoCollection.find() en el controlador de corrutina de Kotlin para 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

Utilizar null con el MongoDB Shell para consultar null o campos faltantes en MongoDB.

Importante

Utiliza null con MongoDB Compass para realizar un query sobre null o campos faltantes en MongoDB.

Importante

Utilizar BCON_NULL con el controlador C de MongoDB para crear un query para null o campos faltantes en MongoDB.

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

Utiliza null con el controlador de Java Reactive Streams para realizar un query por null o campos faltantes en MongoDB.

Importante

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

Importante

Utiliza null con el controlador de corrutina de Kotlin para query null o campos faltantes en MongoDB.

Importante

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

Importante

Utilizar null con el controlador de Node.js para consultar null o campos que faltan en MongoDB.

Importante

Utilizar null con el controlador PHP de MongoDB para ejecutar los query de 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.

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

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 igualdad

La { item : null } consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La { item : null } consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La { item, BCON_NULL } consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La Eq("item", BsonNull.Value) consulta que utiliza el método FilterDefinitionBuilder.Eq() coincide con los documentos que contienen el item campo con un null valor o que no contienen el item campo.

La item => nil consulta coincide con los documentos que contienen el item campo con un nil valor o no contienen el item campo.

La eq("item", null) consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La eq("item", null) consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La eq("item", null) consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La { item : None } consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La { item : null } consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La [ item => undef ] consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La { item : None } consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

La { item => nil } consulta coincide con los documentos que contienen el item campo con un nil valor o no contienen el item campo.

La equal("item", BsonNull) consulta coincide con los documentos que contienen el item campo con un null valor o no contienen el item campo.

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

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

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

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 : nul l} } )

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

Verificación de tipo

La { item : { $type: 10 } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La { item : { $type: 10 } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La { item, { $type, BCON_NULL } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La Type("item", BsonType.Null) consulta que utiliza el método FilterDefinitionBuilder.Type() solo coincide con los documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La siguiente consulta coincide únicamente con documentos que contienen el item campo con un valor de Tipo BSON Null (Tipo 10 BSON):

La type("item", BsonType.NULL) consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La type("item", BsonType.NULL) consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La type("item", BsonType.NULL) consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La { item : { $type: 10 } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La { item : { $type: 10 } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La [ item => [ $type => 10 ] ] consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La { item : { $type: 10 } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La { item => { $type => 10 } } consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

La type("item", BsonType.NULL) consulta solo encuentra documentos que contienen el item campo con un null valor. El valor del item campo es de tipo BSON Null (tipo BSON).10

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

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

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

Comprobación de existencia

El siguiente ejemplo consulta documentos que no contienen un campo.

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, BCON_BOOL (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 bson.D{{"item", bson.D{{"$exists", 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 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

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

Limpie cualquier recurso abierto llamando a los siguientes métodos, según corresponda:

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

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

Nota

Las expresiones no admiten el $exists operador. Para comprobar la existencia de un campo en una expresión, puede usar el $type operador de agregación para comprobar si un campo tiene el missing tipo.

Para más información, consulte $type Verificación de Existencia.

Tip

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

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 operadores de consulta en MongoDB tratan los valores null de forma diferente. Para aplicar un filtro de consulta, copie cada uno de los siguientes documentos en la barra de búsqueda Filter y haga clic en Apply.

Utilice el siguiente filtro de consulta para hacer coincidir documentos que contienen un campo description con un valor null o que no contienen 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

Tiempos de espera

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