Docs Menu

/ /

/

/

Operaciones CRUD

/

/

/

Operaciones CRUD

/

Query de documentos incrustados/anidados

Consulta documentos incrustados en MongoDB con 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 Consultar documentos incrustados 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.

Esta página proporciona ejemplos de operaciones de consulta en documentos anidados/incrustados 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:

Esta página proporciona ejemplos de operaciones de query en documentos incrustados/anidados usando 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 de consulta en documentos incrustados/anidados 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 brinda ejemplos de operaciones de query en documentos incrustados/anidados utilizando el método MongoCollection.Find() 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 brinda ejemplos de operaciones de query sobre documentos incrustados/anidados 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 brinda ejemplos de operaciones de query sobre documentos incrustados/anidados 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 brinda ejemplos de operaciones de query sobre documentos incrustados/anidados utilizando el método com.mongodb.client.MongoCollection.find en el controlador síncrono para 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 brinda ejemplos de operaciones de query en documentos incrustados/anidados utilizando el método MongoCollection.find() en el controlador de corrutina de Kotlin 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:

A partir de mayo de 14, 2025, Motor está obsoleto en favor de la versión GA de la API asíncrona de PyMongo en la librería PyMongo. No añadiremos nuevas características a Motor, y solo proporcionaremos correcciones de errores hasta que llegue al final de su vida útil el 14 de mayo de 2026. Después de eso, solo corregiremos los errores críticos hasta que finalice el soporte el 14 de mayo de 2027. Recomendamos encarecidamente migrar a la API asíncrona de PyMongo mientras Motor aún sea compatible.

Para obtener más información sobre la migración, consulta la Guía de migración a PyMongo asíncrono en la documentación de PyMongo.

Esta página proporciona ejemplos de operaciones de consulta en documentos anidados/incrustados utilizando el método en la API pymongo.asynchronous.collection.AsyncCollection.find asíncrona de 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 brinda ejemplos de operaciones de query en documentos incrustados/anidados utilizando el método Collection.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 de query en documentos incrustados/anidados utilizando el método MongoDB\\Collection::find() en la librería PHP 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 brinda ejemplos de operaciones de query en documentos incrustados/anidados 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:

En esta página, se proporcionan ejemplos de operaciones de query en documentos incrustados/anidados mediante 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 brinda ejemplos de operaciones de query en documentos incrustados/anidados 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:

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: "A" },
   { 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": "A" },
    { "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 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 (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}

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

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

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

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

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

# Subdocument key order matters in a few of these examples so we have
# to use bson.son.SON instead of a Python dict.
from bson.son import SON
await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": SON([("h", 14), ("w", 21), ("uom", "cm")]),
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
            "status": "A",
        },
    ]
)

const documentsToInsert = [
  {
    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 collection.insertMany(documentsToInsert);

$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' => 'A',
    ],
    [
        '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": "A",
        },
        {
            "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: 'A' },
                                { 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()

Consultar campos anidados con notación de puntos

Especifique condiciones de consulta en campos de un documento incrustado/anidado con notación de "field.nestedField" punto.

Nota

Cuando se realiza una consulta con notación de puntos, el campo y el campo anidado deben estar entre comillas.

Especificar una coincidencia exacta en un campo anidado

El siguiente ejemplo selecciona todos los documentos donde el campo uom anidado en el campo size sea igual a "in":

db.inventory.find( { "size.uom": "in" } )

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

{ "size.uom": "in" }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("size.uom", BCON_UTF8 ("in"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("size.uom", "in");
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"size.uom", "in"}},
)

findPublisher = collection.find(eq("size.uom", "in"));

findIterable = collection.find(eq("size.uom", "in"));

val findFlow = collection
    .find(eq("size.uom", "in"))

cursor = db.inventory.find({"size.uom": "in"})

const cursor = db.collection('inventory').find({
  'size.uom': 'in'
});

$cursor = $db->inventory->find(['size.uom' => 'in']);

cursor = db.inventory.find({"size.uom": "in"})

client[:inventory].find('size.uom' => 'in')

findObservable = collection.find(equal("size.uom", "in"))

Especificar coincidencia usando el operador del query

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Además del filtro de igualdad, MongoDB ofrece varios operadores de query para especificar las condiciones del filtro. Utiliza los métodos de FilterDefinitionBuilder para crear un documento de filtro. Por ejemplo:

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

Además del filtro de igualdad, MongoDB proporciona varios operadores de query para especificar las condiciones del filtro. Utilice el paquete bson para crear operadores de query para documentos de filtro. Por ejemplo:

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

Además de la condición de igualdad, MongoDB ofrece varios operadores de query para especificar condiciones de filtros. Utiliza los métodos asistentes de com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Por ejemplo:

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

Además de la condición de igualdad, MongoDB ofrece varios operadores de query para especificar condiciones de filtros. Utiliza los métodos asistentes de com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Por ejemplo:

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

Además de la condición de igualdad, MongoDB ofrece varios operadores de query para especificar condiciones de filtros. Utiliza los métodos asistentes de com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Por ejemplo:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Un documento de filtro de query puedes utilizar los operadores de la query para especificar condiciones de la siguiente forma:

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

Además de la condición de igualdad, MongoDB proporciona varios operadores de la query para especificar las condiciones de filtro. Utiliza los métodos asistentes com.mongodb.client.model.Filters_ para facilitar la creación de documentos de filtro. Por ejemplo:

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

La siguiente consulta utiliza el operador menor que ($lt) en el campo h incrustado en el campo size:

db.inventory.find( { "size.h": { $lt: 15 } } )

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

{ "size.h": { $lt: 15 } }

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "size.h", "{",
   "$lt", BCON_INT64 (15),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Lt("size.h", 15);
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size.h", bson.D{
			{"$lt", 15},
		}},
	})

