Agrupamentos

Visão geral

Neste guia, você pode aprender a usar agrupamentos para ordenar seus resultados de query ou operação de agregação por valores de string. Um agrupamento é um conjunto de convenções de ordenação de caracteres que se aplicam a um idioma e uma localidade específicos.

Agrupamentos no MongoDB

O MongoDB classifica strings utilizando agrupamento binário por padrão. Este método de agrupamento utiliza o padrão ASCII valores de caracteres para comparar e ordenar strings. Alguns idiomas e locais possuem convenções específicas de ordenação de caracteres que diferem do padrão ASCII.

Por exemplo, no francês canadense, o caractere mais acentuado à direita determina a ordem das strings quando os outros caracteres são os mesmos. Considere as seguintes palavras do francês canadense:

• cote

• coté

• côte

• côté

Ao usar o agrupamento binário padrão, o MongoDB os classifica na seguinte ordem:

cote
coté
côte
côté

Ao usar o agrupamento francês canadense, o MongoDB os classifica na seguinte ordem:

cote
côte
coté
côté

Especificar um agrupamento

Para especificar um agrupamento, crie um objeto Collation . Você deve definir o campo { Locale } do objeto Collation ; todos os outros campos são opcionais. Por exemplo, o seguinte exemplo de código especifica um objeto Collation com o agrupamento de localidade "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)
}

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

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

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 precise executar 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)

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":"Emma","length":"474"}
{"name":"Les Misérables","length":"1462"}
{""name":"Infinite Jest","length":"1104"}
{"name":"Cryptonomicon","length":"918"}
{"name":"Ça","length":"1138"}

Informações adicionais

Para saber mais sobre o método Find() , consulte o guia Recuperar dados .

Para saber mais sobre agrupamentos, acesse as seguintes páginas de manual:

• Agrupamentos

• Locais de Agrupamento e Parâmetros Padrão