Docs Menu
Docs Home
/ /
Query
Docs Home
/
Desarrollo
/
Operaciones CRUD
/
Query
Docs Home
/
Desarrollo
/
Operaciones CRUD
/
Query

Query de un arreglo de documentos incrustados

Puede query documentos 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 Consultar una matriz de documentos 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 una matriz de documentos anidados 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 un arreglo de documentos 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 una matriz de documentos 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 proporciona ejemplos de operaciones de query en un arreglo de documentos anidados 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 proporciona ejemplos de operaciones de query en un arreglo de documentos anidados utilizando la función Collection.Find en el MongoDB Go 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 proporciona ejemplos de operaciones de query sobre un arreglo de documentos anidados utilizando el método com.mongodb.reactivestreams.client.MongoCollection.find en el driver 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 proporciona ejemplos de operaciones de query sobre un arreglo de documentos anidados utilizando el método com.mongodb.client.MongoCollection.find en el driver 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 de query en un arreglo de documentos anidados utilizando el método MongoCollection.find() en el driver 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 proporciona ejemplos de operaciones de consulta en una matriz de documentos anidados 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 proporciona ejemplos de operaciones de query en un arreglo de documentos anidados utilizando Collection.find() método en el driver Nodo.js 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 un arreglo de documentos anidados 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 proporciona ejemplos de operaciones de query en un arreglo de documentos 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:

Esta página proporciona ejemplos de operaciones de query sobre un arreglo de documentos anidados 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 proporciona ejemplos de operaciones de query en un arreglo de documentos anidados utilizando collection.find() método en el MongoDB Scala 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:

db.inventory.insertMany( [
   { item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] },
   { item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] },
   { item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] },
   { item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] },
   { item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }
]);
[
    { "item": "journal", "instock": [ { "warehouse": "A", "qty": 5 }, { "warehouse": "C", "qty": 15 } ] },
    { "item": "notebook", "instock": [ { "warehouse": "C", "qty": 5 } ] },
    { "item": "paper", "instock": [ { "warehouse": "A", "qty": 60 }, { "warehouse": "B", "qty": 15 } ] },
    { "item": "planner", "instock": [ { "warehouse": "A", "qty": 40 }, { "warehouse": "B", "qty": 5 } ] },
    { "item": "postcard", "instock": [ { "warehouse": "B","qty": 15 }, { "warehouse": "C", "qty": 35 } ] }
]

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"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (5),
   "}","{",
   "warehouse", BCON_UTF8 ("C"),
   "qty", BCON_INT64 (15),
   "}",
   "]");
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"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("C"),
   "qty", BCON_INT64 (5),
   "}",
   "]");
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"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (60),
   "}","{",
   "warehouse", BCON_UTF8 ("B"),
   "qty", BCON_INT64 (15),
   "}",
   "]");
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"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (40),
   "}","{",
   "warehouse", BCON_UTF8 ("B"),
   "qty", BCON_INT64 (5),
   "}",
   "]");
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"),
   "instock", "[",
   "{",
   "warehouse", BCON_UTF8 ("B"),
   "qty", BCON_INT64 (15),
   "}","{",
   "warehouse", BCON_UTF8 ("C"),
   "qty", BCON_INT64 (35),
   "}",
   "]");
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" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 5 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 15 } } }
            }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "C" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 60 } },
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } } }
            }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "A" }, { "qty", 40 } },
                new BsonDocument { { "warehouse", "B" }, { "qty", 5 } } }
            }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "instock", new BsonArray
            {
                new BsonDocument { { "warehouse", "B" }, { "qty", 15 } },
                new BsonDocument { { "warehouse", "C" }, { "qty", 35 } } }
            }
    }
};
collection.InsertMany(documents);
docs := []any{
	bson.D{
		{"item", "journal"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 5},
			},
			bson.D{
				{"warehouse", "C"},
				{"qty", 15},
			},
		}},
	},
	bson.D{
		{"item", "notebook"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "C"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "paper"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 60},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
		}},
	},
	bson.D{
		{"item", "planner"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "A"},
				{"qty", 40},
			},
			bson.D{
				{"warehouse", "B"},
				{"qty", 5},
			},
		}},
	},
	bson.D{
		{"item", "postcard"},
		{"instock", bson.A{
			bson.D{
				{"warehouse", "B"},
				{"qty", 15},
			},
			bson.D{
				{"warehouse", "C"},
				{"qty", 35},
			},
		}},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', instock: [ { warehouse: 'A', qty: 5 }, { warehouse: 'C', qty: 15 } ] }"),
        Document.parse("{ item: 'notebook', instock: [ { warehouse: 'C', qty: 5 } ] }"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 15 } ] }"),
        Document.parse("{ item: 'planner', instock: [ { warehouse: 'A', qty: 40 }, { warehouse: 'B', qty: 5 } ] }"),
        Document.parse("{ item: 'postcard', instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));
collection.insertMany(asList(
        Document.parse("{ item: 'journal', instock: [ { warehouse: 'A', qty: 5 }, { warehouse: 'C', qty: 15 } ] }"),
        Document.parse("{ item: 'notebook', instock: [ { warehouse: 'C', qty: 5 } ] }"),
        Document.parse("{ item: 'paper', instock: [ { warehouse: 'A', qty: 60 }, { warehouse: 'B', qty: 15 } ] }"),
        Document.parse("{ item: 'planner', instock: [ { warehouse: 'A', qty: 40 }, { warehouse: 'B', qty: 5 } ] }"),
        Document.parse("{ item: 'postcard', instock: [ { warehouse: 'B', qty: 15 }, { warehouse: 'C', qty: 35 } ] }")
));
collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("instock", listOf(
                Document("warehouse", "A").append("qty", 5),
                Document("warehouse", "C").append("qty", 15)
            )),
        Document("item", "notebook")
            .append("instock", listOf(
                Document("warehouse", "C").append("qty", 5)
            )),
        Document("item", "paper")
            .append("instock", listOf(
                Document("warehouse", "A").append("qty", 60),
                Document("warehouse", "B").append("qty", 15)
            )),
        Document("item", "planner")
            .append("instock", listOf(
                Document("warehouse", "A").append("qty", 40),
                Document("warehouse", "B").append("qty", 5)
            )),
        Document("item", "postcard")
            .append("instock", listOf(
                Document("warehouse", "B").append("qty", 15),
                Document("warehouse", "C").append("qty", 35)
            )),
    )
)
# 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",
            "instock": [
                SON([("warehouse", "A"), ("qty", 5)]),
                SON([("warehouse", "C"), ("qty", 15)]),
            ],
        },
        {"item": "notebook", "instock": [SON([("warehouse", "C"), ("qty", 5)])]},
        {
            "item": "paper",
            "instock": [
                SON([("warehouse", "A"), ("qty", 60)]),
                SON([("warehouse", "B"), ("qty", 15)]),
            ],
        },
        {
            "item": "planner",
            "instock": [
                SON([("warehouse", "A"), ("qty", 40)]),
                SON([("warehouse", "B"), ("qty", 5)]),
            ],
        },
        {
            "item": "postcard",
            "instock": [
                SON([("warehouse", "B"), ("qty", 15)]),
                SON([("warehouse", "C"), ("qty", 35)]),
            ],
        },
    ]
)
await db.collection('inventory').insertMany([
  {
    item: 'journal',
    instock: [
      { warehouse: 'A', qty: 5 },
      { warehouse: 'C', qty: 15 }
    ]
  },
  {
    item: 'notebook',
    instock: [{ warehouse: 'C', qty: 5 }]
  },
  {
    item: 'paper',
    instock: [
      { warehouse: 'A', qty: 60 },
      { warehouse: 'B', qty: 15 }
    ]
  },
  {
    item: 'planner',
    instock: [
      { warehouse: 'A', qty: 40 },
      { warehouse: 'B', qty: 5 }
    ]
  },
  {
    item: 'postcard',
    instock: [
      { warehouse: 'B', qty: 15 },
      { warehouse: 'C', qty: 35 }
    ]
  }
]);
$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 5],
            ['warehouse' => 'C',  'qty' => 15],
        ],
    ],
    [
        'item' => 'notebook',
        'instock' => [
            ['warehouse' => 'C',  'qty' => 5],
        ],
    ],
    [
        'item' => 'paper',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 60],
            ['warehouse' => 'B',  'qty' => 15],
        ],
    ],
    [
        'item' => 'planner',
        'instock' => [
            ['warehouse' => 'A',  'qty' => 40],
            ['warehouse' => 'B',  'qty' => 5],
        ],
    ],
    [
        'item' => 'postcard',
        'instock' => [
            ['warehouse' => 'B',  'qty' => 15],
            ['warehouse' => 'C',  'qty' => 35],
        ],
    ],
]);
db.inventory.insert_many(
    [
        {
            "item": "journal",
            "instock": [
                {"warehouse": "A", "qty": 5},
                {"warehouse": "C", "qty": 15},
            ],
        },
        {"item": "notebook", "instock": [{"warehouse": "C", "qty": 5}]},
        {
            "item": "paper",
            "instock": [
                {"warehouse": "A", "qty": 60},
                {"warehouse": "B", "qty": 15},
            ],
        },
        {
            "item": "planner",
            "instock": [
                {"warehouse": "A", "qty": 40},
                {"warehouse": "B", "qty": 5},
            ],
        },
        {
            "item": "postcard",
            "instock": [
                {"warehouse": "B", "qty": 15},
                {"warehouse": "C", "qty": 35},
            ],
        },
    ]
)
client[:inventory].insert_many([{ item: 'journal',
                                  instock: [ { warehouse: 'A', qty: 5 },
                                             { warehouse: 'C', qty: 15 }] },
                                { item: 'notebook',
                                  instock: [ { warehouse: 'C', qty: 5 }] },
                                { item: 'paper',
                                  instock: [ { warehouse: 'A', qty: 60 },
                                             { warehouse: 'B', qty: 15 }] },
                                { item: 'planner',
                                  instock: [ { warehouse: 'A', qty: 40 },
                                             { warehouse: 'B', qty: 5 }] },
                                { item: 'postcard',
                                  instock: [ { warehouse: 'B', qty: 15 },
                                             { warehouse: 'C', qty: 35 }] }
                               ])
