Configurar las operaciones CRUD

Nivel de confirmación de escritura

Una preocupación de escritura describe el número de miembros de un conjunto de réplicas que contienen datos y que deben confirmar una operación de escritura, como una inserción o una actualización, antes de que esta se considere exitosa. De forma predeterminada, la operación de escritura se considera exitosa si solo la confirma el miembro principal del conjunto de réplicas.

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 lectura permite determinar qué datos devuelve el cliente tras una consulta. El nivel 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 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 MongoDB enruta las operaciones de lectura a los miembros de un conjunto de réplicas. De forma predeterminada, una aplicación dirige sus operaciones de lectura al miembro principal de un conjunto 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 precede 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 books predeterminada, el método Find() sigue las reglas de intercalación binaria predeterminadas para determinar los valores name que preceden a "Infinite Jest". Estas reglas colocan las palabras que empiezan por "Ç" después de las que empiezan por "I". El resultado es similar al 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

• Crear uno()

• Opciones del índice

• UpdateOneOptions

• UpdateManyOptions