MongoDb 查询两个 collections 之间

Question

I have this query that should merge both tables and return the result

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

How can i edit it so that it would return me objects where purchaseDate from first table is equal to the data of second table ( or near with minor difference >24hrs ), the objects are linked through receiptId

edit:

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 } }
);

queries i tried:

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 } },
  ]);

I think this one is the one i should try to mock:

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"
         }
    }
])

And much more

Answer 1

Try this:

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
]);

Answer 2

if anyone passed by and want to check how did i do it using simple aggregation and nodejs this is how:

//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");
      }
    }
  }