/ /

$sortByCount (estágio de agregação )

Definição

$sortByCount

Agrupa documentos recebidos com base no valor de uma expressão especificada e, em seguida, calcula a contagem de documentos em cada grupo distinto.

Cada documento de saída contém dois campos: um campo _id contendo o valor de agrupamento distinto e um campo count contendo o número de documentos pertencentes a esse agrupamento ou categoria.

Os documentos são ordenados por count em ordem decrescente.

The $sortByCount stage has the following prototype form:

{ $sortByCount:  <expression> }

Campo

Descrição

expression

Agrupamento por expressão. Você pode especificar qualquer expressão, exceto um literal de documento.

Para especificar um caminho do campo, prefixe o nome do campo com um cifrão $ e coloque-o entre aspas. Por exemplo, para agrupar pelo campo employee, especifique "$employee" como a expressão.

{ $sortByCount:  "$employee" }

Although you cannot specify a document literal for the group by expression, you can, however, specify a field or an expression that evaluates to a document. For example, if employee and business fields are document fields, then the following $mergeObjects expression, which evaluates to a document, is a valid argument to $sortByCount:

{ $sortByCount: { $mergeObjects: [ "$employee", "$business" ] } }

No entanto, o exemplo a seguir com a expressão literal de documento é inválido:

{ $sortByCount: { lname: "$employee.last", fname: "$employee.first" } }

Dica

Ordem de comparação/classificação

Considerações

`$sortByCount` e restrições de memória

A partir do MongoDB 6.0, os estágios do pipeline que exigem mais de 100 megabytes de memória para execução gravam arquivos temporários no disco por padrão. Esses arquivos temporários duram durante a execução do pipeline e podem influenciar o espaço de armazenamento na sua instância. Em versões anteriores do MongoDB, você deve passar { allowDiskUse: true } para find individuais e comandos aggregate para habilitar esse comportamento.

Somente find e aggregate comandos podem substituir o parâmetro allowDiskUseByDefault por um ou outro:

Usando { allowDiskUse: true } para permitir a gravação de arquivos temporários no disco quando allowDiskUseByDefault estiver definido como false
Usando { allowDiskUse: false } para proibir a gravação de arquivos temporários no disco quando allowDiskUseByDefault estiver definido como true

Observação

For MongoDB Atlas, it is recommended to configure storage auto-scaling to prevent long-running queries from filling up storage with temporary files.

Se o Atlas cluster usar auto-scaling de armazenamento, os arquivos temporários podem fazer com que o cluster seja dimensionado para o próximo nível de armazenamento.

Para obter mais detalhes, consulte Limites do pipeline de agregação.

Comportamento

O estágio $sortByCount é equivalente à seguinte sequência $group + $sort:

{ $group: { _id: <expression>, count: { $sum: 1 } } },
{ $sort: { count: -1 } }

Exemplos

Considere uma coleção exhibits com os seguintes documentos:

db.exhibits.insertMany(
   [
      { _id: 1, title: "The Pillars of Society", artist: "Grosz", year: 1926, tags: [ "painting", "satire", "Expressionism", "caricature" ] },
      { _id: 2, title: "Melancholy III", artist: "Munch", year: 1902, tags: [ "woodcut", "Expressionism" ] },
      { _id: 3, title: "Dancer", artist: "Miro", year: 1925, tags: [ "oil", "Surrealism", "painting" ] },
      { _id: 4, title: "The Great Wave off Kanagawa", artist: "Hokusai", tags: [ "woodblock", "ukiyo-e" ] },
      { _id: 5, title: "The Persistence of Memory", artist: "Dali", year: 1931, tags: [ "Surrealism", "painting", "oil" ] },
      { _id: 6, title: "Composition VII", artist: "Kandinsky", year: 1913, tags: [ "oil", "painting", "abstract" ] },
      { _id: 7, title: "The Scream", artist: "Munch", year: 1893, tags: [ "Expressionism", "painting", "oil" ] },
      { _id: 8, title: "Blue Flower", artist: "O'Keefe", year: 1918, tags: [ "abstract", "painting" ] }
   ]
)

The following operation unwinds the tags array and uses the $sortByCount stage to count the number of documents associated with each tag:

