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

Consultar un arreglo

Puedes consultar arreglos 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 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 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 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 campos de arreglo 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 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 arreglos utilizando el método MongoCollection.find() en el controlador de corrutinas 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 campos de matriz 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 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.

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),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
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),
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
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),
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"), BCON_UTF8 ("plain"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (14), BCON_INT64 (21),
   "]");
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),
   "tags", "[",
   BCON_UTF8 ("blank"), BCON_UTF8 ("red"),
   "]",
   "dim_cm", "[",
   BCON_DOUBLE (22.85), BCON_INT64 (30),
   "]");
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),
   "tags", "[",
   BCON_UTF8 ("blue"),
   "]",
   "dim_cm", "[",
   BCON_INT64 (10), BCON_DOUBLE (15.25),
   "]");
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 },
        { "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 ] }")
));
collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("tags", listOf("blank", "red"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "notebook")
            .append("qty", 50)
            .append("tags", listOf("red", "blank"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "paper")
            .append("qty", 100)
            .append("tags", listOf("red", "blank", "plain"))
            .append("dim_cm", listOf(14, 21)),
        Document("item", "planner")
            .append("qty", 75)
            .append("tags", listOf("blank", "red"))
            .append("dim_cm", listOf(22.85, 30)),
        Document("item", "postcard")
            .append("qty", 45)
            .append("tags", listOf("blue"))
            .append("dim_cm", listOf(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, utiliza el documento de query { <field>: <value> } donde <value> es el arreglo exacto que debe coincidir, incluido el orden de los elementos.

Para especificar una condición de igualdad en un arreglo, construye un filtro utilizando el método Eq, en el que <value> es el arreglo exacto a coincidir, incluyendo el orden de los elementos:

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

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

El siguiente ejemplo consulta todos los documentos donde tags es una matriz 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"] }
Consulta el arreglo que coincida exactamente
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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")));
FindIterable<Document> findIterable = collection.find(eq("tags", asList("red", "blank")));
val findFlow = collection
    .find(eq("tags", listOf("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")))

Para encontrar una matriz que contenga "red" y "blank" independientemente del orden u otros elementos en la matriz, utilice el $all operador:

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"] } }
Query de arreglo que cumpla con todos los criterios
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "{",
   "$all", "[",
   BCON_UTF8 ("red"), BCON_UTF8 ("blank"),
   "]",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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")));
val findFlow = collection
    .find(all("tags", listOf("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 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 hacer una query si el campo de arreglo contiene al menos un elemento con el valor especificado, construye un filtro utilizando el método Eq, en el que <value> es el valor del elemento a coincidir:

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

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 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 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 consulta todos los documentos donde la matriz tags contiene la cadena "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" }
Query de arreglo que coincide con múltiples criterios
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW ("tags", BCON_UTF8 ("red"));
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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"));
val findFlow = 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 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:

filter := bson.D{
    {"$and", bson.A{
        bson.D{{<array field>, bson.D{{"$eq", <value1>}}}},
        bson.D{{<array field>, bson.D{{"$lt", <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 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>) ...)

El siguiente ejemplo consulta todos los documentos donde la matriz 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 } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$gt", BCON_INT64 (25),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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));
val findFlow = 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

Cuando especifica condiciones compuestas en elementos de una matriz, puede consultar documentos donde:

  • Un solo elemento de la matriz cumple todas las condiciones especificadas

  • Los diferentes elementos de la matriz cumplen colectivamente todas las condiciones, y cada elemento satisface una o más condiciones.

Consulta un arreglo con condiciones de filtro compuesto sobre los elementos del arreglo

El siguiente ejemplo busca documentos donde la matriz dim_cm contiene elementos que, en alguna combinación, satisfacen las condiciones de la consulta. Un elemento puede cumplir la condición mayor que 15 y otro, la menor que 20, o un solo elemento puede cumplir ambas:

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 } }
Consulta un arreglo usando un filtro compuesto
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$gt", BCON_INT64 (15),
   "$lt", BCON_INT64 (20),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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)));
val findFlow = 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 $elemMatch operador para especificar múltiples criterios en los elementos de la matriz de modo que al menos un elemento de la matriz satisfaga 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 } } }
Query de arreglo por múltiples condiciones
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm", "{",
   "$elemMatch", "{",
   "$gt", BCON_INT64 (22),
   "$lt", BCON_INT64 (30),
   "}",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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 }")));
val findFlow = 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

Utilice la notación de puntos para especificar las condiciones de consulta de un elemento en un índice o posición específicos del array. El array utiliza indexación basada en cero.

Nota

Cuando se realiza una consulta 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 } }
Consulta arreglo por índice
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "dim_cm.1", "{",
   "$gt", BCON_INT64 (25),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
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));
val findFlow = 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

Utilice el operador para consultar matrices por número de elementos. El siguiente ejemplo selecciona documentos $size donde 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 } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "tags", "{",
   "$size", BCON_INT64 (3),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

var filter = Builders<BsonDocument>.Filter.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));
val findFlow = 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:

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

Navega 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_mflix.

  3. Seleccione la colección movies.

3

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 una matriz, utilice la consulta "documento { <field>: <value> } ", donde <value> es la matriz exacta que se busca, incluyendo el orden de los elementos. El siguiente ejemplo busca documentos donde genres contiene la matriz ["Action", "Comedy"] en el orden especificado:

{ genres: ["Action", "Comedy"] }

Para encontrar una matriz que contenga Action y Comedy independientemente del orden u otros elementos en la matriz, utilice el $all operador:

{ 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>, ... } }

El siguiente ejemplo utiliza el operador para consultar todos los documentos donde $nin el genres campo no Drama contiene:

{ genres: { $nin: ["Drama"] } }

Cuando especifica condiciones compuestas en elementos de una matriz, puede consultar un solo elemento de la matriz que cumpla todas las condiciones o cualquier combinación de elementos de la matriz que juntos cumplan las condiciones.

Consulta un arreglo con condiciones de filtro compuesto sobre los elementos del arreglo

El siguiente ejemplo busca documentos donde la cast matriz contiene elementos que, en alguna combinación, cumplen las condiciones de la consulta. El siguiente filtro utiliza los $regex operadores y para devolver documentos donde un elemento de la matriz termina en $eq Olsen y ​​otro elemento es igual a,Mary-Kate Olsen o un elemento que cumple 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 $elemMatch operador para especificar múltiples criterios en los elementos de la matriz de modo que al menos un elemento de la matriz satisfaga todos los criterios especificados.

El siguiente ejemplo utiliza los $elemMatch operadores y para consultar documentos donde $ne languages contiene al menos un elemento que no es null ni es igual English a:

{ languages: { $elemMatch: { $ne: null, $ne: "English" } } }

Query para un elemento por la posición del índice del arreglo

Utilice la notación de puntos para especificar las condiciones de consulta de un elemento en un índice o posición específicos del array. El array utiliza indexación basada en cero.

Nota

Cuando se realiza una consulta 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

Utilice el operador para consultar matrices por número de elementos. El siguiente ejemplo selecciona documentos $size donde genres tiene 3 elementos:

{ genres: { $size: 3 } }

Tutoriales adicionales de query

Para obtener ejemplos adicionales de queries, consulte:

Volver

Documentos incrustados

Next

Arreglos de documentos incrustados

En esta página