Puedes consultar arreglos en MongoDB utilizando los siguientes métodos:
El driver de su lenguaje de programación.
La interfaz de usuario de MongoDB Atlas. Para obtener más información, consulta Realiza un query en un arreglo con MongoDB Atlas.
➤ 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 campos de matriz 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 de query en campos de arreglos mediante 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 campos de matriz utilizando MongoCollection.Find()método en el controlador C# de MongoDB.
Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:
Esta página proporciona ejemplos de operaciones de query en campos de arreglo 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 campos de arreglo 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 proporciona ejemplos de operaciones de query en campos de arreglos 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 de query en campos de arreglo 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 proporciona ejemplos de operaciones de query en campos de arreglos usando el método Collection.find() en el MongoDB Node.js 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:
En esta página, se proporcionan ejemplos de operaciones de query en campos de arreglo mediante 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 proporciona ejemplos de operaciones de query en campos de arreglo 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 en campos de arreglo 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 campos de arreglo utilizando el método collection.find() 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", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }, { item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }, { item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }, { item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }, { item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] } ]);
[ { "item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [ 14, 21 ] }, { "item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [ 14, 21 ] }, { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [ 14, 21 ] }, { "item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [ 22.85, 30 ] }, { "item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [ 10, 15.25 ] } ]
Para obtener instrucciones sobre cómo insertar documentos en MongoDB Compass, consulta Insertar documentos.
var documents = new[] { new BsonDocument { { "item", "journal" }, { "qty", 25 }, { "tags", new BsonArray { "blank", "red" } }, { "dim_cm", new BsonArray { 14, 21 } } }, new BsonDocument { { "item", "notebook" }, { "qty", 50 }, { "tags", new BsonArray { "red", "blank" } }, { "dim_cm", new BsonArray { 14, 21 } } }, new BsonDocument { { "item", "paper" }, { "qty", 100 }, { "tags", new BsonArray { "red", "blank", "plain" } }, { "dim_cm", new BsonArray { 14, 21 } } }, new BsonDocument { { "item", "planner" }, { "qty", 75 }, { "tags", new BsonArray { "blank", "red" } }, { "dim_cm", new BsonArray { 22.85, 30 } } }, new BsonDocument { { "item", "postcard" }, { "qty", 45 }, { "tags", new BsonArray { "blue" } }, { "dim_cm", new BsonArray { 10, 15.25 } } } }; collection.InsertMany(documents);
docs := []any{ bson.D{ {"item", "journal"}, {"qty", 25}, {"tags", bson.A{"blank", "red"}}, {"dim_cm", bson.A{14, 21}}, }, bson.D{ {"item", "notebook"}, {"qty", 50}, {"tags", bson.A{"red", "blank"}}, {"dim_cm", bson.A{14, 21}}, }, bson.D{ {"item", "paper"}, {"qty", 100}, {"tags", bson.A{"red", "blank", "plain"}}, {"dim_cm", bson.A{14, 21}}, }, bson.D{ {"item", "planner"}, {"qty", 75}, {"tags", bson.A{"blank", "red"}}, {"dim_cm", bson.A{22.85, 30}}, }, bson.D{ {"item", "postcard"}, {"qty", 45}, {"tags", bson.A{"blue"}}, {"dim_cm", bson.A{10, 15.25}}, }, } result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList( Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"), Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }") ));
collection.insertMany(asList( Document.parse("{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }"), Document.parse("{ item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }"), Document.parse("{ item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] }") ));
await db.inventory.insert_many( [ {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]}, {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]}, { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [14, 21], }, {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]}, {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]}, ] )
await db.collection('inventory').insertMany([ { item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [14, 21] }, { item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [14, 21] }, { item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [14, 21] }, { item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [22.85, 30] }, { item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [10, 15.25] } ]);
$insertManyResult = $db->inventory->insertMany([ [ 'item' => 'journal', 'qty' => 25, 'tags' => ['blank', 'red'], 'dim_cm' => [14, 21], ], [ 'item' => 'notebook', 'qty' => 50, 'tags' => ['red', 'blank'], 'dim_cm' => [14, 21], ], [ 'item' => 'paper', 'qty' => 100, 'tags' => ['red', 'blank', 'plain'], 'dim_cm' => [14, 21], ], [ 'item' => 'planner', 'qty' => 75, 'tags' => ['blank', 'red'], 'dim_cm' => [22.85, 30], ], [ 'item' => 'postcard', 'qty' => 45, 'tags' => ['blue'], 'dim_cm' => [10, 15.25], ], ]);
db.inventory.insert_many( [ {"item": "journal", "qty": 25, "tags": ["blank", "red"], "dim_cm": [14, 21]}, {"item": "notebook", "qty": 50, "tags": ["red", "blank"], "dim_cm": [14, 21]}, { "item": "paper", "qty": 100, "tags": ["red", "blank", "plain"], "dim_cm": [14, 21], }, {"item": "planner", "qty": 75, "tags": ["blank", "red"], "dim_cm": [22.85, 30]}, {"item": "postcard", "qty": 45, "tags": ["blue"], "dim_cm": [10, 15.25]}, ] )
client[:inventory].insert_many([{ item: 'journal', qty: 25, tags: ['blank', 'red'], dim_cm: [ 14, 21 ] }, { item: 'notebook', qty: 50, tags: ['red', 'blank'], dim_cm: [ 14, 21 ] }, { item: 'paper', qty: 100, tags: ['red', 'blank', 'plain'], dim_cm: [ 14, 21 ] }, { item: 'planner', qty: 75, tags: ['blank', 'red'], dim_cm: [ 22.85, 30 ] }, { item: 'postcard', qty: 45, tags: ['blue'], dim_cm: [ 10, 15.25 ] } ])
collection.insertMany(Seq( Document("""{ item: "journal", qty: 25, tags: ["blank", "red"], dim_cm: [ 14, 21 ] }"""), Document("""{ item: "notebook", qty: 50, tags: ["red", "blank"], dim_cm: [ 14, 21 ] }"""), Document("""{ item: "paper", qty: 100, tags: ["red", "blank", "plain"], dim_cm: [ 14, 21 ] }"""), Document("""{ item: "planner", qty: 75, tags: ["blank", "red"], dim_cm: [ 22.85, 30 ] }"""), Document("""{ item: "postcard", qty: 45, tags: ["blue"], dim_cm: [ 10, 15.25 ] }""") )).execute()
Hacer coincidir un arreglo
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, construye un filtro utilizando el método Eq:
Builders<BsonDocument>.Filter.Eq(<field>, <value>)
<value> es la matriz exacta a coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query eq( <field>, <value>) donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query eq( <field>, <value>) donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query [ <field> => <value> ] donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query { <field> => <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
Para especificar la condición de igualdad en un arreglo, utiliza el documento de query equal( <field>, <value> ) donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.
En el siguiente ejemplo, se realiza un query para todos los documentos donde el valor del campo tags es un arreglo con exactamente dos elementos, "red" y "blank", en el orden especificado:
db.inventory.find( { tags: ["red", "blank"] } )
Copia el siguiente filtro en la barra de query de Compass y haz clic Find:
{ tags: ["red", "blank"] }
var filter = Builders<BsonDocument>.Filter.Eq("tags", new[] { "red", "blank" }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{{"tags", bson.A{"red", "blank"}}}, )
FindPublisher<Document> findPublisher = collection.find(eq("tags", asList("red", "blank")));
cursor = db.inventory.find({"tags": ["red", "blank"]})
const cursor = db.collection('inventory').find({ tags: ['red', 'blank'] });
$cursor = $db->inventory->find(['tags' => ['red', 'blank']]);
cursor = db.inventory.find({"tags": ["red", "blank"]})
client[:inventory].find(tags: ['red', 'blank'])
var findObservable = collection.find(equal("tags", Seq("red", "blank")))
Si, por el contrario, deseas encontrar un arreglo que contenga tanto los elementos "red" como "blank", sin tener en cuenta el orden ni otros elementos del arreglo, utiliza el operador $all:
db.inventory.find( { tags: { $all: ["red", "blank"] } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ tags: { $all: ["red", "blank"] } }
var filter = Builders<BsonDocument>.Filter.All("tags", new[] { "red", "blank" }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"tags", bson.D{{"$all", bson.A{"red", "blank"}}}}, })
findPublisher = collection.find(all("tags", asList("red", "blank")));
findIterable = collection.find(all("tags", asList("red", "blank")));
cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})
const cursor = db.collection('inventory').find({ tags: { $all: ['red', 'blank'] } });
$cursor = $db->inventory->find(['tags' => ['$all' => ['red', 'blank']]]);
cursor = db.inventory.find({"tags": {"$all": ["red", "blank"]}})
client[:inventory].find(tags: { '$all' => ['red', 'blank'] })
findObservable = collection.find(all("tags", "red", "blank"))
Consultar un arreglo para un elemento
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para consultar si el campo de la matriz contiene al menos un elemento con el valor especificado, construya un filtro utilizando el método Eq:
Builders<BsonDocument>.Filter.Eq(<field>, <value>)
<value> es el valor del elemento que debe coincidir.
Para consultar si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro eq( <field>, <value>) donde el valor es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro eq( <field>, <value>) donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro [ <field> => <value> ] donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field>: <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro { <field> => <value> } donde <value> es el valor del elemento.
Para realizar un query si el campo de arreglo contiene al menos un elemento con el valor especificado, usa el filtro equal( <field>, <value> ) donde <value> es el valor del elemento.
El siguiente ejemplo query para todos los documentos donde tags es un arreglo que contiene el string "red" como uno de sus elementos:
db.inventory.find( { tags: "red" } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ tags: "red" }
var filter = Builders<BsonDocument>.Filter.Eq("tags", "red"); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"tags", "red"}, })
findPublisher = collection.find(eq("tags", "red"));
findIterable = collection.find(eq("tags", "red"));
cursor = db.inventory.find({"tags": "red"})
const cursor = db.collection('inventory').find({ tags: 'red' });
$cursor = $db->inventory->find(['tags' => 'red']);
cursor = db.inventory.find({"tags": "red"})
client[:inventory].find(tags: 'red')
findObservable = collection.find(equal("tags", "red"))
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
var builder = Builders<BsonDocument>.Filter; builder.And(builder.Eq(<array field>, <value1>), builder.Lt(<array field>, <value2>));
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
Para especificar condiciones en los elementos del campo de arreglo, utiliza operadores del query en el documento de filtro de query. Por ejemplo:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
[ <array field> => [ <operator1> => <value1>, ... ] ]
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field> => { <operator1> => <value1>, ... } }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
and(gte(<array field>, <value1>), lt(<array field>, <value2>) ...)
Por ejemplo, la siguiente operación consulta todos los documentos donde el arreglo dim_cm contiene al menos un elemento cuyo valor es mayor que 25.
db.inventory.find( { dim_cm: { $gt: 25 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ dim_cm: { $gt: 25 } }
var filter = Builders<BsonDocument>.Filter.Gt("dim_cm", 25); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm", bson.D{ {"$gt", 25}, }}, })
findPublisher = collection.find(gt("dim_cm", 25));
findIterable = collection.find(gt("dim_cm", 25));
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})
const cursor = db.collection('inventory').find({ dim_cm: { $gt: 25 } });
$cursor = $db->inventory->find(['dim_cm' => ['$gt' => 25]]);
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})
client[:inventory].find(dim_cm: { '$gt' => 25 })
findObservable = collection.find(gt("dim_cm", 25))
Especifica múltiples condiciones para los elementos del arreglo
Al especificar condiciones compuestas en elementos de arreglo, puedes especificar el query de modo que un solo elemento de arreglo cumpla estas condiciones o cualquier combinación de elementos de arreglo cumpla las condiciones.
Consulta un arreglo con condiciones de filtro compuesto sobre los elementos del arreglo
El siguiente ejemplo consulta documentos donde el arreglo dim_cm contiene elementos que en alguna combinación satisfacen las condiciones del query; por ejemplo, un elemento puede satisfacer la condición de ser mayor que 15 y otro elemento puede satisfacer la condición de ser menor que 20, o un solo elemento puede satisfacer ambas condiciones:
db.inventory.find( { dim_cm: { $gt: 15, $lt: 20 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ dim_cm: { $gt: 15, $lt: 20 } }
var builder = Builders<BsonDocument>.Filter; var filter = builder.And(builder.Gt("dim_cm", 15), builder.Lt("dim_cm", 20)); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm", bson.D{ {"$gt", 15}, {"$lt", 20}, }}, })
findPublisher = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));
findIterable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)));
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})
const cursor = db.collection('inventory').find({ dim_cm: { $gt: 15, $lt: 20 } });
$cursor = $db->inventory->find([ 'dim_cm' => [ '$gt' => 15, '$lt' => 20, ], ]);
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})
client[:inventory].find(dim_cm: { '$gt' => 15, '$lt' => 20 })
findObservable = collection.find(and(gt("dim_cm", 15), lt("dim_cm", 20)))
Query para un elemento de arreglo que cumpla con varios criterios
Utilice el operador $elemMatch para especificar múltiples criterios en los elementos de un arreglo de manera que al menos un elemento del arreglo cumpla con todos los criterios especificados.
El siguiente ejemplo consulta documentos donde el arreglo dim_cm contiene al menos un elemento que es mayor que ($gt) 22 y menor que ($lt) 30:
db.inventory.find( { dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } }
var filter = Builders<BsonDocument>.Filter.ElemMatch<BsonValue>("dim_cm", new BsonDocument { { "$gt", 22 }, { "$lt", 30 } }); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm", bson.D{ {"$elemMatch", bson.D{ {"$gt", 22}, {"$lt", 30}, }}, }}, })
findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
findIterable = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})
const cursor = db.collection('inventory').find({ dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } } });
$cursor = $db->inventory->find([ 'dim_cm' => [ '$elemMatch' => [ '$gt' => 22, '$lt' => 30, ], ], ]);
cursor = db.inventory.find({"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})
client[:inventory].find(dim_cm: { '$elemMatch' => { '$gt' => 22, '$lt' => 30 } })
findObservable = collection.find(elemMatch("dim_cm", Document("$gt" -> 22, "$lt" -> 30)))
Query para un elemento por la posición del índice del arreglo
Utilizando la notación de puntos, puedes especificar condiciones de query para un elemento en un índice o posición particular del arreglo. El arreglo utiliza indexación de base cero.
Nota
Al realizar los query utilizando la notación de puntos, el campo y el campo anidado deben estar entre comillas.
El siguiente ejemplo del query para todos los documentos donde el segundo elemento del arreglo dim_cm es mayor que 25:
db.inventory.find( { "dim_cm.1": { $gt: 25 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ "dim_cm.1": { $gt: 25 } }
var filter = Builders<BsonDocument>.Filter.Gt("dim_cm.1", 25); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"dim_cm.1", bson.D{ {"$gt", 25}, }}, })
findPublisher = collection.find(elemMatch("dim_cm", Document.parse("{ $gt: 22, $lt: 30 }")));
findIterable = collection.find(gt("dim_cm.1", 25));
cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})
const cursor = db.collection('inventory').find({ 'dim_cm.1': { $gt: 25 } });
$cursor = $db->inventory->find(['dim_cm.1' => ['$gt' => 25]]);
cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})
client[:inventory].find('dim_cm.1' => { '$gt' => 25 })
findObservable = collection.find(gt("dim_cm.1", 25))
Consulta un arreglo por longitud de arreglo
Utiliza el $size operador para consultar arreglos por cantidad de elementos. Por ejemplo, lo siguiente selecciona documentos donde el arreglo tags tiene 3 elementos.
db.inventory.find( { "tags": { $size: 3 } } )
Copia el siguiente filtro en la barra de query de Compass y haz clic en Find:
{ "tags": { $size: 3 } }
var filter = Builders<BsonDocument>.Filter.Size("tags", 3); var result = collection.Find(filter).ToList();
cursor, err := coll.Find( context.TODO(), bson.D{ {"tags", bson.D{ {"$size", 3}, }}, })
findPublisher = collection.find(size("tags", 3));
findIterable = collection.find(size("tags", 3));
cursor = db.inventory.find({"tags": {"$size": 3}})
const cursor = db.collection('inventory').find({ tags: { $size: 3 } });
$cursor = $db->inventory->find(['tags' => ['$size' => 3]]);
cursor = db.inventory.find({"tags": {"$size": 3}})
client[:inventory].find(tags: { '$size' => 3 })
findObservable = collection.find(size("tags", 3))
Consulta un arreglo con MongoDB Atlas
El ejemplo en esta sección utiliza el conjunto de datos de películas 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 arreglo en MongoDB Atlas, sigue estos pasos:
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.
Especifica un documento de filtro de query.
Para consultar un documento que contiene un arreglo, especifique un documento de filtro de query. Un operadores del query utiliza un documento de filtro de query para especificar las condiciones de búsqueda. Utilice los siguientes documentos de ejemplo para query los campos de arreglo en la colección sample_mflix.movies.
Para aplicar un filtro de query, copiar un documento de ejemplo en la barra de búsqueda Filter y hacer clic en Apply.
Para especificar una condición de igualdad en un arreglo, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos. En el siguiente ejemplo, se encuentran documentos que tienen un campo genres que contiene el arreglo ["Action", "Comedy"] en el orden especificado:
{ genres: ["Action", "Comedy"] }
Para encontrar un arreglo que contenga tanto los elementos Action como Comedy, sin importar el orden u otros elementos en el arreglo, utiliza el operador $all:
{ genres: { $all: ["Action", "Comedy"] } }
Para realizar un query si el campo del arreglo contiene al menos un elemento con el valor especificado, utiliza el filtro { <field>: <value> } donde <value> es el valor del elemento.
En el siguiente ejemplo, se realiza un query por todos los documentos donde el campo genres contiene el string Short como uno de sus elementos:
{ genres: "Short" }
Para especificar condiciones sobre los elementos en el campo de arreglo, utiliza operadores del query en el documento de filtro de query:
{ <array field>: { <operator1>: <value1>, ... } }
Por ejemplo, la siguiente operación utiliza el operador $nin para realizar un query por todos los documentos donde el campo genres no contiene Drama.
{ genres: { $nin: ["Drama"] } }
Al especificar condiciones compuestas en elementos de arreglo, puedes especificar el query de modo que un solo elemento de arreglo cumpla estas condiciones o cualquier combinación de elementos de arreglo cumpla las condiciones.
Consulta un arreglo con condiciones de filtro compuesto sobre los elementos del arreglo
En el siguiente ejemplo, se realizan queries de documentos donde el arreglo cast contiene elementos que, en alguna combinación, satisfacen las condiciones del query. Por ejemplo, el siguiente filtro utiliza los operadores $regex y $eq para devolver documentos donde un solo elemento del arreglo termina en Olsen y otro elemento es igual a Mary-Kate Olsen o un solo elemento que satisface ambas condiciones:
{ cast: { $regex: "Olsen$", $eq: "Mary-Kate Olsen" } }
Este filtro de query devuelve películas que incluyen a Mary-Kate Olsen en su reparto, y películas que incluyen tanto a Mary-Kate Olsen como a Ashley Olsen en su reparto.
Query para un elemento de arreglo que cumpla con varios criterios
Utilice el operador $elemMatch para especificar múltiples criterios en los elementos de un arreglo de manera que al menos un elemento del arreglo cumpla con todos los criterios especificados.
El siguiente ejemplo utiliza los operadores $elemMatch y $ne para realizar un query en documentos donde el arreglo languages contiene al menos un elemento que no es null y no es igual a English.
{ languages: { $elemMatch: { $ne: null, $ne: "English" } } }
Query para un elemento por la posición del índice del arreglo
Utilizando la notación de puntos, puedes especificar condiciones de query para un elemento en un índice o posición particular del arreglo. El arreglo utiliza indexación de base cero.
Nota
Al realizar los query utilizando la notación de puntos, el campo y el campo anidado deben estar entre comillas.
En el siguiente ejemplo, se utiliza el operador $ne para realizar un query por todos los documentos donde el primer elemento en el arreglo countries no es igual a USA:
{ "countries.0": { $ne: "USA" }
Consulta un arreglo por longitud de arreglo
Utiliza el $size operador para consultar arreglos por cantidad de elementos. Por ejemplo, lo siguiente selecciona documentos donde el arreglo genres tiene 3 elementos.
{ genres: { $size: 3 } }
Tutoriales adicionales de query
Para obtener ejemplos adicionales de queries, consulte: