/ /

Operaciones CRUD

Lea

Docs Home

Librerías de clientes

Fundamentals

Operaciones CRUD

Lea

Retrieve Data

Overview

En esta guía, puedes aprender cómo recuperar datos de tus colecciones de MongoDB utilizando operaciones de lectura.

Las operaciones de lectura le permiten realizar lo siguiente:

Recupera documentos de tus colecciones utilizando operaciones de búsqueda
Realice transformaciones en documentos de sus colecciones usando operaciones de agregación

Datos de muestra

Los ejemplos en esta guía usan la siguiente estructura Tea como modelo para documentos en la colección tea:

type Tea struct {
	Item        string    `bson:"item,omitempty"`
	Rating      int32     `bson:"rating,omitempty"`
	DateOrdered time.Time `bson:"date_ordered,omitempty"`
}

Para ejecutar los ejemplos de esta guía, cargue estos documentos en la colección tea de la base de datos db utilizando el siguiente snippet:

coll := client.Database("db").Collection("tea")
docs := []interface{}{
	Tea{Item: "Masala", Rating: 10, DateOrdered: time.Date(2009, 11, 17, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Sencha", Rating: 7, DateOrdered: time.Date(2009, 11, 18, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Masala", Rating: 9, DateOrdered: time.Date(2009, 11, 12, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Masala", Rating: 8, DateOrdered: time.Date(2009, 12, 1, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Sencha", Rating: 10, DateOrdered: time.Date(2009, 12, 17, 0, 0, 0, 0, time.Local)},
	Tea{Item: "Hibiscus", Rating: 4, DateOrdered: time.Date(2009, 12, 18, 0, 0, 0, 0, time.Local)},
}
result, err := coll.InsertMany(context.TODO(), docs)

Tip

Bases de datos y colecciones inexistentes

Si la base de datos y la colección necesarias no existen cuando realizas una operación de guardar, el servidor las crea implícitamente.

Cada documento describe la variedad de té que un cliente solicitó, su calificación y la fecha del pedido. Estas descripciones corresponden a los campos item, rating y date_ordered.

Operaciones de búsqueda

Utiliza operaciones de búsqueda para recuperar datos de MongoDB. Las operaciones de búsqueda constan de los métodos Find() y FindOne().

Encuentre todos los documentos

El método Find() espera que proporciones un tipo Context y un filtro de query. El método devuelve todos los documentos que coincidan con el filtro como un tipo Cursor.

Para ver un ejemplo que usa el método Find(), consulta la sección Ejemplo de búsqueda de esta página. Para aprender cómo acceder a los datos utilizando un cursor, consulta la guía Acceder a datos desde un cursor.

Encuentre un documento

El método FindOne() espera que se pase un tipo Context y un filtro de query. El método devuelve el primer documento que coincide con el filtro como un tipo SingleResult.

Para un ejemplo que usa el método FindOne(), consulta la sección Ejemplo de búsqueda única de esta página. Para un ejemplo que usa FindOne() y consultas usando un valor ObjectId específico, consulta la sección Ejemplo de encontrar uno por ObjectId de esta página.

Para aprender cómo acceder a datos de un tipo SingleResult, consulta Deserialización en la guía de BSON.

Modificar comportamiento

Puedes modificar el comportamiento de Find() y FindOne() pasando un FindOptions y un FindOneOptions tipo respectivamente. Si no especificas ninguna opción, el driver usará los valores por defecto para cada opción.

Puedes configurar las opciones de uso común en ambos tipos con los siguientes métodos:

Método	Descripción
`SetCollation()`	El tipo de intercalación de lenguaje que se debe usar al clasificar los resultados. Por defecto: `nil`
`SetLimit()`	El número máximo de documentos para devolver. Por defecto: `0` Esta opción no está disponible para `FindOneOptions`. El método `FindOne()` utiliza internamente `SetLimit(-1)`.
`SetProjection()`	Los campos a incluir en los documentos devueltos. Por defecto: `nil`
`SetSkip()`	El número de documentos que se deben omitir. Por defecto: `0`
`SetSort()`	El campo y el tipo de ordenación para ordenar los documentos coincidentes. Puede especificar una ordenación ascendente o descendente. Por defecto: ninguno

Buscar ejemplo

El siguiente ejemplo pasa un contexto, un filtro y FindOptions al método Find(), que realiza las siguientes acciones:

Coincide con los documentos donde el valor rating está entre 5 y 9 (exclusivo)
Ordena los documentos coincidentes en orden ascendente por date_ordered

filter := bson.D{
	{"$and",
		bson.A{
			bson.D{{"rating", bson.D{{"$gt", 5}}}},
			bson.D{{"rating", bson.D{{"$lt", 9}}}},
		}},
}
sort := bson.D{{"date_ordered", 1}}
opts := options.Find().SetSort(sort)
// Retrieves documents that match the filter and prints them as structs
cursor, err := coll.Find(context.TODO(), filter, opts)
if err != nil {
	panic(err)
}
var results []Tea
if err = cursor.All(context.TODO(), &results); err != nil {
	panic(err)
}
for _, result := range results {
	res, _ := bson.MarshalExtJSON(result, false, false)
	fmt.Println(string(res))
}

{"item":"Sencha","rating":7,"date_ordered":"2009-11-18T05:00:00Z"}
{"item":"Masala","rating":8,"date_ordered":"2009-12-01T05:00:00Z"}

Encuentra un ejemplo

El siguiente ejemplo pasa un contexto, un filtro y FindOneOptions al método FindOne(), que realiza las siguientes acciones:

Coincide con los documentos donde el valor de date_ordered es igual o anterior al 30 de noviembre de 2009
Omite los dos primeros documentos que coinciden

filter := bson.D{{"date_ordered", bson.D{{"$lte", time.Date(2009, 11, 30, 0, 0, 0, 0, time.Local)}}}}
opts := options.FindOne().SetSkip(2)
// Retrieves a document that matches the filter and prints it as
// a struct
var result Tea
err := coll.FindOne(context.TODO(), filter, opts).Decode(&result)
if err != nil {
	if err == mongo.ErrNoDocuments {
		fmt.Println("No documents found")
	} else {
		panic(err)
	}
}
res, _ := bson.MarshalExtJSON(result, false, false)
fmt.Println(string(res))

{"item":"Masala","rating":9,"date_ordered":"2009-11-12T05:00:00Z"}

Encuentra uno por ObjectId Ejemplo

Este ejemplo define una variable id con un valor de tipo ObjectId y utiliza id para especificar un filtro de query. El filtro hace coincidir un documento con un valor de campo _id que corresponde a la variable id. Este ejemplo query el siguiente documento según su valor _id:

 {
     _id: ObjectId('65170b42b99efdd0b07d42de'),
     item: "Hibiscus",
     rating : 4,
     date_ordered : 2009-12-18T05:00:00.000+00:00
 }

El siguiente código pasa el filtro y una instancia de FindOneOptions como parámetros al método FindOne() para realizar las siguientes acciones:

Haz coincidir el documento con el valor ObjectId especificado
Proyecte solo los campos Item y Rating del documento coincidente

id, err := primitive.ObjectIDFromHex("65170b42b99efdd0b07d42de")
if err != nil {
	panic(err)
}
//  Creates a filter to match a document that has the specified
//  "_id" value
filter := bson.D{{"_id", id}}
opts := options.FindOne().SetProjection(bson.D{{"item", 1}, {"rating", 1}})
// Retrieves a document that matches the filter and prints it as
// a struct
var result Tea
err = coll.FindOne(context.TODO(), filter, opts).Decode(&result)
if err != nil {
	if err == mongo.ErrNoDocuments {
		fmt.Println("No documents found")
	} else {
		panic(err)
	}
}
res, _ := bson.MarshalExtJSON(result, false, false)
fmt.Println(string(res))

{"item":"Hibiscus","rating":4}

Nota

El driver de Go genera automáticamente un valor único de ObjectId para el campo _id de cada documento, por lo que tu valor ObjectId podría diferir del ejemplo de código anterior. Para obtener más información sobre el campo _id, consulta la sección Campo _id de la página Insertar un documento.

Operaciones de agregación

Utiliza operaciones de agregación para recuperar y transformar datos de MongoDB. Realiza operaciones de agregación usando el método Aggregate().

Agregación

El método Aggregate() espera que pases un tipo Context y un pipeline de agregación. Una pipeline de agregación define cómo transformar los datos a través de etapas. Algunas de las etapas son emparejar documentos, renombrar campos y agrupar valores.

El método devuelve los documentos resultantes en un tipo Cursor. Si omites la etapa $match, la pipeline continúa usando todos los documentos de la colección.

Para saber cómo acceder a los datos en un cursor, consulta Acceso a datos desde un cursor.

Modificar comportamiento

El método Aggregate() opcionalmente acepta un tipo AggregateOptions, el cual representa opciones que se pueden utilizar para modificar su comportamiento. Si no especificas ninguna opción, el driver usará los valores por defecto para cada opción.

El tipo AggregateOptions te permite configurar opciones con los siguientes métodos:

Método	Descripción
`SetAllowDiskUse()`	Si se debe guardar en archivos temporales. Por defecto: `false`
`SetBatchSize()`	Número de documentos que se devolverán en cada lote. Valor predeterminado: ninguno.
`SetBypassDocumentValidation()`	Si se permite que la operación de guardar se excluya de la validación a nivel de documento. Por defecto: `false`
`SetCollation()`	El tipo de intercalación de lenguaje que se debe usar al clasificar los resultados. Por defecto: `nil`
`SetMaxTime()`	El tiempo máximo que la query puede ejecutarse en el servidor. Por defecto: `nil`
`SetMaxAwaitTime()`	El tiempo máximo que el servidor esperará nuevos documentos para satisfacer una query de cursor con seguimiento. Por defecto: `nil`
`SetComment()`	Un string arbitrario para ayudar a rastrear la operación a través del perfilador de base de datos, currentOp y los registros. Por defecto: `""`
`SetHint()`	El índice que se utilizará para buscar documentos que se recuperarán. Por defecto: `nil`
`SetLet()`	Especifica parámetros para la expresión agregada, lo que mejora la legibilidad del comando al separar las variables del texto de la consulta. Valor predeterminado: ninguno

Ejemplo

El siguiente ejemplo transmite un contexto y un pipeline de agregación que realiza las siguientes acciones:

Agrupa las revisiones por artículo pedido
Calcula la calificación promedio para cada elemento

groupStage := bson.D{
	{"$group", bson.D{
		{"_id", "$item"},
		{"average", bson.D{
			{"$avg", "$rating"},
		}},
	}}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{groupStage})
if err != nil {
	panic(err)
}
// Prints the average "rating" for each item
var results []bson.M
if err = cursor.All(context.TODO(), &results); err != nil {
	panic(err)
}
for _, result := range results {
	fmt.Printf("%v had an average rating of %v \n", result["_id"], result["average"])
}

Sencha had an average rating of 8.5
Hibiscus had an average rating of 4
Masala had an average rating of 9

Para obtener más información sobre cómo construir un pipeline de agregación, consulta la página del manual del servidor de MongoDB en Agregación.

Información Adicional

Para ejemplos ejecutables de las operaciones de búsqueda, consulta los siguientes ejemplos de uso:

Para aprender más sobre las operaciones mencionadas, consulte las siguientes guías:

Documentación de la API

Para obtener más información sobre cualquiera de los métodos o tipos discutidos en esta guía, consultar la siguiente documentación de la API:

Volver

Query

Contabilizar documentos