Menu Docs

Página inicial do DocsDesenvolver aplicaçõesManual do MongoDB

cursor.sort()

Nesta página

  • Definição
  • Compatibilidade
  • Sintaxe
  • Comportamento
  • Exemplos
  • Retorno em ordem natural
cursor.sort(sort)

Importante

Método mongosh

Este é um método mongosh . Esta não é a documentação de Node.js ou de outros métodos de driver específicos da linguagem de programação.

Na maioria dos casos, métodos mongosh funcionam da mesma forma que os métodos legados do shell mongo . No entanto, alguns métodos legados não estão disponíveis em mongosh.

Para a documentação do shell legado mongo, consulte a documentação para a release correspondente do MongoDB Server:

Para drivers de API do MongoDB, consulte a documentação do driver MongoDB específica do idioma.

Especifica a ordem na qual a query retorna documentos correspondentes. Você deve aplicar sort() ao cursor antes de recuperar quaisquer documentos do banco de dados.

Você pode utilizar o cursor.sort(sort) para implantações hospedadas nos seguintes ambientes:

  • MongoDB Atlas: o serviço totalmente gerenciado para implantações MongoDB na nuvem

O método sort() tem o seguinte parâmetro:

Parâmetro
Tipo
Descrição
sort
documento
Um documento que define a ordem de classificação do conjunto de resultados.

O parâmetro sort contém pares de campo e valor, no seguinte formato:

{ field: value }

O documento de classificação pode especificar classificação crescente ou decrescente em campos existentes ou classificação em metadados de pontuação de texto.

Você pode ordenar o máximo de 32 chaves.

O MongoDB não armazena documentos em uma collection em uma ordem específica. Ao ordenar em um campo que contém valores duplicados, os documentos que contêm esses valores podem ser retornados em qualquer ordem.

Se desejar uma ordem de classificação consistente, inclua pelo menos um campo em sua ordenação que contenha valores exclusivos. A maneira mais fácil de garantir isso é incluir o campo _id em sua query de ordenação.

Considere a seguinte collection restaurant:

db.restaurants.insertMany( [
{ "_id" : 1, "name" : "Central Park Cafe", "borough" : "Manhattan"},
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "borough" : "Queens"},
{ "_id" : 3, "name" : "Empire State Pub", "borough" : "Brooklyn"},
{ "_id" : 4, "name" : "Stan's Pizzaria", "borough" : "Manhattan"},
{ "_id" : 5, "name" : "Jane's Deli", "borough" : "Brooklyn"},
] );

O seguinte comando utiliza o método sort() para classificar no campo borough :

db.restaurants.find().sort( { "borough": 1 } )

Neste exemplo, a ordem de classificação pode ser inconsistente, pois o campo borough contém valores duplicados para Manhattan e Brooklyn. Os documentos são devolvidos em ordem alfabética por borough, mas a ordem desses documentos com valores duplicados para borough pode não ser a mesma em várias execuções da mesma classificação. Por exemplo, aqui estão os resultados de duas execuções diferentes do comando acima:

{ "_id" : 3, "name" : "Empire State Pub", "borough" : "Brooklyn" }
{ "_id" : 5, "name" : "Jane's Deli", "borough" : "Brooklyn" }
{ "_id" : 1, "name" : "Central Park Cafe", "borough" : "Manhattan" }
{ "_id" : 4, "name" : "Stan's Pizzaria", "borough" : "Manhattan" }
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "borough" : "Queens" }
{ "_id" : 5, "name" : "Jane's Deli", "borough" : "Brooklyn" }
{ "_id" : 3, "name" : "Empire State Pub", "borough" : "Brooklyn" }
{ "_id" : 4, "name" : "Stan's Pizzaria", "borough" : "Manhattan" }
{ "_id" : 1, "name" : "Central Park Cafe", "borough" : "Manhattan" }
{ "_id" : 2, "name" : "Rock A Feller Bar and Grill", "borough" : "Queens" }

Embora os valores para borough ainda estejam em ordem alfabética, a ordem dos documentos que contêm valores duplicados para borough (ou seja, Manhattan e Brooklyn) não é a mesma.

