Menu Docs
Página inicial do Docs
/ / /
Driver GO
/

Agrupamentos

Nesta página

  • Visão geral
  • Agrupamentos no MongoDB
  • Especificar um agrupamento
  • Definir um agrupamento em uma collection ou visualização
  • Criar um Exemplo de Coleção
  • Usar o exemplo de agrupamento padrão
  • Definir um agrupamento em um índice
  • Exemplo
  • Definir um agrupamento em uma operação
  • Exemplo
  • Informações adicionais
  • Documentação da API

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.

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é

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.

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.

O exemplo a seguir cria uma nova coleção chamada books e especifica um agrupamento padrão com a localidade "fr" . O campo de agrupamento Strength tem um valor de 1 para ignorar diferenças nos acentos das letras.

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

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

Observação

Para saber como inserir documentos, consulte Inserir um documento.

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

Sem especificar um agrupamento books padrão, o método Find() seguiria 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 seria semelhante ao seguinte:

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

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

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() .

Depois de criar a coleção books e aplicar um agrupamento padrão, como mostrado na seção Criar um Exemplo de Coleção , você não poderá alterar o agrupamento padrão da coleção. No entanto, você pode criar um índice para a coleção com um agrupamento diferente.

O exemplo a seguir usa o método CreateOne() para criar um índice ascendente no campo name e especifica um novo agrupamento com um locale "en_US" :

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)

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.

Você pode usar as operações que suportam agrupamento para atualizar e consultar documentos na collection books .

O exemplo a seguir usa o método Find() para retornar documentos nos quais o valor length é maior que "1000". O campo de agrupamento NumericOrdering tem um valor de true para garantir que os valores sejam classificados em ordem numérica em vez de alfabética:

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

Sem especificar um agrupamento com um campo NumericOrdering definido como true, a mesma operação Find() compara valores length como strings. Nesse caso, a saída se assemelha ao seguinte:

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

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:

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

Voltar

Execute um comando