MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

MongoDB聚合框架中的排序阶段实践

2021-02-135.5k 阅读

MongoDB聚合框架基础概述

在深入探讨MongoDB聚合框架中的排序阶段之前，我们先来简要回顾一下聚合框架的整体概念。MongoDB的聚合框架提供了一种强大的方式来处理数据，它允许我们对集合中的文档进行一系列操作，如过滤、分组、计算和排序等，以生成复杂的聚合结果。

聚合操作通过管道（pipeline）的方式进行，管道由多个阶段（stage）组成，每个阶段对输入的文档执行特定的操作，并将结果传递给下一个阶段。这种链式处理方式使得我们能够逐步构建复杂的数据处理逻辑。例如，我们可以先使用$match阶段过滤出符合特定条件的文档，然后使用$group阶段对这些文档进行分组并计算统计信息，最后使用其他阶段进行进一步的处理。

排序阶段 $sort 简介

$sort 的基本语法

排序阶段$sort是聚合框架中用于对文档进行排序的关键阶段。其基本语法如下：

{
    $sort: {
        field1: order1,
        field2: order2,
        ...
    }
}

在上述语法中，field1、field2等是文档中的字段名，order1、order2等表示排序的顺序。排序顺序取值为1或-1，1表示升序（从小到大），-1表示降序（从大到小）。例如，如果我们要按age字段升序排序，可以这样写：

{
    $sort: {
        age: 1
    }
}

若要按name字段降序排序，则可以写成：

{
    $sort: {
        name: -1
    }
}

多字段排序

$sort阶段还支持对多个字段进行排序。在多字段排序时，MongoDB会首先按第一个字段进行排序，如果第一个字段的值相同，则按第二个字段排序，以此类推。例如，假设我们有一个存储用户信息的集合，其中包含age和name字段，我们希望先按age升序排序，对于年龄相同的用户再按name降序排序，可以这样编写$sort阶段：

{
    $sort: {
        age: 1,
        name: -1
    }
}

在这个例子中，年龄较小的用户会排在前面，对于年龄相同的用户，姓氏在字母表中靠后的会排在前面。

实际应用场景中的排序

按数值字段排序

  1. 简单数值排序 假设我们有一个集合products，存储了各种商品的信息，其中包含price字段表示商品价格。如果我们想要获取价格最低的商品列表，可以使用以下聚合管道：
db.products.aggregate([
    {
        $sort: {
            price: 1
        }
    }
]);

上述代码会将products集合中的文档按price字段升序排序，这样价格最低的商品会排在结果集的前面。 2. 复杂数值排序（结合其他操作） 有时候，我们可能需要在过滤数据后再进行排序。例如，我们只想获取价格大于100的商品，并按价格降序排序。这时候可以结合$match阶段和$sort阶段：

db.products.aggregate([
    {
        $match: {
            price: { $gt: 100 }
        }
    },
    {
        $sort: {
            price: -1
        }
    }
]);

在这个例子中，$match阶段首先过滤出价格大于100的商品，然后$sort阶段对这些商品按价格降序排序。

按日期字段排序

  1. 按创建时间排序 在很多应用中，文档会包含一个表示创建时间的字段，比如createdAt。假设我们有一个posts集合存储文章信息，每篇文章都有createdAt字段记录创建时间。如果我们想要按文章创建时间的先后顺序展示文章，可以使用以下聚合管道：
db.posts.aggregate([
    {
        $sort: {
            createdAt: 1
        }
    }
]);

这样会按createdAt字段升序排序，最早创建的文章会排在前面。 2. 获取最近的记录 如果我们只想获取最近发布的几篇文章，可以在排序后结合$limit阶段。例如，获取最近发布的5篇文章：

db.posts.aggregate([
    {
        $sort: {
            createdAt: -1
        }
    },
    {
        $limit: 5
    }
]);

这里$sort阶段先按createdAt字段降序排序，使最新发布的文章排在前面，然后$limit阶段只取前5篇文章。