collection.insertMany(Seq(
  Document("""{ item: "journal", instock: [ { warehouse: "A", qty: 5 }, { warehouse: "C", qty: 15 } ] }"""),
  Document("""{ item: "notebook", instock: [ { warehouse: "C", qty: 5 } ] }"""),
  Document("""{ item: "paper", instock: [ { warehouse: "A", qty: 60 }, { warehouse: "B", qty: 15 } ] }"""),
  Document("""{ item: "planner", instock: [ { warehouse: "A", qty: 40 }, { warehouse: "B", qty: 5 } ] }"""),
  Document("""{ item: "postcard", instock: [ { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ] }""")
)).execute()

Query para un documento anidado en un arreglo

El siguiente ejemplo selecciona todos los documentos donde un elemento del arreglo instock coincide con el documento especificado:

db.inventory.find( { "instock": { warehouse: "A", qty: 5 } } )

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

{ "instock": { warehouse: "A", qty: 5 } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock", "{",
   "warehouse", BCON_UTF8 ("A"),
   "qty", BCON_INT64 (5),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "warehouse", "A" }, { "qty", 5 } });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"warehouse", "A"},
			{"qty", 5},
		}},
	})
FindPublisher<Document> findPublisher = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));
FindIterable<Document> findIterable = collection.find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")));
val findFlow = collection
    .find(eq("instock", Document.parse("{ warehouse: 'A', qty: 5 }")))
cursor = db.inventory.find({"instock": SON([("warehouse", "A"), ("qty", 5)])})
const cursor = db.collection('inventory').find({
  instock: { warehouse: 'A', qty: 5 }
});
$cursor = $db->inventory->find(['instock' => ['warehouse' => 'A', 'qty' => 5]]);
cursor = db.inventory.find({"instock": {"warehouse": "A", "qty": 5}})
client[:inventory].find(instock: { warehouse: 'A', qty: 5 })
var findObservable = collection.find(equal("instock", Document("warehouse" -> "A", "qty" -> 5)))