Para obter uma classificação consistente, adicione um campo que contenha exclusivamente valores únicos à classificação. O comando a seguir usa o método sort() para classificar tanto o campo borough quanto o campo _id :

db.restaurants.find().sort( { "borough": 1, "_id": 1 } )

Como é sempre garantido que o campo _id contenha exclusivamente valores únicos, a ordem de classificação retornada será sempre a mesma em várias execuções da mesma ordenação.

Especifique no parâmetro de classificação o campo ou campos para classificar por e um valor de 1 ou -1 para especificar uma classificação crescente ou decrescente, respectivamente.

A operação a seguir classifica os documentos primeiro pelo campo age em ordem decrescente e, em seguida, pelo campo posts em ordem crescente:

db.users.find({ }).sort( { age : -1, posts: 1 } )

Ao comparar valores de diferentes tipos de BSON em operações de ordenação, o MongoDB usa a seguinte ordem de comparação, da menor para a maior:

  1. MinKey (tipo interno)

  2. Zero

  3. Números (inteiros, longos, duplos, decimais)

  4. Símbolo, string

  5. Objeto

  6. Array

  7. BinData

  8. ObjectId

  9. Boolean

  10. Data

  11. Timestamp

  12. Expressão regular

  13. MaxKey (tipo interno)

Para obter detalhes sobre a ordem de comparação/classificação para tipos específicos, consulte Ordem de comparação/classificação.

Para uma $text procurar, você pode classificar por pontuação de relevância descendente usando a expressão { $meta: "textScore" }.

O seguinte documento de amostra especifica uma classificação decrescente pelos metadados do "textScore":

db.users.find(
{ $text: { $search: "operating" } },
{ score: { $meta: "textScore" }}
).sort({ score: { $meta: "textScore" } })

Os metadados "textScore" são classificados em ordem decrescente.

Para mais informações, consulte $meta para detalhes.

O MongoDB pode obter os resultados de uma operação de classificação a partir de um índice que inclui os campos de classificação. O MongoDB pode usar vários índices para oferecer suporte a uma operação de classificação se a classificação usar os mesmos índices que o predicado de query.

Se o MongoDB não puder usar um índice ou índices para obter a ordem de classificação, o MongoDB deverá executar uma operação de classificação de bloqueio nos dados. Uma classificação de bloqueio indica que o MongoDB deve consumir e processar todos os documentos de entrada para a classificação antes de retornar os resultados. As classificações de bloqueio não bloqueiam operações simultâneas na coleção ou no banco de dados.

As operações de classificação que usam um índice geralmente têm melhor desempenho do que os ordenadores bloqueantes. Para obter mais informações sobre como criar índices para dar suporte a operações de classificação, consulte Usar índices para classificar resultados de queries.

Se o MongoDB exigir o uso de mais de 100 megabytes de memória do sistema para a operação de block sort, o MongoDB retornará um erro a menos que a consulta especifique cursor.allowDiskUse(). allowDiskUse() permite que o MongoDB use arquivos temporários no disco para armazenar dados que excedam o 100 limite de memória do sistema de megabyte ao processar uma block sort.

Para verificar se o MongoDB deve executar uma ordenação bloqueante, acrescente cursor.explain() à query e verifique os resultados da explicação. Se o plano de query contiver um estágio SORT, o MongoDB deverá executar uma operação de ordenador bloqueante sujeita ao limite de memória de 100 megabytes.

Para evitar que as ordenadores bloqueantes consumam muita memória:

Dica

Você pode usar sort() em conjunto com limit() para retornar os primeiros (em termos da ordem de classificação) k documentos, em que k é o limite especificado.

Se o MongoDB não conseguir obter a ordem de classificação por meio de uma varredura de índice, o MongoDB usará um algoritmo de classificação top-k. Este algoritmo armazena os primeiros k resultados (ou último, dependendo da ordem de classificação) vistos até agora pelo índice subjacente ou acesso à collection. Se a qualquer momento o espaço de memória desses k resultados exceder 100 megabytes, a consulta falhará a menos que a consulta especifique cursor.allowDiskUse().

