MongoDB双字段分组问题：Node.js(TypeScript)指定one_id查互逆文档对

嘿，我来帮你搞定这个MongoDB的查询需求！你需要找出那些存在互逆one_id和two_id的文档对，同时限定其中一方的one_id是指定值，对吧？下面是具体的实现方案，结合TypeScript和Node.js来写：

要找到这种互逆文档对，关键是通过自连接查询匹配出和当前文档one_id/two_id完全互换的记录，同时先过滤出和目标ID相关的文档（要么当前文档one_id是指定值，要么two_id是指定值，因为互逆的另一方必然满足后者）。我们用MongoDB的聚合框架来实现这个逻辑。

先给出纯MongoDB的聚合管道，你可以直接在数据库客户端测试：

db.yourCollection.aggregate([
  // 第一步：筛选出和目标ID相关的文档
  {
    $match: {
      $or: [
        { one_id: "307973260186877954" },
        { two_id: "307973260186877954" }
      ]
    }
  },
  // 第二步：自连接查找互逆文档
  {
    $lookup: {
      from: "yourCollection",
      let: { current_one: "$one_id", current_two: "$two_id" },
      pipeline: [
        {
          $match: {
            $expr: {
              $and: [
                { $eq: ["$one_id", "$$current_two"] },
                { $eq: ["$two_id", "$$current_one"] }
              ]
            }
          }
        }
      ],
      as: "reverse_pair"
    }
  },
  // 第三步：过滤掉没有找到互逆对的文档
  {
    $match: {
      $expr: { $gt: [{ $size: "$reverse_pair" }, 0] }
    }
  },
  // 可选：整理结果，只保留需要的字段
  {
    $project: {
      one_id: 1,
      two_id: 1,
      reverse_pair: { $arrayElemAt: ["$reverse_pair", 0] },
      _id: 0
    }
  }
])

如果你用Mongoose来操作MongoDB，下面是对应的TypeScript代码：

import mongoose from 'mongoose';

// 定义文档的TypeScript接口
interface RelationDocument extends mongoose.Document {
  one_id: string;
  two_id: string;
  // 其他字段根据你的实际需求添加
}

// 创建Mongoose模型
const RelationModel = mongoose.model<RelationDocument>(
  'Relation',
  new mongoose.Schema({
    one_id: { type: String, required: true },
    two_id: { type: String, required: true },
    // 其他字段定义...
  })
);

// 封装查询函数
async function findReverseRelationPairs(targetId: string) {
  try {
    const result = await RelationModel.aggregate([
      {
        $match: {
          $or: [
            { one_id: targetId },
            { two_id: targetId }
          ]
        }
      },
      {
        $lookup: {
          from: 'relations', // 注意这里是MongoDB实际的集合名（Mongoose默认转小写复数）
          let: { current_one: '$one_id', current_two: '$two_id' },
          pipeline: [
            {
              $match: {
                $expr: {
                  $and: [
                    { $eq: ['$one_id', '$$current_two'] },
                    { $eq: ['$two_id', '$$current_one'] }
                  ]
                }
              }
            }
          ],
          as: 'reverse_pair'
        }
      },
      {
        $match: {
          $expr: { $gt: [{ $size: '$reverse_pair' }, 0] }
        }
      },
      {
        $project: {
          one_id: 1,
          two_id: 1,
          reverse_pair: { $arrayElemAt: ['$reverse_pair', 0] },
          _id: 0
        }
      }
    ]);

    console.log('找到的互逆文档对:', result);
    return result;
  } catch (error) {
    console.error('查询出错:', error);
    throw error;
  }
}

// 调用查询函数
(async () => {
  // 先连接MongoDB
  await mongoose.connect('mongodb://localhost:27017/yourDatabaseName');
  await findReverseRelationPairs('307973260186877954');
  await mongoose.disconnect();
})();

• 为了提升查询效率，建议给one_id和two_id建立复合索引：db.yourCollection.createIndex({ one_id: 1, two_id: 1 })
• 如果不想返回重复的互逆对（比如同时出现A→B和B→A），可以在聚合最后加一步过滤，比如只保留one_id字符串小于two_id的文档（假设ID字符串可比较）

内容的提问来源于stack exchange，提问作者selimgrr