Docs Menu
Docs Home
/ /

Contabilizar documentos

En esta guía podrás aprender cómo obtener un recuento preciso y estimado del número de documentos de su colección.

Los ejemplos de esta sección utilizan lo siguiente: Tea Estructura como modelo para los documentos de la colección tea:

type Tea struct {
Type string
Rating int32
}

Para ejecutar los ejemplos de esta guía, cargue los datos de muestra en la colección tea de la base de datos db con el siguiente fragmento:

coll := client.Database("db").Collection("tea")
docs := []any{
Tea{Type: "Masala", Rating: 10},
Tea{Type: "Matcha", Rating: 7},
Tea{Type: "Assam", Rating: 4},
Tea{Type: "Oolong", Rating: 9},
Tea{Type: "Chrysanthemum", Rating: 5},
Tea{Type: "Earl Grey", Rating: 8},
Tea{Type: "Jasmine", Rating: 3},
Tea{Type: "English Breakfast", Rating: 6},
Tea{Type: "White Peony", Rating: 4},
}
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 describe un tipo de té y su clasificación. Estos elementos corresponden a los campos type y rating.

Para contar el número de documentos que coinciden con su filtro de consulta, utilice el método CountDocuments(). Si pasa un filtro de consulta vacío, este método devuelve el número total de documentos de la colección.

Tip

Al usar CountDocuments() para devolver el número total de documentos de una colección, MongoDB realiza un escaneo de la colección. Puede evitarlo y mejorar el rendimiento de este método usando una sugerencia para aprovechar el índice integrado en el _id campo. Use esta técnica solo al llamar a CountDocuments() con un parámetro de consulta vacío.

opts := options.Count().SetHint("_id_")
count, err := coll.CountDocuments(context.TODO(), bson.D{}, opts)
if err != nil {
panic(err)
}

Puede modificar el comportamiento de CountDocuments() pasando un tipo CountOptions. Si no especifica ninguna opción, el controlador usa sus valores predeterminados.

El tipo CountOptions le permite configurar opciones con los siguientes métodos:

Método
Descripción

SetCollation()

The type of language collation to use when sorting results.
Default: nil

SetHint()

The index to use to scan for documents to count.
Default: nil

SetLimit()

The maximum number of documents to count.
Default: 0

SetSkip()

The number of documents to skip before counting.
Default: 0

El siguiente ejemplo cuenta la cantidad de documentos donde rating es menor que 6:

filter := bson.D{{"rating", bson.D{{"$lt", 6}}}}
count, err := coll.CountDocuments(context.TODO(), filter)
if err != nil {
panic(err)
}
fmt.Printf("Number of documents with a rating less than six: %d\n", count)
Number of documents with a rating less than six: 4

También puede incluir la etapa $count para contar la cantidad de documentos en una canalización de agregación.

El siguiente ejemplo realiza las siguientes acciones:

  • Cuenta el número de documentos en los que el valor del campo rating es mayor que 5

  • Asigna el recuento al campo counted_documents

matchStage := bson.D{{"$match", bson.D{{"rating", bson.D{{"$gt", 5}}}}}}
countStage := bson.D{{"$count", "counted_documents"}}
cursor, err := coll.Aggregate(context.TODO(), mongo.Pipeline{matchStage, countStage})
if err != nil {
panic(err)
}
var results []bson.D
if err = cursor.All(context.TODO(), &results); err != nil {
panic(err)
}
for _, result := range results {
fmt.Println(result)
}
[{counted_documents 5}]

Para estimar la cantidad de documentos en su colección, utilice el método EstimatedDocumentCount().

Nota

El método EstimatedDocumentCount() es más rápido que el método CountDocuments() porque utiliza los metadatos de la colección en lugar de escanear toda la colección.

Puede modificar el comportamiento de EstimatedDocumentCount() pasando un tipo EstimatedDocumentCountOptions. Si no especifica ninguna opción, el controlador usa sus valores predeterminados.

El tipo EstimatedDocumentCountOptions le permite configurar opciones mediante los siguientes métodos:

Método
Descripción

SetComment()

Sets a comment to attach to the count operation.
Default: nil

El siguiente ejemplo estima la cantidad de documentos en la colección tea:

count, err := coll.EstimatedDocumentCount(context.TODO())
if err != nil {
panic(err)
}
fmt.Printf("Estimated number of documents in the tea collection: %d\n", count)
Estimated number of documents in the tea collection: 9

Nota

Configuración de ejemplo

Este ejemplo se conecta a una instancia de MongoDB mediante una URI de conexión. Para obtener más información sobre cómo conectarse a su instancia de MongoDB, consulte Guía paracrear MongoClient. Este ejemplo también utiliza la restaurants colección de la sample_restaurants base de datos incluida en los conjuntos de datos de ejemplo de Atlas. Puede cargarlos en su base de datos en la versión gratuita de MongoDB Atlas siguiendo la Guía de introducción a Atlas.

Este ejemplo realiza lo siguiente en la colección restaurants:

  • Se aproxima el número de documentos de la colección.

  • Cuenta el número de documentos en los que el valor del campo cuisine es "American"

// Counts documents in a collection by using the Go driver
package main
import (
"context"
"fmt"
"log"
"os"
"github.com/joho/godotenv"
"go.mongodb.org/mongo-driver/v2/bson"
"go.mongodb.org/mongo-driver/v2/mongo"
"go.mongodb.org/mongo-driver/v2/mongo/options"
)
type Restaurant struct {
ID bson.ObjectID `bson:"_id"`
Name string
RestaurantId string `bson:"restaurant_id"`
Cuisine string
Address interface{}
Borough string
Grades interface{}
}
func main() {
if err := godotenv.Load(); err != nil {
log.Println("No .env file found")
}
var uri string
if uri = os.Getenv("MONGODB_URI"); uri == "" {
log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://www.mongodb.com/es/docs/drivers/go/current/usage-examples/#environment-variable")
}
client, err := mongo.Connect(options.Client().ApplyURI(uri))
if err != nil {
panic(err)
}
defer func() {
if err = client.Disconnect(context.TODO()); err != nil {
panic(err)
}
}()
coll := client.Database("sample_restaurants").Collection("restaurants")
// Specifies a filter to match documents where the "cuisine" field
// has a value of "American"
filter := bson.D{{"cuisine", "American"}}
// Retrieves and prints the estimated number of documents in the collection
estCount, estCountErr := coll.EstimatedDocumentCount(context.TODO())
if estCountErr != nil {
panic(estCountErr)
}
// Retrieves and prints the number of matching documents in the collection
count, err := coll.CountDocuments(context.TODO(), filter)
if err != nil {
panic(err)
}
// When you run this file, it should print:
// Estimated number of documents in the movies collection: 25359
// Number of restaurants with American cuisine: 6183
fmt.Printf("Estimated number of documents in the restaurants collection: %d\n", estCount)
fmt.Printf("Number of restaurants with American cuisine: %d\n", count)
}
Estimated number of documents in the restaurants collection: 25359
Number of restaurants with American cuisine: 6183

Para obtener más información sobre las operaciones mencionadas, consulte las siguientes guías:

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

Especifique los campos a devolver

En esta página