Docs Menu

/

Manual de base de datos

/

Operaciones CRUD

/

Manual de base de datos

/

Operaciones CRUD

/

Manual de base de datos

/

Operaciones CRUD

Documentos de query

Esta versión de la documentación está archivada y ya no recibe soporte. Para actualizar su implementación 6.0, consulte Procedimientos de actualización de MongoDB.7.0

Puede query documentos en MongoDB utilizando los siguientes métodos:

El driver de su lenguaje de programación.
La Interfaz de Usuario de MongoDB Atlas. Para aprender más, consulta Query de documentos con MongoDB Atlas.
MongoDB Compass.

➤ Use el menú desplegable Seleccionar su lenguaje en la parte superior derecha para establecer el lenguaje de los siguientes ejemplos o seleccione MongoDB Compass.

Esta página proporciona ejemplos de operaciones de consulta utilizando el db.collection.find()Método mongosh en.

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

Esta página 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 MongoCollection.Find()método en el controlador C# de MongoDB.

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

Esta página proporciona ejemplos de operaciones de query 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 utilizando el método motor.motor_asyncio.AsyncIOMotorCollection.find en el controlador Motor.

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

Esta página proporciona ejemplos de operaciones de query 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.

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' }")
));

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 consulta a la barra de consulta. El parámetro de filtro de consulta 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 filtro de {}, que corresponde a la siguiente declaración SQL:

SELECT * FROM inventory

Para obtener más información sobre la sintaxis del método, consulta find().

Para obtener más información sobre la barra de query de MongoDB Compass, consulta Barra de query.

Para obtener más información sobre la sintaxis del método, consulte Find().

Para obtener más información sobre la sintaxis del método, consulta com.mongodb.reactivestreams.client.MongoCollection.find.

Para obtener más información sobre la sintaxis del método, consulta com.mongodb.cliente.MongoCollection.find.

Para ver las opciones compatibles para el método find(), consulta find().

Para obtener más información sobre la sintaxis del método, consulta find().

Para obtener más información sobre la sintaxis del método, consulta find.

Para obtener más información sobre la sintaxis del método, consulta find().

Para obtener más información sobre la sintaxis del método, consulta colección.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, construya un filtro utilizando el método Eq:

Builders<BsonDocument>.Filter.Eq(<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 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 de la colección inventory todos los documentos 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" }

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"));

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 filtro de { status: "D" }, que corresponde a la siguiente declaración SQL:

SELECT * FROM inventory WHERE 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.

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

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

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" ] } }

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"));

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 expresar esta query utilizando el operador $or, utilice el operador $in en lugar del operador $or cuando realice comprobaciones de igualdad en el mismo campo.

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

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

Consulte el documento Operadores de consulta y proyección para obtener la lista completa de operadores de consulta de MongoDB.

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 } }

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)));

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 filtro de { status: "A", qty: { $lt: 30 } }, que corresponde a la siguiente declaració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

Usando el operador $or, puede especificar una query compuesta que une cada cláusula con una conjunción OR lógica para que la query seleccione los documentos en la colección que coincidan 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 } } ] }

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)));

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 filtro de { $or: [ { status: 'A' }, { qty: { $lt: 30 } } ] }, que corresponde a la siguiente declaración SQL:

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

Nota

Las queries que utilizan operadores de comparación están sujetas a bracketing 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/ } ] }

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")))
);

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 filtro 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

El ejemplo en esta sección utiliza el conjunto de datos de películas de muestra. Para aprender a cargar el conjunto de datos de muestra en la implementación de MongoDB Atlas, se debe consultar Cargar datos de muestra.

Para proyectar los campos que se devolverán de una query en MongoDB Atlas, siga estos pasos:

1

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

Si aún no se muestra, seleccione la organización que contiene su proyecto deseado en el menú Organizations de la barra de navegación.
Si aún no se muestra, seleccione su proyecto en el menú Projects de la barra de navegación.
En la barra lateral, haz clic en Clusters en la sección Database.
La página de clústeres se muestra.

2

Navegue a la colección

Para el clúster que contiene los datos de muestra, haz clic en Browse Collections.
En el panel de navegación izquierdo, seleccione la base de datos sample_mflix.
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

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

Tutoriales adicionales de query

Para obtener ejemplos adicionales de queries, consulte:

Comportamiento

Cursor

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

La operación de MongoDB Compass Find abre un cursor a los documentos coincidentes de la colección en función de la query de búsqueda.

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

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.

