Join us at MongoDB.local London on 7 May to unlock new possibilities for your data. Use WEB50 to save 50%.
Register now >
Docs Menu
Docs Home
/
Desarrollo
/
Operaciones CRUD
Docs Home
/
Desarrollo
/
Operaciones CRUD
Docs Home
/
Desarrollo
/
Operaciones CRUD

Documentos de query

Para consultar documentos, especifique un Predicado de consulta que indica qué documentos devolver. Un predicado de consulta vacío { } Devuelve todos los documentos de la colección.

Se pueden query documentos en MongoDB con los siguientes métodos:

  • El driver de su lenguaje de programación.

  • La Interfaz de usuario de MongoDB Atlas. Para saber más, consulta query 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 query utilizando el método db.collection.find() en mongosh.

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 contiene ejemplos de operaciones de query utilizando 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 query 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 utilizando el método MongoCollection.Find() en el Controlador de MongoDB para C#.

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 utilizando la función colección.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 query 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 query 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 query mediante el uso del método MongoCollection.find() en el controlador de corrutina de Kotlin de MongoDB.

Tip

El driver ofrece métodos asistentes com.mongodb.client.model.Filters para facilitar la creación de documentos de filtro. Los ejemplos en esta página utilizan estos métodos para crear los documentos de filtro.

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página proporciona ejemplos de operaciones de query usando el método pymongo.asynchronous.collection.AsyncCollection.find en la API 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 utilizando colección.find() método en el controlador de MongoDB Nodo.js.

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 contiene ejemplos de operaciones de query utilizando el método MongoDB\\Collection::find() en la Librería PHP de MongoDB.

Los ejemplos en esta página usan la colección inventory. Se debe realizar la conexión a una base de datos de prueba en la instancia de MongoDB y luego crear la colección inventory:

