bulkWrite（）上的MongoDB更改流

我所处的情况是，我经常更改一个文档。我有几个更新，我通过bulkWrite（）发送了一次。我想限制来自基于bulkWrite（）的更改流的通知数。如果我对文档进行5次更新，则更改流将通知5次。当bulkWrite（）完成所有更新后，最好只收到一个通知。有没有办法做到这一点？

请查看MongoDB文档

https://docs.mongodb.com/manual/core/bulk-write-operations/#bulkwrite-方法

如果您尝试这样做：

db.collectionName.bulkWrite(
      [
         { insertOne :
            {
               "document" :
               {
                  "char" : "Dithras", "class" : "barbarian", "lvl" : 4
               }
            }
         },
         { insertOne :
            {
               "document" :
               {
                  "char" : "Taeln", "class" : "fighter", "lvl" : 3
               }
            }
         },
         { updateOne :
            {
               "filter" : { "char" : "Taeln" },
               "update" : { $set : { "status" : "Critical Injury" } }
            }
         },
         { deleteOne :
            { "filter" : { "char" : "Brisbane"} }
         },
         { replaceOne :
            {
               "filter" : { "char" : "Meldane" },
               "replacement" : { "char" : "Tanys", "class" : "oracle", "lvl" : 4 }
            }
         }
      ]
   );

你只会得到一个结果

{
    "acknowledged" : true,
    "deletedCount" : 0,
    "insertedCount" : 2,
    "matchedCount" : 1,
    "upsertedCount" : 0,
    "insertedIds" : {
        "0" : ObjectId("5bdfe0a5bad3d851a4064080"),
        "1" : ObjectId("5bdfe0a5bad3d851a4064081")
    },
    "upsertedIds" : {

    }
}

---

如果我还能做什么，请随便问：）。

我的情况不同，但与你的情况相似。 当用户更改表单中的字段时，我正在更新文档，但在流中，我只想听最终更新的文档

我用的方法是去盎司

一般的想法是存储流的唯一表示（集合、操作和文档的组合），然后在使用该流之前有一个超时。如果另一个流具有相同的唯一id表示，则取消上一个超时并创建一个新的超时

以下是

更新操作的一个简单示例：

const streamMap = new Map();

const debounceStreamExecution = (next, fn) => {

    const streamId = `${next.operationType}_${next.documentKey._id.toString()}` // This could be your own unique representation of a stream.
    const streamItem = streamMap.get(streamId);

    if (streamItem && streamItem.timeout) {
        // Same stream came before, so stop previous execution.
        clearTimeout(streamItem.timeout);
    }

    // We merge previous updates with new ones
    const updateDescription = {
        updatedFields: {
            // Use Lodash _.merge() if you want deep merging
            ...streamItem.updateDescription.updatedFields || {},
            ...next.updateDescription.updatedFields || {}
        },
        removedFields: [].concat(
            streamItem.updateDescription.removedFields || [],
            next.updateDescription.removedFields || []
        )
    };

    // We set our timeout to delay execution
    const timeout = setTimeout(() => {
        streamMap.delete(streamId);
        fn({
            ...next,
            updateDescription
        });
    }, 1000 /* <-- Your delay preference */);

    // We store this stream information.
    streamMap.set(streamId, {
        updateDescription,
        timeout
    });

};

db.collection('aCollection').watch().on('change', next => {
    debounceStreamExecution(next, (result) => {
        console.log('Single stream', result);
    });
});

const streamMap=newmap（）；
const debounceStreamExecution=（下一步，fn）=>{
const streamId=`${next.operationType}{next.documentKey.\u id.toString（）}`//这可能是您自己的流的唯一表示形式。
const streamItem=streamMap.get（streamId）；
if（streamItem&&streamItem.timeout）{
//之前出现了相同的流，因此停止上一次执行。
clearTimeout（streamItem.timeout）；
}
//我们将以前的更新与新的更新合并
常量更新描述={
更新字段：{
//如果要进行深度合并，请使用Lodash u2;.merge（）
…streamItem.updateDescription.updatedFields | |{}，
…next.updateDescription.updatedFields | |{}
},
removedFields:[].concat(
streamItem.updateDescription.removedFields | |[]，
next.updateDescription.removedFields | |[]
)
};
//我们将超时设置为延迟执行
常量超时=设置超时（（）=>{
streamMap.delete（streamId）；
fn({
下一个
更新描述
});
}, 1000 /*  {
去BouncestreamExecution（下一步，（结果）=>{
console.log（'单流'，结果）；
});
});
你是对的，结果信息只有一个。但我的意思是变更流中有许多文档。假设我对同一文档更新三次，然后执行批量写入。变更流将同一文档返回我三次。我只想获取一个文档，因为它是同一文档，我不需要三次。