Retrieve Data

Dados de amostra

Os exemplos deste guia utilizam o seguinte Tea estruturado 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 de código:

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.

For an example that uses the FindOne() method, see the Find One Example section of this page. For an example that uses FindOne() and queries by using a specific ObjectId value, see the Find One by ObjectId Example section of this page.

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

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

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

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

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

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.

The method returns the resulting documents in a Cursor type. If you omit the $match stage, the pipeline proceeds using all documents in the collection.

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

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

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

• SingleResult

• Find()

• Encontre opções

• FindOneOptions

• Cursor

• Aggregate()

• AggregateOptions