Esta página proporciona ejemplos de operaciones query 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 contiene ejemplos de operaciones de query utilizando el método Mongo::Collection#find() en el controlador Ruby 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 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, size: { h: 14, w: 21, uom: "cm" }, status: "A" },
   { item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" },
   { item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" },
   { item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" },
   { item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }
]);
[
    { "item": "journal", "qty": 25, "size": { "h": 14, "w": 21, "uom": "cm" }, "status": "A" },
    { "item": "notebook", "qty": 50, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "A" },
    { "item": "paper", "qty": 100, "size": { "h": 8.5, "w": 11, "uom": "in" }, "status": "D" },
    { "item": "planner", "qty": 75, "size": { "h": 22.85, "w": 30, "uom": "cm" }, "status": "D" },
    { "item": "postcard", "qty": 45, "size": { "h": 10, "w": 15.25, "uom": "cm" }, "status": "A" }
]

Para obtener instrucciones sobre cómo insertar documentos en MongoDB Compass, consulta Insertar documentos.

mongoc_collection_t *collection;
mongoc_bulk_operation_t *bulk;
bson_t *doc;
bool r;
bson_error_t error;
bson_t reply;
collection = mongoc_database_get_collection (db, "inventory");
bulk = mongoc_collection_create_bulk_operation_with_opts (collection, NULL);
doc = BCON_NEW (
   "item", BCON_UTF8 ("journal"),
   "qty", BCON_INT64 (25),
   "size", "{",
   "h", BCON_DOUBLE (14),
   "w", BCON_DOUBLE (21),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("notebook"),
   "qty", BCON_INT64 (50),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("paper"),
   "qty", BCON_INT64 (100),
   "size", "{",
   "h", BCON_DOUBLE (8.5),
   "w", BCON_DOUBLE (11),
   "uom", BCON_UTF8 ("in"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("planner"),
   "qty", BCON_INT64 (75),
   "size", "{",
   "h", BCON_DOUBLE (22.85),
   "w", BCON_DOUBLE (30),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("D"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
doc = BCON_NEW (
   "item", BCON_UTF8 ("postcard"),
   "qty", BCON_INT64 (45),
   "size", "{",
   "h", BCON_DOUBLE (10),
   "w", BCON_DOUBLE (15.25),
   "uom", BCON_UTF8 ("cm"),
   "}",
   "status", BCON_UTF8 ("A"));
r = mongoc_bulk_operation_insert_with_opts (bulk, doc, NULL, &error);
bson_destroy (doc);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
   goto done;
}
/* "reply" is initialized on success or error */
r = (bool) mongoc_bulk_operation_execute (bulk, &reply, &error);
if (!r) {
   MONGOC_ERROR ("%s\n", error.message);
}
var documents = new BsonDocument[]
{
    new BsonDocument
    {
        { "item", "journal" },
        { "qty", 25 },
        { "size", new BsonDocument { { "h", 14 }, { "w", 21 }, {  "uom", "cm"} } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "notebook" },
        { "qty", 50 },
        { "size", new BsonDocument { { "h",  8.5 }, { "w", 11 }, {  "uom", "in"} } },
        { "status", "A" }
    },
    new BsonDocument
    {
        { "item", "paper" },
        { "qty", 100 },
        { "size", new BsonDocument { { "h",  8.5 }, { "w", 11 }, {  "uom", "in"} } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "planner" },
        { "qty", 75 },
        { "size", new BsonDocument { { "h", 22.85 }, { "w", 30  }, {  "uom", "cm"} } },
        { "status", "D" }
    },
    new BsonDocument
    {
        { "item", "postcard" },
        { "qty", 45 },
        { "size", new BsonDocument { { "h", 10 }, { "w", 15.25 }, {  "uom", "cm"} } },
        { "status", "A" }
    },
};
collection.InsertMany(documents);
docs := []any{
	bson.D{
		{"item", "journal"},
		{"qty", 25},
		{"size", bson.D{
			{"h", 14},
			{"w", 21},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "notebook"},
		{"qty", 50},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "A"},
	},
	bson.D{
		{"item", "paper"},
		{"qty", 100},
		{"size", bson.D{
			{"h", 8.5},
			{"w", 11},
			{"uom", "in"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "planner"},
		{"qty", 75},
		{"size", bson.D{
			{"h", 22.85},
			{"w", 30},
			{"uom", "cm"},
		}},
		{"status", "D"},
	},
	bson.D{
		{"item", "postcard"},
		{"qty", 45},
		{"size", bson.D{
			{"h", 10},
			{"w", 15.25},
			{"uom", "cm"},
		}},
		{"status", "A"},
	},
}
result, err := coll.InsertMany(context.TODO(), docs)
Publisher<Success> insertManyPublisher = collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));
collection.insertMany(asList(
        Document.parse("{ item: 'journal', qty: 25, size: { h: 14, w: 21, uom: 'cm' }, status: 'A' }"),
        Document.parse("{ item: 'notebook', qty: 50, size: { h: 8.5, w: 11, uom: 'in' }, status: 'A' }"),
        Document.parse("{ item: 'paper', qty: 100, size: { h: 8.5, w: 11, uom: 'in' }, status: 'D' }"),
        Document.parse("{ item: 'planner', qty: 75, size: { h: 22.85, w: 30, uom: 'cm' }, status: 'D' }"),
        Document.parse("{ item: 'postcard', qty: 45, size: { h: 10, w: 15.25, uom: 'cm' }, status: 'A' }")
));
collection.insertMany(
    listOf(
        Document("item", "journal")
            .append("qty", 25)
            .append("size", Document("h", 14)
                .append("w", 21)
                .append("uom", "cm")
            )
            .append("status", "A"),
        Document("item", "notebook")
            .append("qty", 50)
            .append("size", Document("h", 8.5)
                .append("w", 11)
                .append("uom", "in")
            )
            .append("status", "A"),
        Document("item", "paper")
            .append("qty", 100)
            .append("size", Document("h", 8.5)
                .append("w", 11)
                .append("uom", "in")
            )
            .append("status", "D"),
        Document("item", "planner")
            .append("qty", 75)
            .append("size", Document("h", 22.85)
                .append("w", 30)
                .append("uom", "cm")
            )
            .append("status", "D"),
        Document("item", "postcard")
            .append("qty", 45)
            .append("size", Document("h", 10)
                .append("w", 15.25)
                .append("uom", "cm")
            )
            .append("status", "A"),
    )
)
await db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
    ]
)
await db.collection('inventory').insertMany([
  {
    item: 'journal',
    qty: 25,
    size: { h: 14, w: 21, uom: 'cm' },
    status: 'A'
  },
  {
    item: 'notebook',
    qty: 50,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'A'
  },
  {
    item: 'paper',
    qty: 100,
    size: { h: 8.5, w: 11, uom: 'in' },
    status: 'D'
  },
  {
    item: 'planner',
    qty: 75,
    size: { h: 22.85, w: 30, uom: 'cm' },
    status: 'D'
  },
  {
    item: 'postcard',
    qty: 45,
    size: { h: 10, w: 15.25, uom: 'cm' },
    status: 'A'
  }
]);
$insertManyResult = $db->inventory->insertMany([
    [
        'item' => 'journal',
        'qty' => 25,
        'size' => ['h' => 14, 'w' => 21, 'uom' => 'cm'],
        'status' => 'A',
    ],
    [
        'item' => 'notebook',
        'qty' => 50,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'A',
    ],
    [
        'item' => 'paper',
        'qty' => 100,
        'size' => ['h' => 8.5, 'w' => 11, 'uom' => 'in'],
        'status' => 'D',
    ],
    [
        'item' => 'planner',
        'qty' => 75,
        'size' => ['h' => 22.85, 'w' => 30, 'uom' => 'cm'],
        'status' => 'D',
    ],
    [
        'item' => 'postcard',
        'qty' => 45,
        'size' => ['h' => 10, 'w' => 15.25, 'uom' => 'cm'],
        'status' => 'A',
    ],
]);
db.inventory.insert_many(
    [
        {
            "item": "journal",
            "qty": 25,
            "size": {"h": 14, "w": 21, "uom": "cm"},
            "status": "A",
        },
        {
            "item": "notebook",
            "qty": 50,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "A",
        },
        {
            "item": "paper",
            "qty": 100,
            "size": {"h": 8.5, "w": 11, "uom": "in"},
            "status": "D",
        },
        {
            "item": "planner",
            "qty": 75,
            "size": {"h": 22.85, "w": 30, "uom": "cm"},
            "status": "D",
        },
        {
            "item": "postcard",
            "qty": 45,
            "size": {"h": 10, "w": 15.25, "uom": "cm"},
            "status": "A",
        },
    ]
)
client[:inventory].insert_many([ { item: 'journal',
                                   qty: 25,
                                   size: { h: 14, w: 21, uom: 'cm' },
                                   status: 'A' },
                                 { item: 'notebook',
                                   qty: 50,
                                   size: { h: 8.5, w: 11, uom: 'in' },
                                   status: 'A' },
                                 { item: 'paper',
                                   qty: 100,
                                   size: { h: 8.5, w: 11, uom: 'in' },
                                   status: 'D' },
                                 { item: 'planner',
                                   qty: 75,
                                   size: { h: 22.85, w: 30, uom: 'cm' },
                                   status: 'D' },
                                 { item: 'postcard',
                                   qty: 45,
                                   size: { h: 10, w: 15.25, uom: 'cm' },
                                   status: 'A' } ])
collection.insertMany(Seq(
  Document("""{ item: "journal", qty: 25, size: { h: 14, w: 21, uom: "cm" }, status: "A" }"""),
  Document("""{ item: "notebook", qty: 50, size: { h: 8.5, w: 11, uom: "in" }, status: "A" }"""),
  Document("""{ item: "paper", qty: 100, size: { h: 8.5, w: 11, uom: "in" }, status: "D" }"""),
  Document("""{ item: "planner", qty: 75, size: { h: 22.85, w: 30, uom: "cm" }, status: "D" }"""),
  Document("""{ item: "postcard", qty: 45, size: { h: 10, w: 15.25, uom: "cm" }, status: "A" }""")
)).execute()

Seleccione todos los documentos de una colección

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pase un documento vacío como parámetro de filtro de query a la barra de query. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

Para seleccionar todos los documentos de la colección, pasa un documento vacío como parámetro de filtro de query al método de búsqueda. El parámetro de filtro de query determina los criterios de selección:

db.inventory.find( {} )
Compass selecciona todos los documentos de la colección
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (NULL);
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);

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

