/ /

/ /

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 utilizan lo siguiente Tea struct 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 un ejemplo que usa el método Find(), consulta la sección Ejemplo de búsqueda de esta página. Para aprender a acceder a los datos usando un cursor, consulta el Guía para 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()`	The type of language collation to use when sorting results. Default: `nil`
`SetLimit()`	The maximum number of documents to return. Default: `0` This option is not available for `FindOneOptions`. The `FindOne()` method internally uses `SetLimit(-1)`.
`SetProjection()`	The fields to include in the returned documents. Default: `nil`
`SetSkip()`	The number of documents to skip. Default: `0`
`SetSort()`	The field and type of sort to order the matched documents. You can specify an ascending or descending sort. Default: none

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()`	Whether to write to temporary files. Default: `false`
`SetBatchSize()`	The number of documents to return in each batch. Default: none
`SetBypassDocumentValidation()`	Whether to allow the write to opt-out of document level validation. Default: `false`
`SetCollation()`	The type of language collation to use when sorting results. Default: `nil`
`SetMaxTime()`	The maximum amount of time that the query can run on the server. Default: `nil`
`SetMaxAwaitTime()`	The maximum amount of time for the server to wait on new documents to satisfy a tailable cursor query. Default: `nil`
`SetComment()`	An arbitrary string to help trace the operation through the database profiler, currentOp and logs. Default: `""`
`SetHint()`	The index to use to scan for documents to retrieve. Default: `nil`
`SetLet()`	Specifies parameters for the aggregate expression, which improves command readability by separating the variables from the query text. Default: none

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