带有分页的查询的 MongoDB 自定义排序顺序

Question

我在具有此架构的 MongoDB 集合中有一些文档：

{
    "_id": {
        "$oid": "60c1e8e318afd80016ce58b1"
    },
    "searchPriority": 1,
    "isLive": false,
    "vehicleCondition": "USED",
    "vehicleDetails": {
        "city": "Delhi"
    }
},
{
    "_id": {
        "$oid": "60c1f2f418afd80016ce58b5"
    },
    "searchPriority": 2,
    "isLive": false,
    "vehicleCondition": "USED",
    "vehicleDetails": {
        "city": "Delhi"
    }
},
{
    "_id": {
        "$oid": "60cb429eadd33c00139d2be7"
    },
    "searchPriority": 1,
    "isLive": false,
    "vehicleCondition": "USED",
    "vehicleDetails": {
        "city": "Gurugram"
    }
},
{
    "_id": {
        "$oid": "60c21be618afd80016ce5905"
    },
    "searchPriority": 2,
    "isLive": false,
    "vehicleCondition": "USED",
    "vehicleDetails": {
        "city": "New Delhi"
    }
},
{
    "_id": {
        "$oid": "60e306d29e452d00134b978f"
    },
    "searchPriority": 3,
    "isLive": false,
    "vehicleCondition": "USED",
    "vehicleDetails": {
        "city": "New Delhi"
    }
}

vehicleCondition 可以是NEW 或USED，isLive 可以是true 或false，searchPriority 将是一个介于 1 到 3 之间的整数。（较小的数字意味着它应该在搜索结果）

这里，除了_id，其他字段都不是唯一的。我在isLive、vehicleDetails.city 和searchPriority 上创建了一个复合索引。

在我的应用程序中，我将执行一些这种形式的查询：

• 查找isLive 为true、vehicleDetails.city 为的所有汽车 Delhi 或 New Delhi 或 Gurugram 和 vehicleCondition 是 USED（或NEW）。

为此，我可以像这样进行查找查询：

db.collection.find({"isLive": true, "vehicleDetails.city": { $in: [ "Gurugram", "Delhi", "New Delhi" ] }, "vehicleCondition": "USED" }, {})

我希望此查询的结果按此顺序排序：

• 在查找查询中属于 $in 数组中第一个城市的所有汽车，优先级最低
• 在查找查询中属于 $in 数组中第一个城市的所有汽车，优先级第二低
• 所有属于$in arrarray 内第一个城市的汽车 查询，具有第三低优先级
• 在查找查询中属于 $in 数组中第二个城市的所有汽车，优先级最低
• 在查找查询中属于 $in 数组中第二个城市的所有汽车，优先级第二低
• 在查找查询中属于$in 数组内的第二个城市的所有汽车，具有第三低优先级 查找查询中属于 $in 数组中第三个城市的所有汽车，优先级最低
• 在查找查询中属于 $in 数组中第三个城市的所有汽车，优先级第二低
• 在查找查询中属于 $in 数组中的第三个城市的所有汽车，具有第三低优先级

我该怎么做？由于此查询返回的文档数量可能非常大，因此我将使用分页来限制返回的文档数量。这个额外的要求会对这个问题的可能解决方案有任何影响吗？

Answer 1

我希望这对你有用

 let x = ["Gurugram","Delhi", "New Delhi"];

db.collection.aggregate([
        {
            $match: {
                "isLive": true,
                "vehicleDetails.city": {
                    $in: x
                },
                "vehicleCondition": "USED"
            }
        },
        {
            $project: {
                "_id": 1,
                "searchPriority": 1,
                "isLive": 1,
                "vehicleCondition": 1,
                "vehicleDetails": 1,
                index: { $indexOfArray: [x, "$vehicleDetails.city"] },
            }
        },
        { $sort: { index: 1, searchPriority: 1 } },
        {
            $project: {
                "index": 0,
            }
        }
    ]).toArray();

Answer 2

所以我已经阅读了另一个答案（它提供了技术解决方案），但是根据您的 cmets 并要求它不适合。

所以先在这里使用aggregate，虽然技术上解决了一些问题。