var filter = Builders<BsonDocument>.Filter.Empty;
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{},
)
FindPublisher<Document> findPublisher = collection.find(new Document());
FindIterable<Document> findIterable = collection.find(new Document());
val flowInsertMany = collection
    .find(empty())
cursor = db.inventory.find({})
const cursor = db.collection('inventory').find({});
$cursor = $db->inventory->find([]);
cursor = db.inventory.find({})
client[:inventory].find({})
var findObservable = collection.find(Document())

Esta operación utiliza un predicado de query de {}, que corresponde a la siguiente instrucción SQL:

SELECT * FROM inventory

Para obtener más información, consulta find().

Para obtener más información, consulta Query Bar.

Para más información, consulte mongoc_collection_find_with_opts.

Para obtener más información, consulte Encontrar().

Para obtener más información, consulta colección.Find.

Para obtener más información, consulte com.mongodb.client.MongoCollection.find.

Para obtener más información, consulte MongoCollection.find().

Para obtener más información, consulte find.

Para obtener más información, consulta find().

Para obtener más información, consulta en find().

Para obtener más información, consulte find.

Para obtener más información, consulta find().

Para obtener más información, consulta collection.find().

Especifique la condición de igualdad

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, construya un filtro utilizando el método Eq:

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

Para especificar condiciones de igualdad, utilice el tipo bson.D para crear un documento de filtro:

