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.

Puede consultar documentos en MongoDB con los siguientes métodos:

  • El driver de su lenguaje de programación.

  • El Interfaz de usuario de MongoDB Atlas. Para obtener más información, consulte Consultar documentos 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 consulta 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 consulta utilizando el pymongo.asynchronous.collection.AsyncCollection.find método 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);
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, consulte Barra de consulta.

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

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

Para obtener más información, consulte Colección.Buscar.

Para obtener más información, consulte com.mongodb.reactivestreams.client.MongoCollection.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,find consulte.

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

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

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

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

Para obtener más información, consulte 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' => [ 'A', 'D' ]})
findObservable = collection.find(in("status", "A", "D"))

Nota

Aunque puede utilizar el operador para $or esta consulta, utilice el operador $in $or en lugar de cuando realice verificaciones 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

Utilice el operador para especificar una consulta compuesta que una cada cláusula con una $or conjunción OR lógica. La consulta selecciona los documentos que cumplen 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 consultas con operadores de comparación están sujetas a corchetes de tipos.

Especifique AND así como OR condiciones

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

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

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

1

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

  1. Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.

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

  3. En la barra lateral, haz clic en Clusters en la sección Database.

    La página de clústeres se muestra.

2

Navegue a la colección

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

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

  3. Seleccione la colección movies.

3

Especifique el Filter campo

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 consulta devuelve todos los documentos de la colección sample_mflix.movies donde el campo year coincide con 1924.

Tutoriales adicionales de query

Para obtener más ejemplos de consultas, consulte:

Comportamiento

Cursor

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

La Find operación abre un cursor hacia los documentos coincidentes de la colección según la consulta de búsqueda.

Para obtener más información sobre el muestreo, consulte 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 a conjuntos de réplicas y fragmentos de conjuntos de réplicas, la preocupación de lectura permite a los clientes elegir un nivel de aislamiento para sus lecturas. Para más información, consulte la preocupación de lectura.

Formato del resultado de la query

Al ejecutar una operación de búsqueda con un controlador MongoDB mongosh o, MongoDB devuelve un cursor que administra los resultados de la consulta. Estos no se devuelven como una matriz de documentos.

Para aprender a iterar documentos con un cursor, consulte la documentación de su controlador. Si mongosh usa, consulte Iterar un cursor mongosh en.

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

Especifique el primer número n 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 1 de.

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

También puede leer documentos de una colección con la $match etapa de canalización en una canalización de agregación. Para obtener más información, consulte los ejemplos de agregación de controladores asíncronos de Java.

También puede leer documentos de una colección con la $match etapa de canalización en una canalización de agregación. Para obtener más información, consulte los ejemplos de agregación de controladores síncronos de Java.

También puede leer documentos de una colección con la $match etapa de canalización en una canalización de agregación. Para obtener más información, consulte los ejemplos de la operación "Buscar" del controlador de corrutinas de Kotlin.

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

Nota

El métodopymongo.asynchronous.collection.AsyncCollection.find_onerealiza la misma operación quepymongo.asynchronous.collection.AsyncCollection.findcon 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 puede leer documentos de una colección con la $match etapa de canalización en una canalización de agregación. Para obtener más información, consulte los ejemplos de agregación.

También puede leer documentos de una colección con la $match etapa de canalización en una canalización de agregación. Para obtener más información, consulte el método de agregación.

Volver

Métodos

Next

Documentos incrustados

Obtén una insignia de habilidad

¡Domina "Query Optimization" gratis!

Más información

En esta página