findPublisher = collection.find(lt("size.h", 15));

findIterable = collection.find(lt("size.h", 15));

val findFlow = collection
    .find(lt("size.h", 15))

cursor = db.inventory.find({"size.h": {"$lt": 15}})

const cursor = db.collection('inventory').find({
  'size.h': { $lt: 15 }
});

$cursor = $db->inventory->find(['size.h' => ['$lt' => 15]]);

cursor = db.inventory.find({"size.h": {"$lt": 15}})

client[:inventory].find('size.h' => { '$lt' =>  15 })

findObservable = collection.find(lt("size.h", 15))

Especifique la `AND` condición

El siguiente query selecciona todos los documentos donde el campo anidado h es menor que 15, el campo anidado uom es igual a "in" y el campo status es igual a "D":

db.inventory.find( { "size.h": { $lt: 15 }, "size.uom": "in", status: "D" } )

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

{ "size.h": { $lt: 15 }, "size.uom": "in", status: "D" }

Consulta múltiples campos anidados

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "size.h", "{",
   "$lt", BCON_INT64 (15),
   "}",
   "size.uom", BCON_UTF8 ("in"),
   "status", BCON_UTF8 ("D"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Lt("size.h", 15), builder.Eq("size.uom", "in"), builder.Eq("status", "D"));
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size.h", bson.D{
			{"$lt", 15},
		}},
		{"size.uom", "in"},
		{"status", "D"},
	})

findPublisher = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

findIterable = collection.find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
));

val findFlow = collection
    .find(and(
        lt("size.h", 15),
        eq("size.uom", "in"),
        eq("status", "D")
    ))

