两个集合之间的 MongoDb 查询答案

【问题标题】：MongoDb query between two collections两个集合之间的 MongoDb 查询
【发布时间】：2021-03-04 19:34:32
【问题描述】：

我有这个查询应该合并两个表并返回结果

db.purchasefromobjectmodel.aggregate([
{
"$lookup":{
"from":"amazonmodels",
"localField":"receiptId",
"foreignField":"receiptId",
"as" :"results"
}])

我如何编辑它，以便它返回我的对象，其中第一个表中的 purchaseDate 等于第二个表的数据（或附近有微小差异>24hrs），对象通过receiptId 链接

编辑：

const purchaseFromAppObjectModelSchema = new mongoose.Schema({
  receiptId: String,
  sku: String,
  itemType: String,
  purchaseDate: { type: Date, default: Date.now },
  UserData: { type: [userDataModel] },
  idfa: String,
  status: String,
  appName: String,
  trafficSource: String,
  trafficName: String,
  appVersion: String,
  deviceName: String,
  deviceBrand: String,
});

const amazonSchema = new mongoose.Schema(
  {
    autoRenewing: Boolean,
    betaProduct: Boolean,
    cancelDate: Number,
    cancelReason: Number,
    deferredDate: String,
    deferredSku: String,
    freeTrialEndDate: Number,
    gracePeriodEndDate: Number,
    parentProductId: String,
    productId: String,
    productType: String,
    purchaseDate: Number,
    quantity: Number,
    receiptId: String,
    renewalDate: Number,
    term: String,
    termSku: String,
    testTransaction: Boolean,
  },
  { timestamps: true, toObject: { virtuals: true }, toJSON: { virtuals: true } }
);

我尝试过的查询：

let result = await purchaseFromAppObjectModel.aggregate([
    {
      $lookup: {
        from: "amazonmodels",
        localField: "purchaseDate",
        foreignField: "purchaseDate",
        as: "purchaseDateInfo",
      },
    },
    // {
    //   $replaceRoot: {
    //     newRoot: {
    //       $mergeObjects: [{ $arrayElemAt: ["$purchaseDateInfo", 0] }, "$$ROOT"],
    //     },
    //   },
    // },
    // { $project: { purchaseDateInfo: 0 } },
  ]);

This one merges the collections with same receipt id
 {
      $lookup: {
        from: "amazonmodels",
        localField: "receiptId",
        foreignField: "receiptId",
        as: "purchaseDateInfo",
      },
    },
     {
      $replaceRoot: {
        newRoot: {
          $mergeObjects: [{ $arrayElemAt: ["$purchaseDateInfo", 0] }, "$$ROOT"],
        },
      },
     },
     { $project: { purchaseDateInfo: 0 } },
  ]);

let result = await purchaseFromAppObjectModel.aggregate([
{$match : { purchaseDate : createdAt } } ,
{
      $lookup: {
        from: "amazonmodels",
        localField: "purchaseDate",
        foreignField: "purchaseDate",
        as: "purchaseDateInfo",
      },
    },
    // {
    //   $replaceRoot: {
    //     newRoot: {
    //       $mergeObjects: [{ $arrayElemAt: ["$purchaseDateInfo", 0] }, "$$ROOT"],
    //     },
    //   },
    // },
    // { $project: { purchaseDateInfo: 0 } },
  ]);

我认为这是我应该尝试模拟的一个：

db.orders.aggregate([
   {
      $lookup:
         {
           from: "warehouses",
           let: { order_item: "$item", order_qty: "$ordered" },
           pipeline: [
              { $match:
                 { $expr:
                    { $and:
                       [
                         { $eq: [ "$stock_item",  "$$order_item" ] },
                         { $gte: [ "$instock", "$$order_qty" ] }
                       ]
                    }
                 }
              },
              { $project: { stock_item: 0, _id: 0 } }
           ],
           as: "stockdata"
         }
    }
])

还有更多

【问题讨论】：

通过管道了解$lookup：docs.mongodb.com/manual/reference/operator/aggregation/lookup/…
我已经阅读过它，但我尝试过但没有成功，我想我错过了一些东西，这就是我问的原因
然后发布您尝试过的集合和查询的一些文档。
为什么purchaseDate 在amazonSchema 中是一个数字？是时间戳吗？
是的，它是亚马逊生成的时间戳

标签： node.js mongodb mongodb-query aggregation-framework

【解决方案1】：

试试这个：

db.purchaseFromApp.aggregate([
    {
        $lookup: {
            from: "amazonmodels",
            let: {
                purchaseDate: {
                    $dateFromString: {
                        dateString: { $toString: "$purchaseDate" },
                        format: "$Y-%m-%d"
                    }
                },
                receiptId: "$receiptId"
            },
            pipeline: [
                {
                    $match: {
                        $expr: {
                            $and: [
                                { $eq: ["$receiptId", "$$receiptId"] },
                                {
                                    $eq: [
                                        {
                                            $dateFromString: {
                                                dateString: { $toString: "$purchaseDate" },
                                                format: "$Y-%m-%d"
                                            }
                                        },
                                        "$$purchaseDate"
                                    ]
                                }
                            ]
                        }
                    }
                }
            ],
            as: "purchaseDateInfo"
        }
    },
    // Add other stages
]);

【讨论】：

它返回了一个结果，但没有比较 createdAt 与我认为的购买日期，它可能需要 tweeking 比较日期并返回具有相同收据 ID 和相似或接近日期的对象，因为差异约为 1 或购买日期与亚马逊创建日期之间的两秒
是的，我的回答并不准确。它的基本框架。根据您的要求修改它。
如果您只想比较日期，请检查更新的答案。如果您想包含hours 或minutes，请相应更改format。只需阅读此内容：docs.mongodb.com/manual/reference/operator/aggregation/…
谢谢你，我会编辑它并添加我想要的，因为有几个不匹配，但你给了我一个非常清晰的想法！

【解决方案2】：

如果有人路过并想检查我是如何使用简单聚合和 nodejs 做到这一点的：

//first the query
let result = await purchaseFromAppObjectModel.aggregate([
    {
      $lookup: {
        from: "amazonmodels",
        localField: "receiptId",
        foreignField: "receiptId",
        as: "amazonResults",
      },
    },
  ]);

//Then looping
for (var i = 0; i <= result.length - 1; i++) {
    let objResult = result[i];
    console.log(
      "this is the result index : ",i,"this is the size :",objResult.amazonResults.length);
    let purchaseDate = objResult.purchaseDate;

    if (objResult.amazonResults != 0) {
      let createdAt = objResult.amazonResults[0].createdAt;
      const diffTime = Math.abs(createdAt - purchaseDate);
      console.log(diffTime);
      if (diffTime < 5000) {
        console.log("purchase date  " + purchaseDate);
        console.log("createdAt  " + createdAt);
        console.log("same date");
      } else {
        console.log(" different dates");
      }
    }
  }

【讨论】：