按字符串字段排序

  1. 字母顺序排序 对于包含字符串字段的集合，比如users集合中的name字段，我们可以按字母顺序排序。假设我们要按用户名字的升序排序，可以这样写：
db.users.aggregate([
    {
        $sort: {
            name: 1
        }
    }
]);

这样会按name字段的字母顺序升序排列用户文档。 2. 多语言字符串排序 在处理多语言字符串时，需要注意不同语言的字符编码和排序规则。MongoDB支持通过指定语言特定的排序规则来处理这种情况。例如，对于法语字符串的排序，可以使用以下方式：

db.frenchUsers.aggregate([
    {
        $sort: {
            name: { $sortBy: { locale: "fr", numericOrdering: true } }
        }
    }
]);

这里通过$sortBy子操作符指定了法语（fr）的排序规则，numericOrdering: true表示按数字顺序排序，这在处理包含数字的字符串时很有用。

与其他聚合阶段的协同工作

$sort 与 $match 的协同

  1. 先过滤后排序 如前文提到的按价格过滤商品并排序的例子，先使用$match阶段过滤出符合条件的文档，再使用$sort阶段进行排序，这样可以减少排序的数据量，提高效率。例如，在一个包含大量商品的集合中，先过滤出价格在某个范围内的商品，再对这些商品进行排序：
db.products.aggregate([
    {
        $match: {
            price: { $gte: 50, $lte: 150 }
        }
    },
    {
        $sort: {
            price: -1
        }
    }
]);
  1. 先排序后过滤 在某些情况下，先排序再过滤也有其优势。比如我们要获取按某个字段排序后的前几个文档中符合特定条件的文档。假设我们有一个employees集合，包含salary和department字段，我们要获取按salary降序排序后，department为"Engineering"的前10名员工：
db.employees.aggregate([
    {
        $sort: {
            salary: -1
        }
    },
    {
        $match: {
            department: "Engineering"
        }
    },
    {
        $limit: 10
    }
]);

这里先按salary降序排序，然后过滤出department为"Engineering"的员工，最后取前10名。

$sort 与 $group 的协同

  1. 分组后排序 当我们对数据进行分组并计算统计信息后，可能需要对分组结果进行排序。例如，在一个存储销售记录的集合sales中，我们按product字段分组并计算每个产品的总销售额，然后按总销售额降序排序：
db.sales.aggregate([
    {
        $group: {
            _id: "$product",
            totalSales: { $sum: "$amount" }
        }
    },
    {
        $sort: {
            totalSales: -1
        }
    }
]);

这里$group阶段按product分组并计算总销售额，$sort阶段按总销售额降序排序，这样可以得到总销售额最高的产品排在前面的结果。 2. 排序后分组 先排序再分组也可能有其用途。比如我们要按日期对销售记录进行分组，但希望每个日期组内的记录按金额升序排列。假设sales集合包含date和amount字段：

db.sales.aggregate([
    {
        $sort: {
            date: 1,
            amount: 1
        }
    },
    {
        $group: {
            _id: "$date",
            salesList: { $push: "$$ROOT" }
        }
    }
]);

这里先按date升序和amount升序排序，然后按date分组，$push操作符将每个日期组内的记录推到一个数组salesList中，由于之前已经排序，每个日期组内的记录会按金额升序排列。

$sort 与 $project 的协同

  1. 投影后排序 $project阶段用于选择要包含在输出文档中的字段，也可以对字段进行计算和重命名等操作。在投影后进行排序可以确保输出结果的字段符合我们的要求且按指定顺序排列。例如，在users集合中，我们只想要输出name和age字段，并按age升序排序：
db.users.aggregate([
    {
        $project: {
            name: 1,
            age: 1,
            _id: 0
        }
    },
    {
        $sort: {
            age: 1
        }
    }
]);

这里$project阶段选择了name和age字段并排除了_id字段，然后$sort阶段按age升序排序。 2. 排序后投影 先排序再投影也有实际意义。比如我们已经按某个复杂的排序逻辑对文档进行了排序，然后只希望输出排序后的部分关键信息。假设我们在products集合中按price和rating等多个字段进行了复杂排序，然后只想要输出排序后的productName和price字段：