正如你提到的查询可以有大量的文档匹配，聚合管道与find 方法不同确实将它们全部加载到内存中，这会创造性地导致性能问题，我还看到你提到了一些关于不有一个索引。这将导致对每个 API 调用进行“收集”扫描。

我建议你做的是：

1. 首先，您绝对必须在isLive, vehicleCondition, "vehicleDetails.city" 上建立一个复合索引，以防万一您没有。这只是大规模使用的必需品。

2. 既然我们已经解决了这个问题，我建议您将调用分成几部分，我将粘贴一些 puesdo 代码，这些代码可能看起来有点到处都是，但我相信这是最好的方法您可以使用 Mongo 来实现，因为这些查询中的每一个都假定通过使用先前构建的索引是有效的。

我将简要解释一下方法，我们希望能够独立于其他城市查询每个城市，这样我们就可以使用“自定义排序”功能而无需将所有匹配项加载到内存中。

为此，我们需要知道每个城市需要“跳过”和“限制”多少，例如城市#2（德里）限制将是（限制 - 城市#1（古鲁格拉姆）匹配）。

所以这是伪代码，我故意把它简单化了，这样可以理解。不过，我会在最后添加一些想法以进行一些基本的改进。

let limit = 10; // determined by req?
const skip = 0; // determined by req?
const cities = ['Gurugram', 'Delhi', 'New Delhi'];

// we need this to resolve the proper skip / limit. the last city is not relevant.
const countPromises = [];
for (let i = 0; i < cities.length - 1; i++) {
    countPromises.push(db.collection.countDocuments({
        'isLive': true,
        'vehicleDetails.city': cities[i],
        'vehicleCondition': 'USED',
    }));
}
await Promise.all(countPromises);

// first city initial skip
const citySkips = [skip];

for (let i = 0; i < countPromises.length - 1; i++) {
    // if we have x results in the first city then we need to skip-x skipping for the next city.
    citySkips.push(Math.max(skip - countPromises[0], 0));
}

let finalResults = [];
for (let i = 0; i < cities.length; i++) {
    // assuming we skip over ALL city i results.
    if (citySkips[i] >= countPromises[i]) {
        continue;
    }
    const cityLimit = limit - finalResults.length;
    if (cityLimit <= 0) {
        break;
    }
    const cityResults = await db.collection.find({
        'isLive': true,
        'vehicleDetails.city': cities[i],
        'vehicleCondition': 'USED',
    }).sort({ sortPriority: 1 }).skip(citySkips[i]).limit(cityLimit);
    finalResults = finalResults.concat(cityResults);
}

好的，你可以做出改进：

• 如果数据库不经常更新/您不关心极端准确度，您可以提前预先计算每个城市匹配计数（每天一次？每周一次？取决于您的应用程序）。这将加快确定每个城市的skip 和limit 所需的countDocuments 部分。
• 最后一个for 循环可以是类似于计数的Promise.all，以加快结果。同样，如果城市数量永远不会太高，这可能是一个很好的解决方案。
• 最后，不清楚单辆车是否可以与多个城市相关，但如果是这种情况，则需要在已匹配的文档上添加排除条件。

Answer 3

您可以在匹配后添加自定义排序顺序字段，以根据输入的城市条件顺序和搜索优先顺序对字段进行排序。由于是计算出来的字段索引，不会用于排序。

您可以在末尾添加分页，就像对任何其他查询一样。

类似

db.collection.aggregate([
  {
    $match: {
      "isLive": true,
      "vehicleDetails.city": {
        $in: [
          "Gurugram",
          "Delhi",
          "New Delhi"
        ]
      },
      "vehicleCondition": "USED"
    }
  },
  {
    "$addFields": {
      "cityIndex": {
        "$indexOfArray": [
          [
            "Gurugram",
            "Delhi",
            "New Delhi"
          ],
          "$vehicleDetails.city"
        ]
      }
    }
  },
  {
    $sort: {
      cityIndex: 1,
      sortPriority: 1
    }
  },
  {
    $project: {
      cityIndex: 0
    }
  }
])

工作示例可以在这里找到 - https://mongoplayground.net/p/16-YOkPotLX