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 consta del modo de preferencia de lectura y, opcionalmente, una lista de conjuntos de etiquetas, la opción maxStalenessSeconds y la opción de lectura cubierta.

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

Especifica una intercalación

Para especificar una intercalación, cree un objeto Collation. Debe 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 configuración regional "en_US":

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

Para obtener una lista completa de los campos Collation de objeto, visite la documentación de la API de intercalación. Para ver todas las configuraciones regionales compatibles y los valores predeterminados de los Locale campos, visite Idiomas y configuraciones regionales compatibles.

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

Puedes aplicar una intercalación al crear una nueva colección o vista. Esto define la intercalación predeterminada para cualquier operación realizada en esa colección o vista. Establece una intercalación mediante un objeto CreateCollectionOptions o CreateViewOptions. A continuación, llama al método CreateCollection() o CreateView() con el 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)
}

Utilice el ejemplo de intercalación predeterminada

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

Supongamos 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 Find() método, consulte Buscar documentos.

Establece una intercalación en un índice

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

Para usar el índice en una operación, esta debe usar la misma intercalación que la especificada en el índice. Además, asegúrese de que la operación esté cubierta por el índice que contiene la intercalación. Establezca una intercalación mediante un objeto IndexOptions y páselo 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 aplica una nueva intercalación a una operación que difiere de la intercalación de un índice, no podrá usar ese índice. Como resultado, la operación podría no funcionar tan bien como una que esté cubierta por un índice. Para obtener más información sobre las desventajas de las operaciones de ordenación no cubiertas por un índice, consulte "Usar índices para ordenar los resultados de consultas". Consulte el manual de MongoDB para obtener una lista de las operaciones que admiten la 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 analizados en esta guía, consulte la siguiente documentación de API:

• Escribir preocupación

• LeerPreocupación

• LeerPref

• Intercalación

• Opciones de creación de colección

• IndexModel

• Crear uno()

• Opciones del índice

• UpdateOneOptions

• UpdateManyOptions