db.products.aggregate([
    {
        $sort: {
            price: 1,
            rating: -1
        }
    },
    {
        $project: {
            productName: 1,
            price: 1,
            _id: 0
        }
    }
]);

这里先按price升序和rating降序排序，然后$project阶段只输出productName和price字段。

性能优化与注意事项

索引对排序性能的影响

  1. 单字段索引与排序 当按单个字段进行排序时，如果该字段上有索引，MongoDB可以利用索引来加速排序操作。例如，我们按age字段对users集合进行排序，如果age字段上有索引：
db.users.createIndex({ age: 1 });

那么在执行以下聚合管道时：

db.users.aggregate([
    {
        $sort: {
            age: 1
        }
    }
]);

MongoDB可以直接使用索引来获取已排序的文档，而不需要在内存中进行排序，从而大大提高性能。 2. 复合索引与多字段排序 对于多字段排序，需要创建复合索引。例如，我们按age升序和name降序排序：

db.users.createIndex({ age: 1, name: -1 });

这样在执行以下聚合管道时：

db.users.aggregate([
    {
        $sort: {
            age: 1,
            name: -1
        }
    }
]);

MongoDB可以利用复合索引来高效地进行排序。需要注意的是，复合索引的字段顺序必须与排序的字段顺序一致，才能发挥最佳性能。

内存使用与排序限制

  1. 排序内存限制 MongoDB在进行排序操作时，会受到内存使用的限制。默认情况下，MongoDB会尝试在内存中完成排序操作，如果排序数据量超过了一定的内存限制（默认为32MB），则会报错。例如，当我们对一个非常大的集合进行排序，且排序数据量超过了32MB时，会收到如下错误：
"errmsg" : "Executor error during find command: OperationFailed: Sort operation used more than the maximum 33554432 bytes of RAM. Add an index, or specify a smaller limit.",
"code" : 16502,
"codeName" : "Location16502"
  1. 处理大排序数据量 为了处理大排序数据量，可以采取以下几种方法：
    • 增加内存限制：可以通过调整--sortMemoryLimitBytes参数来增加排序操作可用的内存量，但这需要谨慎操作，因为过多占用内存可能会影响其他数据库操作。
    • 使用索引：如前文所述，合理使用索引可以减少内存排序的需求，从而避免内存限制问题。
    • 分块处理：可以将数据分块处理，例如先按某个字段进行分组，然后对每个分组内的数据进行排序，最后合并结果。

排序顺序的稳定性

  1. 稳定性概念 排序的稳定性是指在排序过程中，相等元素的相对顺序是否保持不变。在MongoDB的$sort阶段，默认情况下排序是不稳定的。例如，假设有两个文档，它们的排序字段值相等，但在集合中的原始顺序不同，经过$sort排序后，它们的相对顺序可能会改变。
  2. 确保稳定性（特殊场景） 在某些特殊场景下，我们可能需要确保排序的稳定性。虽然MongoDB本身默认不保证稳定性，但我们可以通过一些额外的操作来实现。例如，我们可以在排序前为每个文档添加一个唯一的标识字段，然后在排序时将这个标识字段也作为排序依据之一，这样就可以在一定程度上保证相等元素的相对顺序不变。假设我们有一个tasks集合，包含priority和taskId字段，我们希望按priority升序排序，对于priority相同的任务按taskId升序排序，以确保稳定性：
db.tasks.aggregate([
    {
        $sort: {
            priority: 1,
            taskId: 1
        }
    }
]);

这样在priority相同的情况下，taskId小的任务会排在前面，从而在一定程度上保证了排序的稳定性。

高级排序技巧

按计算字段排序

  1. 基于现有字段计算新字段并排序 有时候，我们需要根据文档中的现有字段计算出一个新的字段，并按这个新字段进行排序。例如，在products集合中，每个产品有price和quantity字段，我们要计算每个产品的总价值（totalValue = price * quantity），并按总价值降序排序：
db.products.aggregate([
    {
        $addFields: {
            totalValue: { $multiply: ["$price", "$quantity"] }
        }
    },
    {
        $sort: {
            totalValue: -1
        }
    }
]);