Las coincidencias de igualdad en todo el documento incrustado/anidado requieren una coincidencia exacta del documento especificado, incluyendo el orden de los campos. Por ejemplo, la siguiente query no coincide con ningún documento en la colección inventory:

db.inventory.find( { "instock": { qty: 5, warehouse: "A" } } )
instock: { qty: 5, warehouse: 'A' }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock", "{",
   "qty", BCON_INT64 (5),
   "warehouse", BCON_UTF8 ("A"),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.AnyEq("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"qty", 5},
			{"warehouse", "A"},
		}},
	})
findPublisher = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));
findIterable = collection.find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));
val findFlow = collection
    .find(eq("instock", Document.parse("{ qty: 5, warehouse: 'A' }")))
cursor = db.inventory.find({"instock": SON([("qty", 5), ("warehouse", "A")])})
const cursor = db.collection('inventory').find({
  instock: { qty: 5, warehouse: 'A' }
});
$cursor = $db->inventory->find(['instock' => ['qty' => 5, 'warehouse' => 'A']]);
cursor = db.inventory.find({"instock": {"qty": 5, "warehouse": "A"}})
client[:inventory].find(instock: { qty: 5, warehouse: 'A' } )
findObservable = collection.find(equal("instock", Document("qty" -> 5, "warehouse" -> "A")))

Especifica una condición de query en un campo de un arreglo de documentos

Especifica una condición de query en un campo incrustado en un arreglo de documentos

Si no conoces la posición del índice del documento anidado en el arreglo, concatena el nombre del campo del arreglo con un punto (.) y el nombre del campo en el documento anidado.

El siguiente ejemplo selecciona todos los documentos donde el arreglo instock tiene al menos un documento incrustado que contiene el campo qty cuyo valor es menor o igual a 20:

db.inventory.find( { 'instock.qty': { $lte: 20 } } )

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

{ 'instock.qty': { $lte: 20 } }
Query para campo incrustado que coincide con una única condición
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock.qty", "{",
   "$lte", BCON_INT64 (20),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Lte("instock.qty", 20);
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", bson.D{
			{"$lte", 20},
		}},
	})
findPublisher = collection.find(lte("instock.qty", 20));
findIterable = collection.find(lte("instock.qty", 20));
val findFlow = collection
    .find(lte("instock.qty", 20))
cursor = db.inventory.find({"instock.qty": {"$lte": 20}})
const cursor = db.collection('inventory').find({
  'instock.qty': { $lte: 20 }
});
$cursor = $db->inventory->find(['instock.qty' => ['$lte' => 20]]);
cursor = db.inventory.find({"instock.qty": {"$lte": 20}})
client[:inventory].find('instock.qty' => { '$lte' => 20 })
findObservable = collection.find(lte("instock.qty", 20))

Utiliza el índice de arreglo para hacer un query a un campo en el documento incrustado

Mediante la notación de puntos, se pueden especificar condiciones de consulta para un campo de un documento en un índice o posición específicos de la matriz. La matriz utiliza indexación basada en cero.

Nota

Al realizar consultas utilizando la notación de puntos, el campo y el índice deben estar entre comillas.

El siguiente ejemplo selecciona todos los documentos donde el arreglo instock tiene como primer elemento un documento que contiene el campo qty cuyo valor es menor o igual a 20:

db.inventory.find( { 'instock.0.qty': { $lte: 20 } } )

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

{ 'instock.0.qty': { $lte: 20 } }
Query para un elemento de arreglo que cumpla con una sola condición
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock.0.qty", "{",
   "$lte", BCON_INT64 (20),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.Lte("instock.0.qty", 20);
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.0.qty", bson.D{
			{"$lte", 20},
		}},
	})
findPublisher = collection.find(lte("instock.0.qty", 20));
findIterable = collection.find(lte("instock.0.qty", 20));
val findFlow = collection
    .find(lte("instock.0.qty", 20))
