MongoDB按其他字段查询唯一值

td；rd

我希望获取所有事务，并忽略pendingTransactionId字段等于另一个文档的transactionId的事务

---

我有一个名为Transactions的集合，我存储表示银行交易等交易的文档。这些事务有一个标志告诉您它是否处于挂起状态，还有一个字段存储挂起事务id。下面是一个示例：

// Pending Transaction
{
  transactionId: 1,
  pending: true,
  pendingTransactionId: null,
  amount: 5
}

// Processed transaction
{
  transactionId: 2,
  pending: false,
  pendingTransactionId: 1,
  amount: 7
}

这些都是“相同”的交易，但我有两个记录，因为处理的一个可能在不同的时间处理（比如在挂起的一个交易后的1或2天），还有一些字段可能会更改，比如

金额

（例如，这可能是我在餐厅留下的小费）

我试图创建的查询很难给出所有事务，但它会忽略那些“重复”的事务：如果pendingTransactionId等于另一个文档的transactionId，则应该忽略一个事务

---

更新

添加记录与预期记录的示例

// records
{
  transactionId: 123,
  pending: true,
  pendingTransactionId: null,
  amount: 5
}
{
  transactionId: 321,
  pending: false,
  pendingTransactionId: 123,
  amount: 7
}
{
  transactionId: 333,
  pending: false,
  pendingTransactionId: 888,
  amount: 22
}
{
  transactionId: 444,
  pending: true,
  pendingTransactionId: null,
  amount: 50
}
{
  transactionId: 555,
  pending: false,
  pendingTransactionId: null,
  amount: 60
}

已忽略transactionId=123的记录，因为已处理了一个事务（pending=false）

transactionId=333

不会被忽略，因为它没有挂起，即使我们没有挂起事务的记录

也没有任何本机解决方案。。。

但是，我们可以使用

$lookup

操作符使

左连接

，通过组合

transactionId

和

pendingTransactionId

字段来匹配文档

我们可以得到：

a) doc{ pending = false, transaction : [{pending: true}]  } ✔
b) doc{ pending = true,  transaction : [{pending: false}] } X
c) doc{ pending = false, transaction : []               } ✔

下一阶段，我们使用内部数组

transaction.pending=true

或空

transaction

筛选文档

使用，我们从结果文档中排除字段

---

我希望获取所有事务，并忽略其中的事务 pendingTransactionId字段等于另一个的transactionId 文件

这是一个自查找操作。查找具有父事务（具有

pendingTransactionId

的事务）的所有事务，作为每个文档的结果数组。然后在下一阶段删除父事务的所有文档。在示例文档中，

transactionId:123

与父级

transactionId:321

匹配

db.test.aggregate( [
 {
    $lookup: {
        from: "txns",
        localField: "transactionId",
        foreignField: "pendingTransactionId",
        as: "parent_txn"
    }
 },
 {
    $match: { parent_txn: { $size: 0 } }
 },
 { 
    $project: { parent_txn: 0 }
 }
] )

---

你能多寄些样品吗。需要看看@Valijon添加了一个示例后，我们是否可以得到期望的结果

db.collection.aggregate([
  {
    $lookup: {
      from: "collection",
      let: {
        transactionId: "$transactionId",
        pendingTransactionId: "$pendingTransactionId"
      },
      pipeline: [
        {
          $match: {
            $expr: {
              $or: [
                {
                  $eq: [
                    "$$transactionId",
                    "$pendingTransactionId"
                  ]
                },
                {
                  $eq: [
                    "$transactionId",
                    "$$pendingTransactionId"
                  ]
                }
              ]
            }
          }
        }
      ],
      as: "transactions"
    }
  },
  {
    $match: {
      $expr: {
        $or: [
          {
            $eq: [
              {
                $let: {
                  vars: {
                    transaction: {
                      $arrayElemAt: [
                        "$transactions",
                        0
                      ]
                    }
                  },
                  in: "$$transaction.pending"
                }
              },
              true
            ]
          },
          {
            $eq: [
              {
                $size: "$transactions"
              },
              0
            ]
          }
        ]
      }
    }
  },
  {
    $unset: "transactions"
  }
])

db.test.aggregate( [
 {
    $lookup: {
        from: "txns",
        localField: "transactionId",
        foreignField: "pendingTransactionId",
        as: "parent_txn"
    }
 },
 {
    $match: { parent_txn: { $size: 0 } }
 },
 { 
    $project: { parent_txn: 0 }
 }
] )