$sort (aggregation stage)（聚合阶段）

Performance演出

$sort is a blocking stage, which causes the pipeline to wait for all input data to be retrieved for the blocking stage before processing the data. A blocking stage may reduce performance because it reduces parallel processing for a pipeline with multiple stages. A blocking stage may also use substantial amounts of memory for large data sets.是一个阻塞阶段，它使管道在处理数据之前等待所有输入数据被检索到阻塞阶段。阻塞阶段可能会降低性能，因为它减少了具有多个阶段的流水线的并行处理。阻塞阶段也可能为大型数据集使用大量内存。

Limits限制

• You can sort on a maximum of 32 keys.您最多可以对32个键进行排序。
• Providing a sort pattern with duplicate fields causes an error.提供具有重复字段的排序模式会导致错误。

Sort Consistency排序一致性

MongoDB does not store documents in a collection in a particular order. When sorting on a field which contains duplicate values, documents containing those values may be returned in any order.MongoDB不会以特定顺序将文档存储在集合中。在对包含重复值的字段进行排序时，包含这些值的文档可以按任何顺序返回。

The $sort operation is not a "stable sort," which means that documents with equivalent sort keys are not guaranteed to remain in the same relative order in the output as they were in the input.$sort操作不是“稳定排序”，这意味着具有等效排序键的文档不能保证在输出中保持与输入中相同的相对顺序。

If the field specified in the sort criteria does not exist in two documents, then the value on which they are sorted is the same. The two documents may be returned in any order.如果排序条件中指定的字段在两个文档中不存在，则对它们进行排序的值是相同的。这两份文件可以按任何顺序退回。

If consistent sort order is desired, include at least one field in your sort that contains unique values. The easiest way to guarantee this is to include the _id field in your sort query.如果需要一致的排序顺序，请在排序中至少包含一个包含唯一值的字段。保证这一点的最简单方法是在排序查询中包含_id字段。

Consider the following restaurant 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"},
] )

The following command uses the $sort stage to sort on the borough field:以下命令使用$sort阶段对borough字段进行排序：

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

In this example, sort order may be inconsistent, since the borough field contains duplicate values for both Manhattan and Brooklyn. 在这个例子中，排序顺序可能不一致，因为borough（行政区）字段包含Manhattan（曼哈顿）和Brooklyn（布鲁克林）的重复值。Documents are returned in alphabetical order by borough, but the order of those documents with duplicate values for borough might not the be the same across multiple executions of the same sort. For example, here are the results from two different executions of the above command:文档按borough按字母顺序返回，但borough值重复的文档的顺序在同一排序的多个执行中可能不同。例如，以下是上述命令的两次不同执行的结果：

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

While the values for borough are still sorted in alphabetical order, the order of the documents containing duplicate values for borough (i.e. Manhattan and Brooklyn) is not the same.虽然borough的值仍然按字母顺序排序，但包含borough重复值的文档（即Manhattan和Brooklyn）的顺序并不相同。

To achieve a consistent sort, add a field which contains exclusively unique values to the sort. The following command uses the $sort stage to sort on both the borough field and the _id field:为了实现一致的排序，请在排序中添加一个仅包含唯一值的字段。以下命令使用$sort阶段对borough字段和_id字段进行排序：

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

Since the _id field is always guaranteed to contain exclusively unique values, the returned sort order will always be the same across multiple executions of the same sort.由于_id字段总是保证只包含唯一值，因此返回的排序顺序在同一排序的多个执行中总是相同的。

Sort by an Array Field按数组字段排序

When MongoDB sorts documents by an array-value field, the sort key depends on whether the sort is ascending or descending:当MongoDB按数组值字段对文档进行排序时，排序键取决于排序是升序还是降序：

• In an ascending sort, the sort key is the lowest value in the array.在升序排序中，排序键是数组中的最低值。
• In a descending sort, the sort key is the highest value in the array.在降序排序中，排序键是数组中的最高值。

The query filter does not affect sort key selection.查询筛选器不影响排序键选择。

For example, create a shoes collection with these documents:例如，使用以下文档创建shoes集合：

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

The following queries sort the documents by the sizes field in ascending and descending order:以下查询按sizes字段按升序和降序对文档进行排序：

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

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

Both of the preceding queries return the document with _id: 'A' first because sizes 7 and 11 are the lowest and highest in the entries in the sizes array, respectively.前面的两个查询都首先返回_id: 'A'的文档，因为大小7和11分别是sizes数组中条目的最低和最高值。

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

$sort + $limit Memory Optimization内存优化

When a $sort precedes a $limit and there are no intervening stages that modify the number of documents, the optimizer can coalesce the $limit into the $sort. 当$sort位于$limit之前，并且没有修改文档数量的中间阶段时，优化器可以将$limit合并到$sort中。This allows the $sort operation to only maintain the top n results as it progresses, where n is the specified limit, and ensures that MongoDB only needs to store n items in memory. 这允许$sort操作在执行过程中只维护前n个结果，其中n是指定的限制，并确保MongoDB只需要在内存中存储n个项目。This optimization still applies when allowDiskUse is true and the n items exceed the aggregation memory limit.当allowDiskUse为真并且n个项目超过聚合内存限制时，此优化仍然适用。

Optimizations are subject to change between releases.优化可能会在不同版本之间发生变化。

$sort and Memory Restrictions和内存限制

Starting in MongoDB 6.0, pipeline stages that require more than 100 megabytes of memory to execute write temporary files to disk by default. These temporary files last for the duration of the pipeline execution and can influence storage space on your instance. 从MongoDB 6.0开始，默认情况下，需要超过100兆字节内存来执行将临时文件写入磁盘的流水线阶段。这些临时文件在管道执行期间持续存在，并可能影响实例上的存储空间。In earlier versions of MongoDB, you must pass { allowDiskUse: true } to individual find and aggregate commands to enable this behavior.在早期版本的MongoDB中，您必须将{ allowDiskUse: true }传递给单个find和aggregate命令以启用此行为。

Individual find and aggregate commands can override the allowDiskUseByDefault parameter by either:单个find和aggregate命令可以通过以下任一方式覆盖allowDiskUseByDefault参数：

• Using { allowDiskUse: true } to allow writing temporary files out to disk when allowDiskUseByDefault is set to false当allowDiskUseByDefault设置为false时，使用{ allowDiskUse: true }允许将临时文件写入磁盘
• Using { allowDiskUse: false } to prohibit writing temporary files out to disk when allowDiskUseByDefault is set to true当allowDiskUseByDefault设置为true时，使用{ allowDiskUse: false }禁止将临时文件写入磁盘

For additional details, see Aggregation Pipeline Limits.有关更多详细信息，请参阅聚合管道限制。