cursor = db.inventory.find({"instock.0.qty": {"$lte": 20}})
const cursor = db.collection('inventory').find({
  'instock.0.qty': { $lte: 20 }
});
$cursor = $db->inventory->find(['instock.0.qty' => ['$lte' => 20]]);
cursor = db.inventory.find({"instock.0.qty": {"$lte": 20}})
client[:inventory].find('instock.0.qty' => { '$lte' => 20 })
findObservable = collection.find(lte("instock.0.qty", 20))

Especifica múltiples condiciones para el arreglo de documentos

Cuando se especifican condiciones en más de un campo anidado en una matriz de documentos, se puede especificar la consulta de modo que un solo documento cumpla con estas condiciones o que cualquier combinación de documentos en la matriz cumpla con las condiciones.

Un único documento anidado cumple múltiples condiciones de query en campos anidados

Utilice el operador para especificar múltiples criterios en una matriz de documentos incrustados de modo que al menos un documento incrustado satisfaga todos los criterios $elemMatch especificados.

El siguiente ejemplo consulta documentos donde el arreglo instock tiene al menos un documento incrustado que contiene tanto el campo qty igual a 5 como el campo warehouse igual a A:

db.inventory.find( { "instock": { $elemMatch: { qty: 5, warehouse: "A" } } } )

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

{ "instock": { $elemMatch: { qty: 5, warehouse: "A" } } }
Un único documento anidado cumple múltiples condiciones de query en campos anidados
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock", "{",
   "$elemMatch", "{",
   "qty", BCON_INT64 (5),
   "warehouse", BCON_UTF8 ("A"),
   "}",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", 5 }, { "warehouse", "A" } });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"$elemMatch", bson.D{
				{"qty", 5},
				{"warehouse", "A"},
			}},
		}},
	})
findPublisher = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));
findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")));
val findFlow = collection
    .find(elemMatch("instock", Document.parse("{ qty: 5, warehouse: 'A' }")))
cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})
const cursor = db.collection('inventory').find({
  instock: { $elemMatch: { qty: 5, warehouse: 'A' } }
});
$cursor = $db->inventory->find(['instock' => ['$elemMatch' => ['qty' => 5, 'warehouse' => 'A']]]);
cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})
client[:inventory].find(instock: { '$elemMatch' => { qty: 5,
                                                     warehouse: 'A' } })
findObservable = collection.find(elemMatch("instock", Document("qty" -> 5, "warehouse" -> "A")))

El siguiente ejemplo consulta documentos donde el arreglo instock tiene al menos un documento incrustado que contiene el campo qty que es mayor que 10 y menor o igual que 20:

db.inventory.find( { "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } } )

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

{ "instock": { $elemMatch: { qty: { $gt: 10, $lte: 20 } } } }
Un único documento anidado cumple múltiples condiciones de query en campos anidados
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock", "{",
   "$elemMatch", "{",
   "qty", "{",
   "$gt", BCON_INT64 (10),
   "$lte", BCON_INT64 (20),
   "}",
   "}",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("instock", new BsonDocument { { "qty", new BsonDocument { { "$gt", 10 }, { "$lte", 20 } } } });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock", bson.D{
			{"$elemMatch", bson.D{
				{"qty", bson.D{
					{"$gt", 10},
					{"$lte", 20},
				}},
			}},
		}},
	})
findPublisher = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));
findIterable = collection.find(elemMatch("instock", Document.parse("{ qty: { $gt: 10, $lte: 20 } }")));
val findFlow = collection
    .find(elemMatch("instock", Document.parse("{ qty: { \$gt: 10, \$lte: 20 } }")))
cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})
const cursor = db.collection('inventory').find({
  instock: { $elemMatch: { qty: { $gt: 10, $lte: 20 } } }
});
$cursor = $db->inventory->find(['instock' => ['$elemMatch' => ['qty' => ['$gt' => 10, '$lte' => 20]]]]);
cursor = db.inventory.find({"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})
client[:inventory].find(instock: { '$elemMatch' => { qty: { '$gt'  => 10,
                                                            '$lte' => 20 } } })
findObservable = collection.find(elemMatch("instock", Document("""{ qty: { $gt: 10, $lte: 20 } }""")))

La combinación de elementos satisface los criterios

Si las condiciones de query compuestas en un campo de arreglo no utilizan el operador $elemMatch, la query selecciona aquellos documentos cuyo arreglo contiene cualquier combinación de elementos que satisfaga las condiciones.

Por ejemplo, la siguiente query coincide con documentos donde cualquier documento incrustado en el arreglo instock tiene el campo qty mayor que 10 y cualquier documento (pero no necesariamente el mismo documento incrustado) en el arreglo tiene el campo qty menor o igual a 20:

db.inventory.find( { "instock.qty": { $gt: 10,  $lte: 20 } } )

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

{ "instock.qty": { $gt: 10,  $lte: 20 } }
Valor de cantidad de la query dentro del rango
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock.qty", "{",
   "$gt", BCON_INT64 (10),
   "$lte", BCON_INT64 (20),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Gt("instock.qty", 10), builder.Lte("instock.qty", 20));
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", bson.D{
			{"$gt", 10},
			{"$lte", 20},
		}},
	})
findPublisher = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));
findIterable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)));
val findFlow = collection
    .find(and(gt("instock.qty", 10), lte("instock.qty", 20)))
cursor = db.inventory.find({"instock.qty": {"$gt": 10, "$lte": 20}})
const cursor = db.collection('inventory').find({
  'instock.qty': { $gt: 10, $lte: 20 }
});
$cursor = $db->inventory->find(['instock.qty' => ['$gt' => 10, '$lte' => 20]]);
cursor = db.inventory.find({"instock.qty": {"$gt": 10, "$lte": 20}})
client[:inventory].find('instock.qty' => { '$gt' => 10, '$lte' => 20 })
findObservable = collection.find(and(gt("instock.qty", 10), lte("instock.qty", 20)))

Los siguientes ejemplos de queries de documentos donde el arreglo instock tiene al menos un documento incrustado que contiene el campo qty igual a 5 y al menos un documento incrustado (pero no necesariamente el mismo documento incrustado) que contiene el campo warehouse igual a A:

db.inventory.find( { "instock.qty": 5, "instock.warehouse": "A" } )

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

{ "instock.qty": 5, "instock.warehouse": "A" }
Cantidad y ubicación del almacén que coinciden con la query
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "instock.qty", BCON_INT64 (5),
   "instock.warehouse", BCON_UTF8 ("A"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("instock.qty", 5), builder.Eq("instock.warehouse", "A"));
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"instock.qty", 5},
		{"instock.warehouse", "A"},
	})
findPublisher = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));
findIterable = collection.find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")));
val findFlow = collection
    .find(and(eq("instock.qty", 5), eq("instock.warehouse", "A")))
cursor = db.inventory.find({"instock.qty": 5, "instock.warehouse": "A"})
const cursor = db.collection('inventory').find({
  'instock.qty': 5,
  'instock.warehouse': 'A'
});
$cursor = $db->inventory->find(['instock.qty' => 5, 'instock.warehouse' => 'A']);
cursor = db.inventory.find({"instock.qty": 5, "instock.warehouse": "A"})
client[:inventory].find('instock.qty' => 5,
                        'instock.warehouse' => 'A')
findObservable = collection.find(and(equal("instock.qty", 5), equal("instock.warehouse", "A")))

Query un arreglo de documentos con MongoDB Atlas

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

Para query un arreglo de documentos en MongoDB Atlas, siga estos pasos:

1

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

  1. 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.

  2. Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.

  3. 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

  1. Para el clúster que contiene los datos de muestra, haz clic en Browse Collections.

  2. En el panel de navegación izquierdo, seleccione la base de datos sample_training.

  3. Seleccione la colección grades.

3

Especifique el campo de filtro

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:

{"scores.type": "exam"}
4

Haga clic Apply

Este filtro de query devuelve todos los documentos de la colección sample_training.grades que contienen un subdocumento en el arreglo scores en el que type está configurado en exam. Se devuelve el documento completo, incluyendo el arreglo completo de scores. Para obtener más información sobre cómo modificar el arreglo devuelto, consulta Elementos específicos del proyecto en el arreglo devuelto.

Tutoriales adicionales de query

Para obtener ejemplos adicionales de queries, consulte:

Volver

Arreglos

Next

Resultados del Proyecto

En esta página