$sort (agregación)

Rendimiento

$sort es una etapa de bloqueo, que hace que el pipeline espere a que se recuperen todos los datos de entrada para la etapa de bloqueo antes del procesamiento de los datos. Una etapa de bloqueo puede reducir el rendimiento porque disminuye el procesamiento paralelo en un pipeline con múltiples etapas. Una etapa de bloqueo también puede utilizar cantidades sustanciales de memoria para grandes conjuntos de datos.

Límites

• Puedes ordenar sobre un máximo de 32 claves.

• Proveer un patrón de ordenación con campos duplicados causa un error.

Coherencia de clasificación

MongoDB no almacena documentos en una colección en un orden específico. Al ordenar en un campo que contiene valores duplicados, los documentos que contienen esos valores pueden ser devueltos en cualquier orden.

Si se desea un orden de clasificación coherente, se debe incluir al menos un campo en la clasificación que contenga valores únicos. La forma más sencilla de garantizar esto es incluir el campo _id en la query de ordenación.

Considere la siguiente colección 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"},
] )

El siguiente comando utiliza la etapa $sort para ordenar en el campo borough:

db.restaurants.aggregate(
   [
     { $sort : { borough : 1 } }
   ]
)

En este ejemplo, el orden de clasificación puede ser inconsistente, ya que el campo borough contiene valores duplicados tanto para Manhattan como para Brooklyn. Los documentos se devuelven en orden alfabético por borough, pero el orden de aquellos documentos con valores duplicados para borough podría no ser el mismo en múltiples ejecuciones del mismo ordenamiento. Por ejemplo, aquí están los resultados de dos ejecuciones diferentes del comando mencionado anteriormente:

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

Aunque los valores para borough aún se ordenan alfabéticamente, el orden de los documentos que contienen valores duplicados para borough (es decir, Manhattan y Brooklyn) no son lo mismo.

Para lograr una clasificación coherente, agrega un campo que contenga valores exclusivamente únicos a la clasificación. El siguiente comando usa la etapa $sort para ordenar tanto en el campo borough como en el campo _id:

db.restaurants.aggregate(
   [
     { $sort : { borough : 1, _id: 1 } }
   ]
)

Dado que siempre se garantiza que el campo _id contendrá valores exclusivamente únicos, el orden de clasificación devuelto siempre será el mismo en múltiples ejecuciones del mismo ordenamiento.

Ordenar por un campo de arreglo

Cuando MongoDB ordena documentos por un campo cuyo valor es un arreglo, la clave de ordenación depende de si el orden es ascendente o descendente:

• En una ordenación ascendente, la clave de ordenación es el valor más bajo del arreglo.

• En una ordenación descendente, la clave de ordenación es el valor más alto del arreglo.

El filtro de query no afecta la selección de la clave de ordenación.

Por ejemplo, cree una colección shoes con estos documentos:

db.shoes.insertMany( [
   { _id: 'A', sizes: [ 7, 11 ] },
   { _id: 'B', sizes: [ 8, 9, 10 ] }
] )

Las siguientes queries ordenan los documentos por el campo sizes en orden ascendente y descendente:

// Ascending sort
db.shoes.aggregate( [
   {
      $sort: { sizes: 1 }
   }
] )
// Descending sort
db.shoes.aggregate( [
   {
      $sort: { sizes: -1 }
   }
] )

Ambas queries anteriores devuelven el documento con _id: 'A' primero porque los tamaños 7 y 11 son el más bajo y el más alto en las entradas del arreglo sizes, respectivamente.

db.shoes.aggregate( [
   {
      $match: { sizes: { $gt: 9 } }
   },
   {
      $sort: { sizes: 1 }
   }
] )

$sort + $limit Optimización de Memoria

Cuando un $sort precede a un $limit y no hay etapas intermedias que modifiquen el número de documentos, el optimizador puede fusionar el $limit con el $sort. Esto permite que la operación de $sort solo mantenga los n mejores resultados a medida que avanza, donde n es el límite especificado, y garantiza que MongoDB solo necesite almacenar n elementos en memoria. Esta optimización sigue aplicándose cuando allowDiskUse es true y los elementos de n superan el límite de memoria de agregación.

Las optimizaciones están sujetas a cambios entre versiones.

$sort y restricciones de memoria

A partir de MongoDB 6.0, las etapas de la canalización que requieren más de 100 megabytes de memoria para ejecutarse escriben archivos temporales en el disco de forma predeterminada. Estos archivos temporales duran mientras se ejecuta la canalización y pueden afectar el espacio de almacenamiento de la instancia. En versiones anteriores de MongoDB, se debía pasar { allowDiskUse: true } a los comandos find y aggregate para habilitar este comportamiento.

Los comandos individuales find y aggregate pueden anular el parámetro allowDiskUseByDefault de las siguientes maneras:

• Se utiliza { allowDiskUse: true } para permitir la escritura de archivos temporales en el disco cuando allowDiskUseByDefault se establece en false

• Se utiliza { allowDiskUse: false } para prohibir la escritura de archivos temporales en el disco cuando allowDiskUseByDefault esté configurado en true

Para obtener más información, consulte Límites de pipeline de agregación.