Especifica los documentos a devolver

Overview

En esta guía, puedes aprender a especificar qué documentos devolver de una operación de lectura utilizando los siguientes métodos:

SetSort(): Especifica el orden de clasificación de los documentos devueltos.
SetSkip(): Especifica la cantidad de documentos que se deben omitir antes de devolver los resultados de la consulta.
SetLimit()Especifica el número máximo de documentos que se deben devolver como resultado de una query.

Datos de muestra

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

type Course struct {
	Title      string
	Enrollment int32
}

Para ejecutar los ejemplos de esta guía, cargue los datos de muestra en la colección db.courses utilizando el siguiente snippet:

coll := client.Database("db").Collection("courses")
docs := []any{
	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)

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 representa una descripción de un curso universitario e incluye el título y la matrícula máxima del curso, que corresponden a los campos title y enrollment en cada documento.

Sort

Para especificar el orden de los resultados, pásese una interfaz que especifique los campos de ordenación y la dirección al método SetSort() de las opciones de una operación.

Las siguientes operaciones toman SetSort() como opción:

Find()
FindOne()
FindOneAndDelete()
FindOneAndUpdate()
FindOneAndReplace()
GridFSBucket.Find()

Puedes establecer una dirección de ordenamiento ascendente o descendente.

Ascendente

Un orden ascendente clasifica tus resultados de menor a mayor. Para especificar esta ordenación, pasa el campo por el que quieras ordenar y 1 al método SetSort().

Tip

Con una ordenación ascendente, el método ordena los valores de tipo Boolean de false a true, los valores de tipo String de la a a la z y los valores de tipo numérico de infinito negativo a infinito positivo.

El siguiente ejemplo especifica una ordenación ascendente en el campo enrollment:

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

{"title":"Modern Poetry","enrollment":12}
{"title":"World Fiction","enrollment":35}
{"title":"Plate Tectonics","enrollment":35}
{"title":"Abstract Algebra","enrollment":60}

Descendente

Una ordenación descendente organiza tus resultados del más grande al más pequeño. Para especificar este orden, pase el campo por el que desea ordenar y -1 al método SetSort().

Tip

Con una ordenación descendente, el método ordena los valores de tipo Boolean desde true hasta false, los valores de tipo String de la z a la a y los valores de tipo numérico desde el infinito positivo hasta el infinito negativo.

El siguiente ejemplo especifica una ordenación descendente en el campo enrollment:

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

{"title":"Abstract Algebra","enrollment":60}
{"title":"World Fiction","enrollment":35}
{"title":"Plate Tectonics","enrollment":35}
{"title":"Modern Poetry","enrollment":12}

Manejo de empates

Se produce un empate cuando dos o más documentos tienen valores idénticos en el campo que se utiliza para ordenar los resultados. MongoDB no garantiza el orden en caso de empate.

Por ejemplo, en los datos de la muestra, hay un empate en enrollment en los siguientes documentos:

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

Puede clasificar en campos adicionales para resolver los empates en la clasificación original. Si desea garantizar un orden específico para los documentos, seleccione campos de clasificación que no den lugar a empates.

El siguiente ejemplo especifica un orden descendente en el campo enrollment, luego un orden ascendente en el campo title:

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

{"title":"Abstract Algebra","enrollment":60}
{"title":"Plate Tectonics","enrollment":35}
{"title":"World Fiction","enrollment":35}
{"title":"Modern Poetry","enrollment":12}

Agregación

También puedes incluir el Etapa $sort para especificar una clasificación en una canalización de agregación.

El siguiente ejemplo especifica un orden descendente en el campo enrollment, luego un orden ascendente en el campo title:

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

{"title":"Abstract Algebra","enrollment":60}
{"title":"Plate Tectonics","enrollment":35}
{"title":"World Fiction","enrollment":35}
{"title":"Modern Poetry","enrollment":12}

Omitir

Para omitir un número especificado de resultados devueltos de una query, pasa el número de documentos que deseas omitir al método SetSkip() de las opciones de la operación de lectura.