filter := bson.D{{"<field>", <value>}}

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza el método Filtros.eq() para crear el documento de filtro de query:

and(eq(<field1>, <value1>), eq(<field2>, <value2>) ...)

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza expresiones <field>:<value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza expresiones <field> => <value> en el documento de filtro de query:

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

Para especificar condiciones de igualdad, utiliza el método com.mongodb.client.model.Filters.eq_ para crear el documento de filtro de query:

and(equal(<field1>, <value1>), equal(<field2>, <value2>) ...)

El siguiente ejemplo selecciona todos los documentos de la colección inventory donde status es igual a "D":

db.inventory.find( { status: "D" } )

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

{ status: "D" }

Nota

La barra de query de MongoDB Compass autocompleta la query actual según las claves de los documentos de la colección, incluidas las claves en los subdocumentos incrustados.

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

Esta operación utiliza un predicado de query de { status: "D" }, que corresponde a la siguiente instrucción SQL:

SELECT * FROM inventory WHERE status = "D"

Especifique condiciones utilizando operadores de query

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

El siguiente ejemplo recupera todos los documentos de la colección inventory donde status sea igual a "A" o "D":

db.inventory.find( { status: { $in: [ "A", "D" ] } } )

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

{ status: { $in: [ "A", "D" ] } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", "{",
   "$in", "[",
   BCON_UTF8 ("A"), BCON_UTF8 ("D"),
   "]",
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var filter = Builders<BsonDocument>.Filter.In("status", new[] { "A", "D" });
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{{"status", bson.D{{"$in", bson.A{"A", "D"}}}}})
findPublisher = collection.find(in("status", "A", "D"));
findIterable = collection.find(in("status", "A", "D"));
val findFlow = collection
    .find(`in`("status", "A", "D"))
cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})
const cursor = db.collection('inventory').find({
  status: { $in: ['A', 'D'] }
});
$cursor = $db->inventory->find(['status' => ['$in' => ['A', 'D']]]);
cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})
client[:inventory].find(status: { '$in' => %w[A D] })
findObservable = collection.find(in("status", "A", "D"))

Nota

Aunque puedas utilizar el operador $or para esta query, utiliza el operador $in en lugar de $or cuando realizas comprobaciones de igualdad en el mismo campo.

La operación utiliza un predicado de query de { status: { $in: [ "A", "D" ] } }, que corresponde a la siguiente instrucción SQL:

SELECT * FROM inventory WHERE status in ("A", "D")

Para obtener la lista completa de operadores del query de MongoDB, consulte Predicados de query.