cursor = db.inventory.find({"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

const cursor = db.collection('inventory').find({
  'size.h': { $lt: 15 },
  'size.uom': 'in',
  status: 'D'
});

$cursor = $db->inventory->find([
    'size.h' => ['$lt' => 15],
    'size.uom' => 'in',
    'status' => 'D',
]);

cursor = db.inventory.find({"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

client[:inventory].find('size.h'   => { '$lt' => 15 },
                        'size.uom' => 'in',
                        'status'   => 'D')

findObservable = collection.find(and(
  lt("size.h", 15),
  equal("size.uom", "in"),
  equal("status", "D")
))

Coincidir con un documento incrustado/anidado

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field>: <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field>: <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field>: <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<field>, <value>)

<value> es el documento a comparar

Para especificar una condición de igualdad en un campo que es un documento incrustado, utiliza el tipo bson.D para crear un filtro donde <value> es el documento a coincidir:

filter := bson.D{
    {<field>, bson.D{
        {"nestedField1", value1},
        {"nestedField2", value2},
    }},
}

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro eq( <field1>, <value>) donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro eq( <field1>, <value>) donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado, utiliza la clase documento o el método eq() donde <value> es el documento que debe coincidir:

eq(<field>, Document()
   .append("nestedField1", value1)
   .append("nestedField2", value2))

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field>: <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field>: <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query [ <field> => <value> ] donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field>: <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro de query { <field> => <value> } donde <value> es el documento que debe coincidir.

Para especificar una condición de igualdad en un campo que es un documento incrustado/anidado, utiliza el documento de filtro equal( <field1>, <value> ) donde <value> es el documento que debe coincidir.

Por ejemplo, el siguiente query selecciona todos los documentos donde el campo size es igual al documento { h: 14, w: 21, uom: "cm" }:

db.inventory.find( { size: { h: 14, w: 21, uom: "cm" } } )

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

{ size: { h: 14, w: 21, uom: "cm" } }

Campo de query embebida

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "h", 14 }, { "w", 21 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
	})

FindPublisher<Document> findPublisher = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

FindIterable<Document> findIterable = collection.find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")));

val findFlow = collection
    .find(eq("size", Document.parse("{ h: 14, w: 21, uom: 'cm' }")))

cursor = db.inventory.find({"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})

const cursor = collection.find({
  size: { h: 14, w: 21, uom: 'cm' },
});

$cursor = $db->inventory->find(['size' => ['h' => 14, 'w' => 21, 'uom' => 'cm']]);

cursor = db.inventory.find({"size": {"h": 14, "w": 21, "uom": "cm"}})

client[:inventory].find(size: { h: 14, w: 21, uom: 'cm' })

var findObservable = collection.find(equal("size", Document("h" -> 14, "w" -> 21, "uom" -> "cm")))

Advertencia

MongoDB no recomienda comparaciones en documentos incrustados porque las operaciones requieren una coincidencia exacta del documento <value> especificado, incluido el orden de los campos.

Por ejemplo, el siguiente query no coincide con ningún documento de la colección inventory:

db.inventory.find(  { size: { w: 21, h: 14, uom: "cm" } }  )

Campo de query embebida

mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "size", "{",
   "w", BCON_DOUBLE (21),
   "h", BCON_DOUBLE (14),
   "uom", BCON_UTF8 ("cm"),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

var filter = Builders<BsonDocument>.Filter.Eq("size", new BsonDocument { { "w", 21 }, { "h", 14 }, { "uom", "cm" } });
var result = collection.Find(filter).ToList();

cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"size", bson.D{
			{"w", 21},
			{"h", 14},
			{"uom", "cm"},
		}},
	})

findPublisher = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

findIterable = collection.find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")));

val findFlow = collection
    .find(eq("size", Document.parse("{ w: 21, h: 14, uom: 'cm' }")))

cursor = db.inventory.find({"size": SON([("w", 21), ("h", 14), ("uom", "cm")])})

const cursor = db.collection('inventory').find({
  size: { w: 21, h: 14, uom: 'cm' }
});

$cursor = $db->inventory->find(['size' => ['w' => 21, 'h' => 14, 'uom' => 'cm']]);

cursor = db.inventory.find({"size": {"w": 21, "h": 14, "uom": "cm"}})

client[:inventory].find(size: { h: 21, w: 14, uom: 'cm' })

findObservable = collection.find(equal("size", Document("w" -> 21, "h" -> 14, "uom" -> "cm")))

Las queries que utilizan comparaciones en documentos incrustados pueden provocar un comportamiento impredecible si se utilizan con un controlador que no emplea estructuras de datos ordenadas para expresar las queries.

Consultar documentos incrustados con MongoDB Atlas

Este ejemplo utiliza el conjunto de datos de muestra de películas. Para cargar el conjunto de datos de muestra en su implementación de MongoDB Atlas, consulte Cargar datos de muestra.

Para consultar un documento incrustado en MongoDB Atlas, seguir 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

Navegue 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_mflix.
Seleccione la colección movies.

3

Especificar el documento de filtro de query

Especifique el 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.

Copie el siguiente documento de filtro de query en la barra de búsqueda Filter:

{ "awards.wins": 1 }

4

Haga clic Apply

Este filtro de query devuelve todos los documentos de la colección sample_mflix.movies donde el documento incrustado para el campo awards contiene { wins: 1 }.

Tutoriales adicionales de query

Para obtener ejemplos adicionales de queries, consulte:

Volver

Query

Next

Arreglos

Seleccionar el lenguaje

Califique esta página

En esta página

Consultar campos anidados con notación de puntos

Coincidir con un documento incrustado/anidado
Consultar documentos incrustados con MongoDB Atlas
Tutoriales adicionales de query

En esta página

Consultar campos anidados con notación de puntos
Coincidir con un documento incrustado/anidado
Consultar documentos incrustados con MongoDB Atlas
Tutoriales adicionales de query