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 devolverán de una consulta.

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 fragmento:

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 realiza una operación de escritura, el servidor las crea implícitamente.

Cada documento representa una descripción de un curso universitario e incluye el título del curso y la matrícula máxima, correspondientes a los campos title y enrollment de cada documento.

Sort

Para especificar el orden de sus resultados, pase una interfaz que especifique los campos de clasificació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()

Puede establecer una dirección de clasificación 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 a a 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

Un orden descendente ordena los resultados de mayor a menor. 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 de true a false, los valores de tipo String de z a a y los valores de tipo numérico de infinito positivo a 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 ataduras

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 muestra, hay un empate para enrollment en los siguientes documentos:

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

Puede ordenar por campos adicionales para resolver empates en la ordenación original. Si desea garantizar un orden específico para los documentos, seleccione campos de ordenación que no generen empates.

El siguiente ejemplo especifica una ordenación descendente en el campo enrollment y luego una ordenación 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 una ordenación descendente en el campo enrollment y luego una ordenación 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 una cantidad específica de resultados devueltos de una consulta, pase la cantidad de documentos que desea omitir al método SetSkip() de las opciones de la operación de lectura.

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

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

Si la cantidad de documentos excede la cantidad de documentos coincidentes para una consulta, esa consulta no devuelve ningún documento.

Las operaciones de búsqueda devuelven los documentos en un orden natural, sin clasificarlos por campo. Para evitar omitir documentos aleatorios, utilice el método SetSort() para ordenar los documentos por un campo con valores únicos antes de configurar 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 puede incluir la etapa $skip en una canalización de agregación para omitir documentos.

El siguiente ejemplo realiza una operación 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 la cantidad de documentos devueltos de una consulta, pase la cantidad de documentos que desea que se devuelvan al método SetLimit() de las opciones de la operación de lectura.

Las siguientes operaciones de lectura toman SetLimit() como 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 tienen un valor de campo 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}

Múltiples opciones

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 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 una canalización 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 analizadas en esta guía, consulte la siguiente documentación:

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