cursor.sort()¶

Sort Stability排序稳定性¶

In MongoDB, sorts are inherently stable, unless sorting on a field which contains duplicate values:在MongoDB中，排序本质上是稳定的，除非对包含重复值的字段进行排序：

• a stable sort is one that returns the same sort order each time it is performed稳定排序是每次执行时返回相同排序顺序的排序
• an unstable sort is one that may return a different sort order when performed multiple times不稳定排序是指在多次执行时可能返回不同排序顺序的排序

If a stable sort is desired, include at least one field in your sort that contains exclusively 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() method to sort on the borough field:下面的命令使用sort()方法对borough字段进行排序：

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

In this example, the sort is unstable, 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. 文档是按borough的字母顺序返回的，但是在多次执行相同的排序时，具有重复borough值的文档的顺序可能不同。For example, here are the results from two different executions of the above command:例如，以下是上述命令的两次不同执行的结果：

{ "_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 stable sort, add a field which contains exclusively unique values to the sort. 要实现稳定排序，请在排序中添加一个包含唯一值的字段。The following command uses the sort() method to sort on both the borough field and the _id field:以下命令使用sort()方法对borough字段和_id字段进行排序：

db.restaurants.find().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字段始终保证包含唯一的值，因此在同一排序的多次执行中，返回的排序顺序始终相同。

Ascending/Descending Sort升序/降序排序¶

Specify in the sort parameter the field or fields to sort by and a value of 1 or -1 to specify an ascending or descending sort respectively.在sort参数中指定要排序的一个或多个字段，值为1或-1分别指定升序或降序排序。

The following operation sorts the documents first by the age field in descending order and then by the posts field in ascending order:以下操作首先按age字段降序排列文档，然后按ports字段升序排列文档：

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

When comparing values of different BSON types, MongoDB uses the following comparison order, from lowest to highest:在比较不同BSON类型的值时，MongoDB使用以下比较顺序，从最低到最高：

1. MinKey (internal type)
2. Null
3. Numbers (ints, longs, doubles, decimals)
4. Symbol, String
5. Object
6. Array
7. BinData
8. ObjectId
9. Boolean
10. Date
11. Timestamp
12. Regular Expression
13. MaxKey (internal type)

For details on the comparison/sort order for specific types, see Comparison/Sort Order.有关特定类型的比较/排序顺序的详细信息，请参阅比较/排序顺序。

Text Score Metadata Sort文本分数元数据排序¶

For a $text search, you can sort by descending relevance score using the { $meta: "textScore" } expression.对于$text搜索，您可以使用{ $meta: "textScore" }表达式，通过降低相关性分数进行排序。

The following sample document specifies a descending sort by the "textScore" metadata:以下示例文档按"textScore"元数据指定了降序排序：

db.users.find(
   { $text: { $search: "operating" } },
   { score: { $meta: "textScore" }}        // Optional starting in MongoDB 4.4
).sort({ score: { $meta: "textScore" } })

The "textScore" metadata sorts in descending order."textScore"元数据按降序排序。

For more information, see $meta for details.有关更多信息，请参阅$meta以了解详细信息。

Sort and Index Use排序和索引使用¶

MongoDB can obtain the results of a sort operation from an index which includes the sort fields. MongoDB可以从包含排序字段的索引中获取排序操作的结果。MongoDB may use multiple indexes to support a sort operation if the sort uses the same indexes as the query predicate.如果排序使用与查询谓词相同的索引，MongoDB可以使用多个索引来支持排序操作。

If MongoDB cannot use an index or indexes to obtain the sort order, MongoDB must perform a blocking sort operation on the data. 如果MongoDB无法使用一个或多个索引来获取排序顺序，MongoDB必须对数据执行阻塞排序操作。A blocking sort indicates that MongoDB must consume and process all input documents to the sort before returning results. 阻塞排序表示MongoDB必须在返回结果之前使用并处理所有输入文档。Blocking sorts do not block concurrent operations on the collection or database.阻止排序不会阻止集合或数据库上的并发操作。

Sort operations that use an index often have better performance than blocking sorts. 使用索引的排序操作通常比阻塞排序具有更好的性能。For more information on creating indexes to support sort operations, see Use Indexes to Sort Query Results.有关创建索引以支持排序操作的更多信息，请参阅使用索引对查询结果进行排序。

If MongoDB requires using more than 100 megabytes of system memory for the blocking sort operation, MongoDB returns an error unless the query specifies cursor.allowDiskUse() (New in MongoDB 4.4). 如果MongoDB需要使用超过100 MB的系统内存来执行阻塞排序操作，MongoDB将返回一个错误，除非查询指定cursor.allowDiskUse()（MongoDB 4.4中新增）。allowDiskUse() allows MongoDB to use temporary files on disk to store data exceeding the 100 megabyte system memory limit while processing a blocking sort operation.允许MongoDB在处理阻塞排序操作时，使用磁盘上的临时文件存储超过100 MB系统内存限制的数据。

To check if MongoDB must perform a blocking sort, append cursor.explain() to the query and check the explain results. 要检查MongoDB是否必须执行阻塞排序，请将cursor.explain()附加到查询并检查解释结果。If the query plan contains a SORT stage, then MongoDB must perform a blocking sort operation subject to the 100 megabyte memory limit.如果查询计划包含SORT阶段，则MongoDB必须在100 MB内存限制下执行阻塞排序操作。

To prevent blocking sorts from consuming too much memory:要防止阻塞排序占用过多内存，请执行以下操作：

• Create an index to support the sort operation. 创建索引以支持排序操作。See Use Indexes to Sort Query Results for more information and examples.有关更多信息和示例，请参阅使用索引对查询结果进行排序。
• Limit the amount of data to sort by using cursor.limit() with cursor.sort(). 使用cursor.limit()和cursor.sort()限制要排序的数据量。See Limit Results for more information and examples.有关更多信息和示例，请参阅限制结果。

Limit Results限制结果¶

You can use sort() in conjunction with limit() to return the first (in terms of the sort order) k documents, where k is the specified limit.可以将sort()与limit()结合使用，返回第一个（按照排序顺序）k个文档，其中k是指定的限制。

If MongoDB cannot obtain the sort order via an index scan, then MongoDB uses a top-k sort algorithm. 如果MongoDB无法通过索引扫描获得排序顺序，那么MongoDB将使用top-k排序算法。This algorithm buffers the first k results (or last, depending on the sort order) seen so far by the underlying index or collection access. 该算法缓冲底层索引或集合访问到目前为止看到的前k个结果（或最后一个，取决于排序顺序）。If at any point the memory footprint of these k results exceeds 100 megabytes, the query will fail unless the query specifies cursor.allowDiskUse() (New in MongoDB 4.4).如果在任何时候，这些k结果的内存占用超过100 MB，则查询将失败，除非查询指定cursor.allowDiskUse()（MongoDB 4.4中新增）。

Interaction with Projection与投影的交互作用¶

When a set of results are both sorted and projected, the MongoDB query engine will always apply the sorting first.当对一组结果进行排序和投影时，MongoDB查询引擎将始终首先应用排序。

Index Use索引使用¶

Queries that include a sort by $natural order do not use indexes to fulfill the query predicate with the following exception: If the query predicate is an equality condition on the _id field { _id: <value> }, then the query with the sort by $natural order can use the _id index.包含按$natural顺序排序的查询不使用索引来实现查询谓词，但以下情况除外：如果查询谓词是_id字段{ _id: <value> }上的相等条件，则具有按{ _id: <value> }顺序排序的查询可以使用_id索引。