Quando um conjunto de resultados é classificado e projetado, o mecanismo de query MongoDB sempre aplicará a classificação primeira.

Uma coleção orders contém os seguintes documentos:

{ _id: 1, item: { category: "cake", type: "chiffon" }, amount: 10 }
{ _id: 2, item: { category: "cookies", type: "chocolate chip" }, amount: 50 }
{ _id: 3, item: { category: "cookies", type: "chocolate chip" }, amount: 15 }
{ _id: 4, item: { category: "cake", type: "lemon" }, amount: 30 }
{ _id: 5, item: { category: "cake", type: "carrot" }, amount: 20 }
{ _id: 6, item: { category: "brownies", type: "blondie" }, amount: 10 }

A seguinte query, que retorna todos os documentos da coleção orders, não especifica uma ordem de classificação:

db.orders.find()

A query retorna os documentos em ordem indeterminada:

{ "_id" : 1, "item" : { "category" : "cake", "type" : "chiffon" }, "amount" : 10 }
{ "_id" : 2, "item" : { "category" : "cookies", "type" : "chocolate chip" }, "amount" : 50 }
{ "_id" : 3, "item" : { "category" : "cookies", "type" : "chocolate chip" }, "amount" : 15 }
{ "_id" : 4, "item" : { "category" : "cake", "type" : "lemon" }, "amount" : 30 }
{ "_id" : 5, "item" : { "category" : "cake", "type" : "carrot" }, "amount" : 20 }
{ "_id" : 6, "item" : { "category" : "brownies", "type" : "blondie" }, "amount" : 10 }

A seguinte query especifica uma classificação no campo amount em ordem decrescente.

db.orders.find().sort( { amount: -1 } )

A query retorna os seguintes documentos, em ordem decrescente de amount:

{ "_id" : 2, "item" : { "category" : "cookies", "type" : "chocolate chip" }, "amount" : 50 }
{ "_id" : 4, "item" : { "category" : "cake", "type" : "lemon" }, "amount" : 30 }
{ "_id" : 5, "item" : { "category" : "cake", "type" : "carrot" }, "amount" : 20 }
{ "_id" : 3, "item" : { "category" : "cookies", "type" : "chocolate chip" }, "amount" : 15 }
{ "_id" : 1, "item" : { "category" : "cake", "type" : "chiffon" }, "amount" : 10 }
{ "_id" : 6, "item" : { "category" : "brownies", "type" : "blondie" }, "amount" : 10 }

A query a seguir especifica a ordem de classificação usando os campos de um documento incorporado item. A query classifica primeiro pelo campo category em ordem crescente e, em seguida, dentro de cada category, pelo campo type em ordem crescente.

db.orders.find().sort( { "item.category": 1, "item.type": 1 } )

A query retorna os seguintes documentos, ordenados primeiro pelo campo category e dentro de cada categoria, pelo campo type:

{ "_id" : 6, "item" : { "category" : "brownies", "type" : "blondie" }, "amount" : 10 }
{ "_id" : 5, "item" : { "category" : "cake", "type" : "carrot" }, "amount" : 20 }
{ "_id" : 1, "item" : { "category" : "cake", "type" : "chiffon" }, "amount" : 10 }
{ "_id" : 4, "item" : { "category" : "cake", "type" : "lemon" }, "amount" : 30 }
{ "_id" : 2, "item" : { "category" : "cookies", "type" : "chocolate chip" }, "amount" : 50 }
{ "_id" : 3, "item" : { "category" : "cookies", "type" : "chocolate chip" }, "amount" : 15 }

O parâmetro $natural retorna itens de acordo com sua ordem natural dentro do banco de dados. Este pedido é um recurso de implementação interna, e você não deve confiar em nenhum pedido específico dos documentos.

Queries que incluem uma classificação por $natural pedido não usam índices para preencher o predicado de consulta com a seguinte exceção: Se o predicado de consulta for uma condição de igualdade no _id campo { _id: <value> }, então a consulta com a ordem de classificação por $natural pode usar o índice _id.

Dica

Veja também:

← cursor.skip()