Especifique AND condiciones

Una query compuesta puede especificar condiciones para más de un campo en los documentos de la colección. Implícitamente, una conjunción lógica AND conecta las cláusulas de una query compuesta de modo que la query selecciona los documentos de la colección que cumplen todas las condiciones.

El siguiente ejemplo recupera todos los documentos en la colección inventory donde status es igual a "A" y qty es menor que ($lt) 30:

db.inventory.find( { status: "A", qty: { $lt: 30 } } )

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

{ status: "A", qty: { $lt: 30 } }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", BCON_UTF8 ("A"),
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
		{"qty", bson.D{{"$lt", 30}}},
	})
findPublisher = collection.find(and(eq("status", "A"), lt("qty", 30)));
findIterable = collection.find(and(eq("status", "A"), lt("qty", 30)));
val findFlow = collection
    .find(and(eq("status", "A"), lt("qty", 30)))
cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})
const cursor = db.collection('inventory').find({
  status: 'A',
  qty: { $lt: 30 }
});
$cursor = $db->inventory->find([
    'status' => 'A',
    'qty' => ['$lt' => 30],
]);
cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})
client[:inventory].find(status: 'A', qty: { '$lt' => 30 })
findObservable = collection.find(and(equal("status", "A"), lt("qty", 30)))

La operación utiliza un predicado de query de { status: "A", qty: { $lt: 30 } }, que corresponde a la siguiente instrucción SQL:

SELECT * FROM inventory WHERE status = "A" AND qty < 30

Consulte operadores de comparación para otros operadores de comparación de MongoDB.

Especifique OR condiciones

Usa el operador $or para especificar una query compuesta que una cada cláusula con una conjunción lógica OR. La query selecciona los documentos que coinciden con al menos una condición.

El siguiente ejemplo recupera todos los documentos de la colección donde el status es igual a "A" o qty es menor que ($lt) 30:

db.inventory.find( { $or: [ { status: "A" }, { qty: { $lt: 30 } } ] } )

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

{ $or: [ { status: "A" }, { qty: { $lt: 30 } } ] }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "$or", "[",
   "{",
   "status", BCON_UTF8 ("A"),
   "}","{",
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}",
   "}",
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter;
var filter = builder.Or(builder.Eq("status", "A"), builder.Lt("qty", 30));
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{
			"$or",
			bson.A{
				bson.D{{"status", "A"}},
				bson.D{{"qty", bson.D{{"$lt", 30}}}},
			},
		},
	})
findPublisher = collection.find(or(eq("status", "A"), lt("qty", 30)));
findIterable = collection.find(or(eq("status", "A"), lt("qty", 30)));
val findFlow = collection
    .find(or(eq("status", "A"), lt("qty", 30)))
cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})
const cursor = db.collection('inventory').find({
  $or: [{ status: 'A' }, { qty: { $lt: 30 } }]
});
$cursor = $db->inventory->find([
    '$or' => [
        ['status' => 'A'],
        ['qty' => ['$lt' => 30]],
    ],
]);
cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})
client[:inventory].find('$or' => [ { status: 'A' },
                                   { qty: { '$lt' => 30 } } ])
findObservable = collection.find(or(equal("status", "A"), lt("qty", 30)))

La operación utiliza un predicado de query de { $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }, que corresponde a la siguiente instrucción SQL:

SELECT * FROM inventory WHERE status = "A" OR qty < 30

Nota

Las queries con operadores de comparación están sujetas a bracketing de tipos

Especifique AND, así como las condiciones OR

En el siguiente ejemplo, el documento de query compuesto selecciona todos los documentos de la colección donde status es igual a "A" y ya sea qty es menor que ($lt) 30 o item comienza con el carácter p:

db.inventory.find( {
     status: "A",
     $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ]
} )

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

{ status: "A", $or: [ { qty: { $lt: 30 } }, { item: /^p/ } ] }
mongoc_collection_t *collection;
bson_t *filter;
mongoc_cursor_t *cursor;
collection = mongoc_database_get_collection (db, "inventory");
filter = BCON_NEW (
   "status", BCON_UTF8 ("A"),
   "$or", "[",
   "{",
   "qty", "{",
   "$lt", BCON_INT64 (30),
   "}",
   "}","{",
   "item", BCON_REGEX ("^p", ""),
   "}",
   "]");