这里$addFields阶段计算出totalValue字段，然后$sort阶段按totalValue降序排序。 2. 复杂计算字段排序 除了简单的算术运算，还可以进行更复杂的计算。例如，在一个存储运动员比赛成绩的集合athletes中，每个运动员有distance（比赛距离）和time（比赛用时）字段，我们要计算每个运动员的平均速度（averageSpeed = distance / time），并按平均速度降序排序：

db.athletes.aggregate([
    {
        $addFields: {
            averageSpeed: { $divide: ["$distance", "$time"] }
        }
    },
    {
        $sort: {
            averageSpeed: -1
        }
    }
]);

这样就可以按计算出的平均速度对运动员进行排序。

嵌套文档与数组字段排序

  1. 嵌套文档字段排序 如果文档包含嵌套结构，我们可以按嵌套字段进行排序。例如，在一个customers集合中，每个客户文档包含一个address嵌套文档，address文档中有city字段。我们要按客户所在城市的字母顺序升序排序：
db.customers.aggregate([
    {
        $sort: {
            "address.city": 1
        }
    }
]);

这里通过使用点号（.）表示法来指定嵌套字段进行排序。 2. 数组字段排序 对于包含数组字段的文档，排序会稍微复杂一些。假设我们有一个students集合，每个学生文档包含一个scores数组字段，存储学生的各项成绩。如果我们要按学生的最高成绩降序排序，可以这样做：

db.students.aggregate([
    {
        $addFields: {
            highestScore: { $max: "$scores" }
        }
    },
    {
        $sort: {
            highestScore: -1
        }
    }
]);

这里先使用$max操作符找出每个学生的最高成绩，并添加为highestScore字段，然后按highestScore字段降序排序。如果要对数组中的元素进行排序，可以使用$sortArray操作符。例如，对scores数组进行升序排序：

db.students.aggregate([
    {
        $addFields: {
            sortedScores: { $sortArray: { input: "$scores", sortBy: { $ascending: 1 } } }
        }
    }
]);

这样会在每个文档中添加一个新的 sortedScores字段，其中的数组元素按升序排列。

条件排序

  1. 简单条件排序 有时候，我们希望根据某个条件来决定排序的顺序。例如，在employees集合中，如果员工的department是"Sales"，则按salary降序排序，否则按salary升序排序。可以使用$cond操作符来实现：
db.employees.aggregate([
    {
        $sort: {
            salary: {
                $cond: [
                    { $eq: ["$department", "Sales"] },
                    -1,
                    1
                ]
            }
        }
    }
]);

这里$cond操作符根据department是否为"Sales"来决定salary的排序顺序。 2. 复杂条件排序 还可以有更复杂的条件排序逻辑。例如，在products集合中，如果产品的category是"Electronics"且rating大于4，则按price降序排序；如果category是"Clothing"且reviews数量大于100，则按price升序排序；其他情况按createdAt升序排序：

db.products.aggregate([
    {
        $sort: {
            price: {
                $cond: [
                    { $and: [{ $eq: ["$category", "Electronics"] }, { $gt: ["$rating", 4] }] },
                    -1,
                    {
                        $cond: [
                            { $and: [{ $eq: ["$category", "Clothing"] }, { $gt: ["$reviews.length", 100] }] },
                            1,
                            {
                                $cond: [
                                    true,
                                    { $ascending: ["$createdAt", 1] }
                                ]
                            }
                        ]
                    }
                ]
            }
        }
    }
]);

这里通过多层$cond嵌套实现了复杂的条件排序逻辑。

通过以上对MongoDB聚合框架中排序阶段的深入探讨和实践，我们可以看到$sort阶段在数据处理中的强大功能和广泛应用场景。合理使用排序功能，结合其他聚合阶段以及注意性能优化等方面，可以帮助我们高效地处理和分析MongoDB中的数据。无论是简单的按单一字段排序，还是复杂的多条件、多字段排序，都能通过适当的方法实现，以满足各种业务需求。