/ /

Operadores

Operadores pipeline de agregação

Página inicial do Docs

Manual do banco de dados

Referência

Operadores

Operadores pipeline de agregação

$sortArray (agregação)

Esta versão da documentação foi arquivada e não é mais suportada. Para atualizar seu sistema do 6.0, consulte osprocedimentos de atualização do MongoDB 7.0 .

Definição

$sortArray

Novidades na versão 5.2.

Classifica uma array com base em seus elementos. A ordem de classificação é especificada pelo usuário.

$sortArray tem a seguinte sintaxe:

$sortArray: {
   input: <array>,
   sortBy: <sort spec>
}

Campo	Tipo	Descrição
`input`	expressão	A array a ser ordenada. O resultado é `null`, se a expressão: Avalia como ausente. Avalia como `null`. Avalia como `undefined`. Se a expressão avaliar como qualquer outro valor que não array, a operação resultará em um erro.
`sortBy`	documento ou booleano	O documento especifica uma ordem de classificação.

Comportamento

A expressão $sortArray ordena a array input de acordo com a especificação sortBy.

A sintaxe e semântica $sortArray são as mesmas que o comportamento em uma operação $push modificada por $sort.

Classificar por campos de documento

Se os elementos de array forem documentos, você poderá ordenar por um campo de documento. Especifique o nome do campo e uma direção de ordenação, crescente (1) ou decrescente (-1).

{
   input: <array-of-documents>,
   sortBy: { <document-field>: <sort-direction> }
}

Ordenar por valor

Para classificar toda a array por valor ou por elementos de array que não sejam documentos, identifique a array de entrada e especifique 1 para uma ordem crescente ou -1 para uma ordem decrescente no parâmetro sortBy.

{
   input: <array-of-documents>,
   sortBy: <sort-direction>
}

Considerações

Não há traversal implícita de array na chave de ordenação.
Operadores posicionais não são suportados. Um nome de campo como "valores.1" denota um campo chamado "1" na array values. Não se refere ao item no índice 1 na array values.
Quando uma array inteira é ordenada, a ordem é lexicográfica. O estágio de aggregation $sort se comporta de forma diferente. Consulte $sort para obter mais detalhes.
Quando uma array é classificada por um campo, todos os documentos ou escalares que não têm o campo especificado são classificados igualmente. A ordem de classificação resultante é indefinida.
null valores existentes e valores ausentes são ordenados igualmente.

Estabilidade da ordenação

A estabilidade da ordenação não está especificada. Os usuários não devem confiar em $sortArray para usar um algoritmo de ordenação específico.

Exemplos

Os exemplos nesta seção usam uma array team em uma collection engineers.

db.engineers.insertOne(
   {
      team:
         [
            {
               name: "pat",
               age: 30,
               address: { street: "12 Baker St", city: "London" }
            },
            {
               name: "dallas",
               age: 36,
               address: { street: "12 Cowper St", city: "Palo Alto" }
            },
            {
              name: "charlie",
              age: 42,
              address: { street: "12 French St", city: "New Brunswick" }
            }
         ]
   }
)

A array team tem três elementos. Cada elemento de team tem subelementos agrupados: name, age e address. Os exemplos seguintes mostram como ordenar a array team utilizando estes subelementos.

Ordenar em um campo

A seguinte operação classifica no campo name dentro da array team:

db.engineers.aggregate( [
   { $project:
      {
         _id: 0,
         result:
            {
               $sortArray: { input: "$team", sortBy: { name: 1 } }
            }
      }
   }
] )

A operação retorna os seguintes resultados:

{
   result:
      [
         {
            name: 'charlie',
            age: 42,
            address: { street: '12 French St', city: 'New Brunswick' }
         },
         {
            name: 'dallas',
            age: 36,
            address: { street: '12 Cowper St', city: 'Palo Alto' }
         },
         {
            name: 'pat',
            age: 30,
            address: { street: '12 Baker St', city: 'London' }
         }
      ]
}

Ordenar em um subcampo

A seguinte operação utiliza notação de ponto para ordenar a array com base no subcampo address:

db.engineers.aggregate( [
   {
      $project:
         {
                _id: 0,
                result:
               {
                  $sortArray:
                     {
                        input: "$team",
                        sortBy: { "address.city": -1 }
                     }
               }
             }
   }
] )

A direção de ordenação é decrescente porque o valor sortBy é "-1".

{
   result: [
      {
         name: 'dallas',
         age: 36,
         address: { street: '12 Cowper St', city: 'Palo Alto' }
      },
      {
         name: 'charlie',
         age: 42,
         address: { street: '12 French St', city: 'New Brunswick' }
      },
      {
         name: 'pat',
         age: 30,
         address: { street: '12 Baker St', city: 'London' }
      }
  ]
}

Classificar em Vários Campos

A seguinte operação especifica múltiplos campos de índice para fazer uma ordenação composta dentro da operação $sortArray:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
               {
                  $sortArray:
                     {
                        input: "$team",
                        sortBy: { age: -1, name: 1 }
                     }
               }
         }
    }
 ] )

Saída de exemplo:

{
   result: [
      {
         name: 'charlie',
         age: 42,
         address: { street: '12 French St', city: 'New Brunswick' }
      },
      {
         name: 'dallas',
         age: 36,
         address: { street: '12 Cowper St', city: 'Palo Alto' }
      },
      {
         name: 'pat',
         age: 30,
         address: { street: '12 Baker St', city: 'London' }
      }
   ]
}

Ordenar uma array de números inteiros

Este exemplo especifica uma array de entrada diretamente. Os valores são todos do mesmo tipo, Int32:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
               {
                  $sortArray:
                     {
                         input: [ 1, 4, 1, 6, 12, 5 ],
                         sortBy: 1
                     }
               }
         }
   }
] )

Saída de exemplo:

[ { result: [ 1, 1, 4, 5, 6, 12 ] } ]

A array de entrada tem um "1" na posição 0 e na posição 2. Os números "1" são agrupados nos resultados, mas não há garantias sobre como o grupo de "1" é ordenado em relação à sua ordem original.

Classificar em campos de tipo misto

Este exemplo especifica uma array de entrada diretamente. Os valores têm tipos diferentes:

db.engineers.aggregate( [
   {
      $project:
         {
            _id: 0,
            result:
            {
               $sortArray:
                  {
                     input: [ 20, 4, { a: "Free" }, 6, 21, 5, "Gratis",
                             { a: null }, { a: { sale: true, price: 19 } },
                             Decimal128( "10.23" ), { a: "On sale" } ],
                     sortBy: 1
                  }
            }
         }
   }
] )

Saída de exemplo:

{ result:
   [
      4,
      5,
      6,
      Decimal128("10.23"),
      20,
      21,
      'Gratis',
      { a: null },
      { a: 'Free' },
      { a: 'On sale' },
      { a: { sale: true, price: 19 } }
   ]
}

Os resultados são ordenados.

Por outro lado, depois de alterar o campo sortBy para ordenar o "1" dos campos de documento, sortBy: { a: 1 }, a ordem de classificação para os valores escalares e null é indefinida:

{ result:
    [
       20,
       4,
       6,
       21,
       5,
       'Gratis',
       { a: null },
       Decimal128("10.23"),
       { a: 'Free' },
       { a: 'On sale' },
       { a: { sale: true, price: 19 } }
    ]
 }

Voltar

$slice

$split