Las siguientes operaciones de lectura toman SetSkip() como una opción:

Find()
FindOne()
CountDocuments()
GridFSBucket.Find()

Si el número de documentos supera el número de documentos encontrados para una query, esa query no devuelve ningún documento.

Las operaciones de búsqueda devuelven documentos en un orden natural que no está ordenado según ningún campo. Para evitar omitir documentos aleatoriamente, utiliza el método SetSort() para ordenar documentos en un campo con valores únicos antes de establecer una opción de omisión.

El siguiente ejemplo realiza una operación Find() con el siguiente comportamiento:

Ordena los resultados en orden ascendente en el campo enrollment.
Omite los dos primeros documentos

opts := options.Find().SetSort(bson.D{{"enrollment", 1}}).SetSkip(2)
cursor, err := coll.Find(context.TODO(), bson.D{}, 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))
}

{"title":"Plate Tectonics","enrollment":35}
{"title":"Abstract Algebra","enrollment":60}

Agregación

También se puede incluir la etapa $skip en una pipeline de agregación para omitir documentos.

El siguiente ejemplo realiza una operación de Aggregate() con el siguiente comportamiento:

Ordena los resultados en orden descendente en el campo enrollment
Omite el primer documento

sortStage := bson.D{{"$sort", bson.D{{"enrollment", -1}}}}
skipStage := bson.D{{"$skip", 1}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{sortStage, skipStage})
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))
}

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

Limit

Para limitar el número de documentos que se devuelven de una query, pase el número de documentos que desea recibir al método SetLimit() de las opciones de la operación de lectura.

Las siguientes operaciones de lectura toman SetLimit() como una opción:

Find()
CountDocuments()
GridFSBucket.Find()

Si el límite es 0 o supera el número de documentos coincidentes, el método devuelve todos los documentos. Si el límite es un número negativo, el método utiliza el valor absoluto del número negativo como límite y cierra el cursor después de recuperar los documentos.

El siguiente ejemplo muestra cómo devolver dos documentos que tengan un valor de campo de enrollment mayor que 20:

filter := bson.D{{"enrollment", bson.D{{"$gt", 20}}}}
opts := options.Find().SetLimit(2)
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))
}

{"title":"World Fiction","enrollment":35}
{"title":"Abstract Algebra","enrollment":60}

Opciones múltiples

El driver ejecuta el comportamiento de límite como último independientemente del orden en que se configuren otras opciones. Por ejemplo, la siguiente configuración de opciones produce el mismo resultado, sin importar el orden en que se llame a SetLimit():

opts := options.Find().SetSort(bson.D{{"enrollment", -1}}).SetSkip(1).SetLimit(2)
opts := options.Find().SetLimit(2).SetSort(bson.D{{"enrollment", -1}}).SetSkip(1)

El siguiente ejemplo realiza una operación Find() con el siguiente comportamiento:

Ordena los resultados en orden descendente en el campo enrollment
Omite el primer documento
Devuelve los dos primeros de los documentos restantes

filter := bson.D{}
opts := options.Find().SetSort(bson.D{{"enrollment", -1}}).SetLimit(2).SetSkip(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))
}

{"title":"Abstract Algebra","enrollment":60}
{"title":"Plate Tectonics","enrollment":35}

Agregación

También puede incluir la etapa $limit para especificar un límite en un pipeline de agregación.

El siguiente ejemplo muestra cómo devolver tres documentos:

limitStage := bson.D{{"$limit", 3}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{limitStage})
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))
}

{"title":"World Fiction","enrollment":35}
{"title":"Abstract Algebra","enrollment":60}
{"title":"Modern Poetry","enrollment":12}

Información Adicional

Para obtener más información sobre las operaciones comentadas en esta guía, consulta la documentación siguiente:

Para obtener más información sobre cómo ordenar las puntuaciones de texto de sus consultas de texto, consulte Realizar una consulta de texto.

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

Acceder a datos desde un cursor

Especifique los campos a devolver