cursor = mongoc_collection_find_with_opts (collection, filter, NULL, NULL);
var builder = Builders<BsonDocument>.Filter;
var filter = builder.And(
    builder.Eq("status", "A"),
    builder.Or(builder.Lt("qty", 30), builder.Regex("item", new BsonRegularExpression("^p"))));
var result = collection.Find(filter).ToList();
cursor, err := coll.Find(
	context.TODO(),
	bson.D{
		{"status", "A"},
		{"$or", bson.A{
			bson.D{{"qty", bson.D{{"$lt", 30}}}},
			bson.D{{"item", bson.Regex{Pattern: "^p", Options: ""}}},
		}},
	})
findPublisher = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);
findIterable = collection.find(
        and(eq("status", "A"),
                or(lt("qty", 30), regex("item", "^p")))
);
val findFlow = collection
    .find(
        and(eq("status", "A"),
            or(lt("qty", 30), regex("item", "^p")))
    )
cursor = db.inventory.find(
    {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]}
)
const cursor = db.collection('inventory').find({
  status: 'A',
  $or: [{ qty: { $lt: 30 } }, { item: { $regex: '^p' } }]
});
$cursor = $db->inventory->find([
    'status' => 'A',
    '$or' => [
        ['qty' => ['$lt' => 30]],
        // Alternatively: ['item' => new \MongoDB\BSON\Regex('^p')]
        ['item' => ['$regex' => '^p']],
    ],
]);
cursor = db.inventory.find(
    {"status": "A", "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]}
)
client[:inventory].find(status: 'A',
                        '$or' => [ { qty: { '$lt' => 30 } },
                                   { item: { '$regex' => BSON::Regexp::Raw.new('^p') } } ])
findObservable = collection.find(and(
  equal("status", "A"),
  or(lt("qty", 30), regex("item", "^p")))
)

La operación utiliza un predicado de query de:

{
   status: 'A',
   $or: [
     { qty: { $lt: 30 } }, { item: { $regex: '^p' } }
   ]
}

que corresponde a la siguiente instrucción SQL:

SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")

Nota

MongoDB admite queries con expresiones regulares $regex para realizar coincidencias de patrón de string.

Query documentos con MongoDB Atlas

En este ejemplo se utiliza el conjunto de datos de películas de muestra. Para cargar el conjunto de datos de muestra en tu implementación de MongoDB Atlas, consulta Cargar datos de muestra.

Para proyectar campos para una query en MongoDB Atlas, siga estos pasos:

1

En la interfaz de usuario de MongoDB Atlas, ve a la página Clusters de tu 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_mflix.

  3. Seleccione la colección movies.

3

Especifica el campo Filter

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:

{ year: 1924 }
4

Haga clic Apply

La query devuelve todos los documentos de la colección sample_mflix.movies donde el campo year coincide con 1924.

Tutoriales adicionales de query

Para más ejemplos de consultas, vea:

Comportamiento

Cursor

El método db.collection.find() devuelve un cursor a los documentos coincidentes.

La Find operación abre un cursor a los documentos coincidentes de la colección basados en la consulta query.

Para obtener más información sobre el muestreo, consulta las Preguntas frecuentes de Compass.

El método mongoc_collection_find_with_opts devuelve un cursor a los documentos coincidentes.

El método MongoCollection.Find() devuelve un cursor a los documentos coincidentes. Consulta la documentación del controlador C# de MongoDB para iterar sobre un cursor.

La función Collection.Find arroja un cursor a los documentos coincidentes. Consulta la documentación del cursor para obtener más información.

El método com.mongodb.cliente.MongoCollection.find devuelve una instancia de la interfaz com.mongodb.cliente.FindIterable.

El método MongoCollection.find() devuelve una instancia de la clase FindFlow.

El método colección.find() devuelve un cursor.

El método MongoDB\\Collection::find() devuelve un cursor a los documentos coincidentes. Consulta la documentación de la Librería PHP de MongoDB para iterar sobre un cursor.

El método pymongo.collection.Collection.find devuelve un cursor a los documentos coincidentes. Consulta la documentación de PyMongo para iterar sobre un cursor.

El método Mongo::Collection#find() devuelve un CollectionView, que es un Enumerable. Se crea un cursor cuando se enumera la View; por ejemplo, al llamar a #to_a() o #each(). También puedes obtener un Enumerator si llamas a #to_enum() en la View. Consulta la documentación de la API del controlador Ruby para iterar sobre un cursor.

El método collection.find() devuelve el Observable de búsqueda.

Actualizaciones concurrentes mientras se utiliza un cursor

A medida que un cursor devuelve documentos, otras operaciones pueden ejecutarse en segundo plano y afectar los resultados, dependiendo del nivel de consistencia de lectura. Para más detalles, consulte Aislamiento de lectura, coherencia y actualidad.

Aislamiento de lectura

Para las lecturas en sets de réplicas y particiones de sets de réplicas, el nivel de consistencia de lectura permite a los clientes elegir un nivel de aislamiento para sus lecturas. Para obtener más información, consulte nivel de consistencia de lectura.

Formato del resultado de la query

Cuando ejecutas una operación de búsqueda con un driver de MongoDB o mongosh, MongoDB devuelve un cursor que gestiona los resultados de la query. Los resultados de la query no se devuelven como un arreglo de documentos.

Para aprender a iterar a través de documentos en un cursor, consulta la documentación de tu driver. Si utilizas mongosh, consulta Itera un cursor en mongosh.

Métodos y Opciones Adicionales

También puedes leer documentos de una colección con:

Nota

El métododb.collection.findOne()realiza la misma operación quedb.collection.find()con un límite de 1.

MongoDB Compass también acepta las siguientes opciones de barra de consulta:

Proyecto

Especifica qué campos se deben devolver en los datos resultantes.

Sort

Especifique el orden de clasificación de los documentos devueltos.

Omitir

Especifica el primer n-número de documentos que se deben omitir antes de devolver el conjunto de resultados.

Limit

Especifica la cantidad máxima de documentos a devolver.

También puedes leer documentos de una colección con:

También puedes leer documentos de una colección con:

Nota

El método MongoCollection.FindOne() realiza la misma operación que MongoCollection.Find(), con un límite de 1.

También puedes leer documentos de una colección con:

También puedes leer documentos de una colección con la etapa del pipeline $match en un pipeline de agregación. Para obtener más información, consulta los Ejemplos de agregación del controlador asincrónico de Java.

También puedes leer documentos de una colección con la etapa de $match dentro de una pipeline de agregación. Para obtener más información, consulta Ejemplos de agregación síncrona de Java Driver.

También puedes leer documentos de una colección con la etapa de $match dentro de una pipeline de agregación. Para obtener más información, consulta los ejemplos de la operación Find del controlador de corutinas de Kotlin.

También puedes leer documentos de una colección con:

Nota

El método pymongo.asynchronous.collection.AsyncCollection.find_one realiza la misma operación que pymongo.asynchronous.collection.AsyncCollection.find con un límite de 1.

También puedes leer documentos de una colección con:

Nota

El método Collection.findOne() realiza la misma operación que Collection.find() con un límite 1 de.

También puedes leer documentos de una colección con:

Nota

El métodoMongoDB\\Collection::findOne()realiza la misma operación queMongoDB\\Collection::find()con un límite de 1.

También puedes leer documentos de una colección con:

Nota

El método pymongo.collection.Collection.find_one realiza la misma operación que el método pymongo.collection.Collection.find con un límite de 1.

También puedes leer documentos de una colección con la etapa del pipeline $match en un pipeline de agregación. Para obtener más información, consulta los ejemplos de agregación.

También puedes leer documentos de una colección con la etapa del pipeline $match en un pipeline de agregación. Para más información, consulta el método de agregación.

Volver

Insert

Next

Documentos incrustados

Obtén una insignia de habilidad

¡Domina "Query Optimization" gratis!

Más información

En esta página