com.mongodb.reactivestreams.client.MongoCollection.find devuelve una instancia de la interfaz com.mongodb.reactivestreams.cliente.FindPublisher.

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

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ónde lectura.

Formato del resultado de la query

Cuando ejecuta una operación de búsqueda con un driver de MongoDB o mongosh, el comando 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 cómo iterar a través de documentos en un cursor, consulte la documentación de su driver. Si está utilizando mongosh, consulte Iterar un cursor en mongosh.

Métodos y Opciones Adicionales

Los siguientes métodos también pueden leer documentos de una colección:

db.collection.findOne()
En la canalización de agregación, la $match etapa de canalización proporciona acceso a las consultas de MongoDB.

Nota

El método también realiza una operación de db.collection.findOne() lectura para devolver un solo documento. Internamente, el método db.collection.findOne() db.collection.find() es el 1método con un límite de.

Además de filter, MongoDB Compass también permite que se pasen las siguientes opciones a la barra de consultas:

Proyecto	Especifica qué campos se deben devolver en los datos resultantes.
Sort	Especifique el orden de clasificación de los documentos devueltos.
Omitir	Especifica la cantidad n de documentos que se deben omitir antes de devolver el conjunto de resultados.
Limit	Especifica la cantidad máxima de documentos a devolver.

Los siguientes métodos también pueden leer documentos de una colección:

MongoCollection.FindOne()
En canalización de agregación, la etapa de pipeline$match proporciona acceso a queries de MongoDB. Consulte la documentación LINQ del driver C# de MongoDB.

Nota

El método MongoCollection.FindOne() también realiza una operación de lectura para devolver un solo documento. Internamente, el método MongoCollection.FindOne() es el método MongoCollection.Find() con un límite 1 de.

Los siguientes métodos también pueden leer documentos de una colección:

Collection.FindOne
En pipeline de agregación, la etapa de pipeline$match proporciona acceso a las query de MongoDB. Consulta Colección.Aggregate.

Los siguientes métodos también pueden leer documentos de una colección:

En la canalización de agregación, la etapa proporciona acceso a $match las consultas de MongoDB. Consulte com.mongodb.reactivestreams.client.MongoCollection.aggregate para obtener más información.

Los siguientes métodos también pueden leer documentos de una colección:

En la pipeline de agregación, la etapa de pipeline $match proporciona acceso a los query de MongoDB. Consulta los Ejemplos de agregación del controlador síncrono de Java.

Los siguientes métodos también pueden leer documentos de una colección:

Collection.findOne()
En pipeline de agregación, la etapa $match de la pipeline proporciona acceso a las query de MongoDB. Consulte el tutorial de agregación del controlador MongoDB Node.js

Nota

El método Collection.findOne() también realiza una operación de lectura para devolver un documento único. Internamente, el colección.findOne() el método es colección.find() método con un límite de 1.

Los siguientes métodos también pueden leer documentos de una colección:

MongoDB\\Collection::findOne()
En la pipeline de agregación, la etapa de pipeline$match ofrece acceso a las queries de MongoDB. Consulta el ejemplo de agregación de la librería de MongoDB PHP.

Nota

El método también realiza una operación de MongoDB\\Collection::findOne() lectura para devolver un solo documento. Internamente, el método MongoDB\\Collection::findOne() MongoDB\\Collection::find() es el 1método con un límite de.

Los siguientes métodos también pueden leer documentos de una colección:

pymongo.collection.Collection.find_one
En la canalización de agregación, la etapa proporciona acceso a las consultas de MongoDB. Consulte los $match ejemplos de agregación de PyMongo.

Nota

El método pymongo.collection.Collection.find_one también realiza una operación de lectura para devolver un solo documento. Internamente, el método pymongo.collection.Collection.find_one es el método pymongo.collection.Collection.find con un límite de 1.

Los siguientes métodos también pueden leer documentos de una colección:

En la pipeline de agregación, la etapa de pipeline$match ofrece acceso a las queries de MongoDB. Consulta los ejemplos de agregación del controlador Ruby de MongoDB.

Los siguientes métodos también pueden leer documentos de una colección:

En pipeline de agregación, la etapa $match de la pipeline proporciona acceso a los query de MongoDB. Consulta el método de agregación del controlador MongoDB Scala.

Volver

Métodos

Next

Documentos incrustados

Obtén una insignia de habilidad

¡Domina "Query Optimization" gratis!

Más información

Seleccionar el lenguaje

Califique esta página