Configurar operações CRUD

Escreva preocupação

Uma preocupação de gravação descreve o número de membros portadores de dados em um conjunto de réplicas que devem confirmar uma operação de escrita, como uma inserção ou atualização, antes que a operação retorne como bem-sucedida. Por padrão, a operação de gravação é bem-sucedida se somente o membro primário do conjunto de réplicas reconhecê-la.

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)

Preocupação de leitura

A opção de preocupação de leitura possibilita que você determine quais dados o cliente retorna de uma query. O nível de preocupação de leitura padrão é "local", o que significa que o cliente retorna os dados mais recentes da instância, sem garantia de que os dados tenham sido gravados na maioria dos membros do conjunto de réplicas.

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

readPreference

A opção de preferência de leitura especifica como o cliente MongoDB roteia as operações de leitura para os membros de um conjunto de réplica. Por padrão, um aplicativo direciona suas operações de leitura para o membro primário em um conjunto de réplicas.

A read preference consiste no modo de read preference e, opcionalmente, em uma lista de conjunto de tags, na opção maxStalenessSeconds e na opção de leituras distribuídas.

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

Especificar um agrupamento

Para especificar um agrupamento, crie um objeto Collation. Você deve definir o campo Locale do objeto Collation , mas todos os outros campos são opcionais. Por exemplo, o seguinte exemplo de código especifica um objeto Collation com o agrupamento de locale "en_US":

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

Para ver uma lista completa dos Collation campos de objeto, acesse a documentação da API de agrupamento. Para ver todas as localidades suportadas e os valores padrão para os campos Locale , visite Idiomas e localidades compatíveis.

Definir um agrupamento em uma collection ou visualização

Você pode aplicar um agrupamento ao criar uma nova coleção ou visualização. Isso define o agrupamento padrão para quaisquer operações chamadas nessa coleção ou visualização. Defina um agrupamento por meio de um objeto CreateCollectionOptions ou CreateViewOptions . Em seguida, chame o método CreateCollection() ou CreateView() com seu objeto de opções 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)
}

Usar o exemplo de agrupamento padrão

Se você chamar uma operação que usa um agrupamento na collection books , a operação usará o agrupamento padrão especificado no Exemplo de criar uma coleção.

Suponha que a coleção books contenha os seguintes documentos:

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

O exemplo a seguir usa o método Find() para retornar todos os documentos com um valor name que precede alfabeticamente "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"}

Se o código não especificar um agrupamento books padrão, o método Find() seguirá as regras de agrupamento binário padrão para determinar os valores name que precedem "Infinite Jest". Essas regras colocam as palavras que começam com "ç" após aquelas que começam com "I". O resultado se assemelha ao seguinte:

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

Para saber mais sobre o método Find(), consulte Localizar documentos.

Definir um agrupamento em um índice

Você pode aplicar um agrupamento ao criar um novo índice em uma coleção. O índice armazena uma representação ordenada dos documentos na coleção, para que sua instância do MongoDB não execute a ordem para operações de classificação na memória.

Para usar o índice em uma operação, sua operação deve usar o mesmo agrupamento que o especificado no índice. Além disso, certifique-se de que a operação esteja coberta pelo índice que contém o agrupamento. Defina um agrupamento por meio de um objeto IndexOptions e passe esse objeto como argumento para o 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

Definir um agrupamento em uma operação

As operações que leem, atualizam e excluem documentos de uma coleção podem usar agrupamentos. A aplicação de um agrupamento a uma operação substitui qualquer agrupamento padrão definido anteriormente para uma coleção.

Se você aplicar um novo agrupamento a uma operação que difere do agrupamento de um índice, não poderá usar esse índice. Como resultado, a operação pode não ter um desempenho tão bom quanto uma operação coberta por um índice. Para obter mais informações sobre as desvantagens das operações de classificação não cobertas por um índice, consulte Usando índices para classificar resultados de queries. Consulte o manual do MongoDB para obter uma lista de operações que suportam agrupamento.

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"}

Documentação da API

Para saber mais sobre os métodos discutidos neste guia, consulte a seguinte documentação da API:

• Escreva preocupação

• Leia a preocupação

• ReadPref

• Agrupamentos

• CreateCollectionOptions

• IndexModel

• CreateOne()

• IndexOptions

• UpdateOneOptions

• UpdateManyOptions