I have a nodes database extracted from OpenStreetMap and the data is structured like this:

我有一个从OpenStreetMap提取的节点数据库，数据的结构如下：

[
{_id: 0, location: {type: 'Point', coordinates: [long, lat]}},
{_id: 1, location: {type: 'Point', coordinates: [long, lat]}, ${key}: ${value}},
{_id: 2, location: {type: 'Point', coordinates: [long, lat]}, ${key}: ${value}},
{_id: 3, location: {type: 'Point', coordinates: [long, lat]}},
{_id: 4, location: {type: 'Point', coordinates: [long, lat]}, ${key}: ${value}},
]

As we know, OpenStreetMap has tons of tags containing keys and values.
I'm trying to query the closest pair of nodes that contains a specific tag in only one query. I couldn't go much further than an simple aggregation function matching the nodes data base. In the example bellow I use the tag power: tower, but it is not mandatory to be that one.

正如我们所知，OpenStreetMap有大量包含键和值的标记。我尝试在一个查询中查询包含特定标记的最接近的节点对。除了匹配节点数据库的简单聚合函数之外，我不能做更多的工作。在下面的示例中，我使用了标记power：Tower，但它不是强制性的。

  const result = await client.nodes_collection
    .aggregate([
      {
        $match: {
          power: 'tower',
        },
      },
      {
        $lookup: {
          from: 'nodes',
          as: 'closestNode',
          pipeline: [{ $match: { power: 'tower' } }],
        },
      },
      {
        $unwind: '$closestNode',
      },
      {
        $match: {
          'closestNode._id': { $ne: '$_id' },
        },
      }
]).toArray()

P.S: It is mandatory to be in only one query.

附注：必须只出现在一个查询中。

EDIT:

编辑：

For mongoDB version 5.3 or higher (With the help of @Juliana Aragão):

对于MongoDB 5.3或更高版本(在@Juliana Aragão的帮助下)：

db.nodes.aggregate([
  {$match: {power: "tower"}},
  {$lookup: {
      from: "nodes",
      as: "closestNode",
      let: {coords: "$location.coordinates"},
      pipeline: [
        {$geoNear: {
            near: {
              type: "Point",
              coordinates: "$$coords"
            },
            distanceField: "distFromMe",
            spherical: true,
            query: {power: "tower"}
        }},
        {$skip: 1},
        {$limit: 1},
        {$project: {distFromMe: 1}}
      ]
  }},
  {$set: {closestNode: {$first: "$closestNode"}}},
  {$sort: {"closestNode.distFromMe": 1}},
  {$limit: 1}
])

For older versions of mongoDB, $geoNear does not support the coordinates as a parameter, thus one option is to create the calculation by ourselves. This solution includes calculating the distance between all pairs: O(n^2):

对于较早版本的MongoDB，$GeoNear不支持将坐标作为参数，因此一种选择是自己创建计算。此解决方案包括计算所有对之间的距离：O(n^2)：

db.nodes.aggregate([
  {$match: {power: "tower"}},
  {$lookup: {
      from: "nodes",
      as: "closestNode",
      let: {
        long: {$multiply: [{$first: "$location.coordinates"}, 0.017452778]},
        lat: {$multiply: [{$last: "$location.coordinates"}, 0.017452778]}
      },
      pipeline: [
        {$match: {power: "tower"}},
        {$set: {
            lat: {$multiply: [{$last: "$location.coordinates"}, 0.017452778]},
            long: {$multiply: [{$first: "$location.coordinates"}, 0.017452778]}
        }},
        {$set: {distFromMe: {
              $let: {
                vars: {
                  dlon: {$subtract: ["$long", "$$long"]},
                  dlat: {$subtract: ["$lat", "$$lat"]},
                  rlon: {$divide: [
                      {$multiply: [6378137, {$cos: {$avg: ["$lat", "$$lat"]}}]},
                      {$sqrt: {$subtract: [
                            1,
                            {$multiply: [
                                0.00669437,
                                {$pow: [{$sin: {$avg: ["$lat", "$$lat"]}}, 2]}
                            ]}
                      ]}}
                  ]},
                  rlat: {$divide: [
                      {$multiply: [6378137, {$subtract: [1, 0.00669437]}]},
                      {$pow: [
                          {$subtract: [
                              1,
                              {$multiply: [
                                  0.00669437,
                                  {$pow: [
                                      {$sin: {$avg: ["$lat", "$$lat"]}},
                                      2
                                  ]}
                              ]}
                          ]},
                          1.5
                      ]}
                  ]}
                },
                in: {$max: [
                    {$sqrt: [{$add: [
                            {$pow: [{$multiply: ["$$dlon", "$$rlon"]}, 2]},
                            {$pow: [{$multiply: ["$$dlat", "$$rlat"]}, 2]}
                    ]}]},
                    1
                ]}
            }}
        }},
        {$sort: {distFromMe: 1}},
        {$skip: 1},
        {$limit: 1},
        {$project: {distFromMe: 1}}
      ]
  }},
  {$set: {closestNode: {$first: "$closestNode"}}},
  {$sort: {"closestNode.distFromMe": 1}},
  {$limit: 1}
])

See how it works on the playground example.

看看它是如何在操场上工作的例子。

The distance calculation is according to this ref by @jimirwin‏:

距离的计算是根据@jimirwin‏的参考：