Configurar las operaciones CRUD

Nivel de confirmación de escritura

Un nivel de confirmación de escritura (write concern) describe el número de miembros con datos en un set de réplicas que deben confirmar una operación de escritura, como una inserción o actualización, antes de que la operación se considere exitosa. Por defecto, la operación de escritura es exitosa si solo el miembro principal del conjunto de réplicas la reconoce.

uri := "mongodb://<hostname>:<port>"
journal := false
cliWC := &writeconcern.WriteConcern{
    W: 2,
    Journal: &journal,
}
clOpts := options.Client().ApplyURI(uri).SetWriteConcern(cliWC)
client, err := mongo.Connect(clOpts)
...
collWC := writeconcern.Majority()
collOpts := options.Collection().SetWriteConcern(collWC)
coll := client.Database("db").Collection("myColl", collOpts)

readConcern

La opción de nivel de consistencia de lectura permite determinar qué datos devuelve el cliente desde una consulta. El nivel de consistencia de lectura predeterminado es "local", lo que significa que el cliente devuelve los datos más recientes de la instancia, sin garantía de que los datos se hayan escrito en la mayoría de los miembros del conjunto de réplicas.

rc := readconcern.Majority()
opts := options.Collection().SetReadConcern(rc)
database := client.Database("db")
coll := database.Collection("myCollection", opts)

preferencia de lectura

La opción de preferencia de lectura especifica cómo el cliente de MongoDB enruta las operaciones de lectura a los nodos de un set de réplicas. Por defecto, una aplicación dirige sus operaciones de lectura al miembro principal de un set de réplicas.

La preferencia de lectura consiste en el modo de preferencia de lectura y, opcionalmente, una lista de conjunto de etiquetas, la opción maxStalenessSeconds y la opción lectura protegida.

rp := readpref.Secondary()
opts := options.Database().SetReadPreference(rp)
database := client.Database("db", opts)

Especifica una intercalación

Para especificar una intercalación, crea un objeto Collation. Debes definir el campo Locale del objeto Collation, pero todos los demás campos son opcionales. Por ejemplo, el siguiente ejemplo de código especifica un objeto Collation con la intercalación de localización de "en_US":

myCollation := &options.Collation{Locale: "en_US"}

Para obtener una lista completa de los campos de Collation objeto, visita la documentación de la API de intercalación. Para ver todas las localizaciones admitidas y los valores predeterminados de los campos Locale, visita Idiomas y localizaciones admitidas.

Establecer una intercalación en una colección o vista

Puedes aplicar una intercalación al crear una colección o vista nueva. Esto define la intercalación por defecto para cualquier operación que se realice en esa colección o vista. Establecer una intercalación a través de un objeto CreateCollectionOptions o CreateViewOptions. Luego, llama al método CreateCollection() o CreateView() con tu objeto de opciones como argumento.

myCollation := &options.Collation{Locale: "fr", Strength: 1}
opts := options.CreateCollection().SetCollation(myCollation)
err := db.CreateCollection(context.TODO(), "books", opts)
if err != nil {
   panic(err)
}

Use el ejemplo de intercalación por defecto

Si llamas a una operación que utiliza una intercalación en la colección books, la operación utiliza la intercalación predeterminada especificada en el Ejemplo de creación de una colección.

Suponga que la colección books contiene los siguientes documentos:

{"name" : "Emma", "length" : "474"}
{"name" : "Les Misérables", "length": "1462"}
{"name" : "Infinite Jest", "length" : "1104"}
{"name" : "Cryptonomicon", "length" : "918"}
{"name" : "Ça", "length" : "1138"}

El siguiente ejemplo utiliza el método Find() para devolver todos los documentos con un valor name que antecede alfabéticamente a "Infinite Jest":

filter := bson.D{{"name", bson.D{{"$lt", "Infinite Jest"}}}}
cursor, err := coll.Find(context.TODO(), filter)
if err != nil {
   panic(err)
}
var results []bson.D
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))
}

{"name":"Emma","length":"474"}
{"name":"Cryptonomicon","length":"918"}
{"name":"Ça","length":"1138"}

Si el código no especifica una intercalación predeterminada de books, el método Find() sigue las reglas predeterminadas de intercalación binaria para determinar los valores de name que preceden a "Infinite Jest". Estas reglas sitúan palabras que comienzan con "Ç" después de las que comienzan con "I". La salida se asemeja a la siguiente:

{"name":"Emma","length":"474"}
{"name":"Cryptonomicon","length":"918"}

Para obtener más información sobre el método Find(), consulta Buscar documentos.

Establece una intercalación en un índice

Puede aplicar una intercalación al crear un nuevo índice en una colección. El índice almacena una representación ordenada de los documentos en la colección, por lo que tu instancia de MongoDB no realiza la ordenación para las operaciones de ordenamiento en memoria.

Para utilizar el índice en una operación, su operación debe utilizar la misma intercalación que la especificada en el índice. Además, asegúrate de que la operación esté cubierta por el índice que contiene la intercalación. Establece una intercalación a través de un objeto IndexOptions y pasa este objeto como argumento al método CreateOne().

 myCollation := &options.Collation{Locale: "en_US"}
 opts := options.Index().SetCollation(myCollation)
 indexModel := mongo.IndexModel{
   Keys:    bson.D{{"name", 1}},
   Options: opts,
 }
 name, err := coll.Indexes().CreateOne(context.TODO(), indexModel)
 if err != nil {
   panic(err)
 }
 fmt.Println("Name of Index Created: " + name)

 Name of Index Created: name_1

Establecer una intercalación en una operación

Las operaciones que leen, actualizan y eliminan documentos de una colección pueden utilizar intercalaciones. Al aplicar una intercalación a una operación se anula cualquier intercalación por defecto previamente definida para una colección.

Si aplicas una nueva intercalación a una operación que difiere de la intercalación de un índice, no puedes usar ese índice. Por lo tanto, la operación puede no tener el mismo rendimiento que una operación cubierta por un índice. Para obtener más información sobre las desventajas de las operaciones de ordenación que no están cubiertas por un índice, consulta Uso de índices para ordenar los resultados de query. Consulta el manual de MongoDB para obtener una lista de operaciones que admiten intercalación.

filter := bson.D{{"length", bson.D{{"$gt", "1000"}}}}
myCollation := &options.Collation{Locale: "en_US", NumericOrdering: true}
opts := options.Find().SetCollation(myCollation)
cursor, err := coll.Find(context.TODO(), filter, opts)
if err != nil {
   panic(err)
}
var results []bson.D
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))
}

{"name":"Les Misérables","length":"1462"}
{"name":"Infinite Jest","length":"1104"}
{"name":"Ça","length":"1138"}

{"name":"Emma","length":"474"}
{"name":"Les Misérables","length":"1462"}
{""name":"Infinite Jest","length":"1104"}
{"name":"Cryptonomicon","length":"918"}
{"name":"Ça","length":"1138"}

Documentación de la API

Para obtener más información sobre los métodos que se abordan en esta guía, consulte la siguiente documentación de la API:

• Nivel de confirmación de escritura (write concern)

• readConcern

• ReadPref

• Intercalación

• CreateCollectionOptions

• IndexModel

• CreateOne()

• Opciones del índice

• UpdateOneOptions

• UpdateManyOptions