db.exhibits.aggregate( [ { $unwind: "$tags" },  { $sortByCount: "$tags" } ] )

A operação retorna os seguintes documentos, ordenados em ordem decrescente por contagem:

[
   { _id: "painting", count: 6 },
   { _id: "oil", count: 4 },
   { _id: "Expressionism", count: 3 },
   { _id: "Surrealism", count: 2 },
   { _id: "abstract", count: 2 },
   { _id: "woodblock", count: 1 },
   { _id: "woodcut", count: 1 },
   { _id: "ukiyo-e", count: 1 },
   { _id: "satire", count: 1 },
   { _id: "caricature", count: 1 }
]

Os exemplos de C# nesta página utilizam o banco de dados sample_mflix a partir dos conjuntos de dados de amostra do Atlas. Para saber como criar um cluster MongoDB Atlas gratuito e carregar os conjuntos de dados de exemplo, consulte Introdução na documentação do driver MongoDB .NET/C#.

A seguinte classe Movie modela os documentos na collection sample_mflix.movies:

[BsonIgnoreExtraElements]
public class Movie
{
    [BsonId]
    public ObjectId Id { get; set; }
    [BsonElement("title")]
    public string Title { get; set; } = null!;
    [BsonElement("year")]
    public int? Year { get; set; }
    [BsonElement("runtime")]
    public int? Runtime { get; set; }
    [BsonElement("rated")]
    public string? Rated { get; set; }
    [BsonElement("metacritic")]
    public int Metacritic { get; set; }
    [BsonElement("plot")]
    public string? Plot { get; set; }
    [BsonElement("type")]
    public string? Type { get; set; }
    [BsonElement("cast")]
    public string[]? Cast { get; set; }
    [BsonElement("directors")]
    public string[]? Directors { get; set; }
    [BsonElement("writers")]
    public string[]? Writers { get; set; }
    [BsonElement("imdb")]
    public ImdbData? Imdb { get; set; }
}

Para usar o driver MongoDB .NET/C# para adicionar um estágio $sortByCount a uma agregação pipeline, chame o método UnionWith() em um objeto PipelineDefinition.

O exemplo a seguir cria um estágio de pipeline que agrupa os Movie documentos recebidos pelo valor de seu campo Rated e, em seguida, retorna o número de documentos em cada grupo:

var pipeline = new EmptyPipelineDefinition<Movie>()
    .SortByCount(m => m.Rated);

{ "_id" : "...", "count" : 9894 }
{ "_id" : "R", "count" : 5537 }
{ "_id" : "PG-13", "count" : 2321 }
{ "_id" : "PG", "count" : 1852 }
{ "_id" : "APPROVED", "count" : 709 }
{ "_id" : "G", "count" : 477 }
{ "_id" : "PASSED", "count" : 181 }
{ "_id" : "TV-14", "count" : 89 }
{ "_id" : "TV-PG", "count" : 76 }
{ "_id" : "TV-MA", "count" : 60 }
{ "_id" : "TV-G", "count" : 59 }
{ "_id" : "GP", "count" : 44 }
{ "_id" : "M", "count" : 37 }
{ "_id" : "Approved", "count" : 5 }
{ "_id" : "AO", "count" : 3 }
{ "_id" : "TV-Y7", "count" : 3 }
{ "_id" : "OPEN", "count" : 1 }
{ "_id" : "Not Rated", "count" : 1 }

Os exemplos do Node.js nesta página utilizam o banco de dados do sample_mflix a partir dos conjuntos de dados de amostra do Atlas. Para saber como criar um cluster gratuito do MongoDB Atlas e carregar os conjuntos de dados de exemplo, consulte Introdução na documentação do driver do MongoDB Node.js

Para usar o driver Node.js do MongoDB para adicionar um estágio $sortByCount a um pipeline de agregação , use o operador $sortByCount em um objeto de pipeline.

O exemplo a seguir cria uma etapa de pipeline que agrupa os documentos de entrada movie pelo valor do campo rated e, em seguida, retorna a quantidade de documentos em cada grupo. O exemplo em seguida executa o pipeline de agregação:

const pipeline = [{ $sortByCount: "$rated" }];
const cursor = collection.aggregate(pipeline);
return cursor;

Voltar

$sort

$unionWith