Recuperar dados

Dados de amostra

Os exemplos nesta aba usam o seguinte struct Tea como um modelo para documentos na coleção tea:

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

Para executar os exemplos neste guia, carregue estes documentos na coleção tea no banco de dados do db utilizando o seguinte trecho:

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)

Cada documento descreve a variedade de chá que um cliente pediu, sua classificação e a data do pedido. Estas descrições correspondem aos campos item, rating e date_ordered.

Localizar todos os documentos

O método Find() espera que você passe um tipo Context e um filtro de query. O método retorna todos os documentos que correspondem ao filtro como um tipo Cursor.

Para um exemplo que utiliza o método Find() , consulte a seção Encontrar Exemplo desta página. Para saber como acessar dados usando um cursor, consulte o guia Acessar dados de um cursor .

Encontrar um documento

O método FindOne() espera que você passe um tipo de Context e um filtro de query. O método retorna o primeiro documento que corresponde ao filtro como um tipo SingleResult.

Para ver um exemplo que usa o método FindOne(), consulte a seção Encontrar um exemplo nesta página. Para ver um exemplo que usa FindOne() e faz queries usando um valor de ObjectId específico, consulte a seção Exemplo de localizar um por ObjectId nesta página.

Para saber como acessar dados de um tipo SingleResult, consulte Unmarshalling no guia BSON.

Modificar comportamento

Você pode modificar o comportamento de Find() e FindOne() passando os tipos FindOptions e FindOneOptions, respectivamente. Se você não especificar nenhuma opção, o driver usará os valores padrão para cada opção.

Você pode configurar as opções normalmente usadas em ambos os tipos com os seguintes métodos:

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

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

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

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

Agregação

O método Aggregate() espera que você passe um tipo Context e um pipeline de agregação. Um pipeline de agregação define como transformar dados por meio de estágios. Algumas das etapas são combinar documentos, renomear campos e agrupar valores.

O método retorna os documentos resultantes em um tipo Cursor . Se você omitir o estágio $match , o pipeline continuará usando todos os documentos da coleção.

Para saber como acessar dados em um cursor, consulte Como acessar dados de um cursor.

Modificar comportamento

O método Aggregate() opcionalmente usa um tipo AggregateOptions , que representa opções que você pode usar para modificar seu comportamento. Se você não especificar nenhuma opção, o driver usará os valores padrão para cada opção.

O tipo AggregateOptions permite a você configurar opções com os seguintes métodos:

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

Documentação da API

Para saber mais sobre qualquer um dos métodos ou tipos discutidos neste guia, consulte a seguinte documentação da API:

• FindOne()

• Resultado único

• Find()

• Encontre opções

• FindOneOptions

• Cursor

• Aggregate()

• AggregateOptions