Classificar resultados

Dados de amostra

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

type Course struct {
	Title      string
	Enrollment int32
}

Para executar os exemplos nesta aba, carregue os dados de amostra na coleção db.courses com o seguinte trecho:

coll := client.Database("db").Collection("courses")
docs := []interface{}{
	Course{Title: "World Fiction", Enrollment: 35},
	Course{Title: "Abstract Algebra", Enrollment: 60},
	Course{Title: "Modern Poetry", Enrollment: 12},
	Course{Title: "Plate Tectonics", Enrollment: 35},
}
result, err := coll.InsertMany(context.TODO(), docs)

Cada documento contém uma descrição de um curso universitário que inclui o nome do curso e o número máximo de matrículas, correspondentes aos campos title e enrollment em cada documento.

Ascendente

Uma classificação crescente ordena seus resultados do menor para o maior. Para especificar esta classificação, passe o campo pelo qual você deseja classificar e 1 para o método SetSort().

filter := bson.D{}
opts := options.Find().SetSort(bson.D{{"enrollment", 1}})
cursor, err := coll.Find(context.TODO(), filter, opts)
var results []Course
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))
}

Descendente

Uma classificação decrescente ordena seus resultados do maior para o menor. Para especificar essa classificação, passe o campo pelo qual você deseja classificar e -1 para o método SetSort().

filter := bson.D{}
opts := options.Find().SetSort(bson.D{{"enrollment", -1}})
cursor, err := coll.Find(context.TODO(), filter, opts)
var results []Course
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))
}

Lidar com empates

Um empate ocorre quando dois ou mais documentos têm valores idênticos no campo que você está usando para classificar seus resultados. O MongoDB não garante a ordem se ocorrerem empates.

Por exemplo, nos dados de amostra, há uma vínculo para enrollment nos seguintes documentos:

{"title":"World Fiction","enrollment":35}
{"title":"Plate Tectonics","enrollment":35}

Você pode classificar campos adicionais para resolver empates na classificação original. Para garantir um pedido específico de documentos, selecione os campos de classificação que não resultem em empates.

filter := bson.D{}
opts := options.Find().SetSort(bson.D{{"enrollment", -1}, {"title", 1}})
cursor, err := coll.Find(context.TODO(), filter, opts)
var results []Course
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))
}

Agregação

Você também pode incluir o estágio $sort para especificar uma classificação em um pipeline de agregação.

sortStage := bson.D{{"$sort", bson.D{{"enrollment", -1}, {"title", 1}}}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{sortStage})
if err != nil {
    panic(err)
}
var results []Course
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))
}

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:

• Find()

• FindOptions.SetSort()

• Aggregate()

• FindOne()

• FindOneAndDelete()

• FindOneAndUpdate()

• FindOneAndReplace()

• gridfs.Bucket.Find()