Node.js+Express中Mongo条件更新聚合查询实现求助

需求梳理 #

• 按key字段匹配文档，无匹配则插入新文档
• 满足以下任一条件时，完全覆盖更新现有文档：
  • 传入的price值小于存储的price
  • 存储的total_amount值小于指定阈值（示例中为8）
• 不满足条件则跳过更新

数据示例 #

原始集合数据 #

[
    {
        "key": "key1",
        "price": 149,
        "total_amount": 40,
        "name": "Item1"
    },
    {
        "key": "key2",
        "price": 225,
        "total_amount": 11,
        "name": "Item2"
    },
    {
        "key": "key3",
        "price": 99,
        "total_amount": 3,
        "name": "Item2"
    }
]

传入参数 #

const total_amount_to_check = 8;

const itemsToProcess = [
  {
    "key": "key1",
    "price": 125,
    "name": "Item1",
    "total_amount": 20,
  },
  {
    "key": "key2",
    "price": 400,
    "name": "Item2",
    "total_amount": 45,
  },
  {
    "key": "key3",
    "price": 149,
    "name": "Item3",
    "total_amount": 10,
  }
];

预期结果 #

[
    {
        "key": "key1",
        "price": 125,
        "name": "Item1",
        "total_amount": 20,
    },
    {
        "key": "key2",
        "price": 225,
        "total_amount": 11,
        "name": "Item2"
    },
    {
        "key": "key3",
        "price": 149,
        "name": "Item3",
        "total_amount": 10,
    }
]

实现代码 #

方案一：Mongoose（Express常用ORM） #

const mongoose = require('mongoose');
const total_amount_to_check = 8;

// 定义数据模型Schema
const ItemSchema = new mongoose.Schema({
  key: { type: String, unique: true, required: true },
  price: Number,
  total_amount: Number,
  name: String
});

const Item = mongoose.model('Item', ItemSchema);

// 待处理的对象数组
const itemsToProcess = [
  { key: "key1", price: 125, name: "Item1", total_amount: 20 },
  { key: "key2", price: 400, name: "Item2", total_amount: 45 },
  { key: "key3", price: 149, name: "Item3", total_amount: 10 }
];

// 批量处理函数
async function processItems() {
  // 连接数据库
  await mongoose.connect('mongodb://localhost:27017/your_database_name');

  for (const item of itemsToProcess) {
    // 查询匹配的现有文档
    const existingItem = await Item.findOne({ key: item.key });

    if (!existingItem) {
      // 无匹配则插入新文档
      await Item.create(item);
      console.log(`已插入：key=${item.key}`);
      continue;
    }

    // 判断是否满足更新条件
    const shouldUpdate = item.price < existingItem.price || existingItem.total_amount < total_amount_to_check;

    if (shouldUpdate) {
      // 完全覆盖更新现有文档
      await Item.replaceOne({ key: item.key }, item);
      console.log(`已更新：key=${item.key}`);
    } else {
      console.log(`跳过更新：key=${item.key}`);
    }
  }

  // 验证最终结果
  const finalData = await Item.find({}).sort({ key: 1 });
  console.log('\n最终集合数据：');
  console.log(JSON.stringify(finalData, null, 2));

  await mongoose.disconnect();
}

// 执行处理
processItems().catch(err => console.error('处理失败：', err));

方案二：MongoDB原生驱动 #

const { MongoClient } = require('mongodb');
const total_amount_to_check = 8;

const itemsToProcess = [
  { key: "key1", price: 125, name: "Item1", total_amount: 20 },
  { key: "key2", price: 400, name: "Item2", total_amount: 45 },
  { key: "key3", price: 149, name: "Item3", total_amount: 10 }
];

async function processItems() {
  const client = new MongoClient('mongodb://localhost:27017');
  await client.connect();

  const db = client.db('your_database_name');
  const collection = db.collection('items');

  for (const item of itemsToProcess) {
    const existingItem = await collection.findOne({ key: item.key });

    if (!existingItem) {
      await collection.insertOne(item);
      console.log(`已插入：key=${item.key}`);
      continue;
    }

    const shouldUpdate = item.price < existingItem.price || existingItem.total_amount < total_amount_to_check;

    if (shouldUpdate) {
      await collection.replaceOne({ key: item.key }, item);
      console.log(`已更新：key=${item.key}`);
    } else {
      console.log(`跳过更新：key=${item.key}`);
    }
  }

  const finalData = await collection.find({}).sort({ key: 1 }).toArray();
  console.log('\n最终集合数据：');
  console.log(JSON.stringify(finalData, null, 2));

  await client.close();
}

processItems().catch(err => console.error('处理失败：', err));

说明 #

• 无需使用聚合管道：聚合主要用于数据查询分析，此类条件写操作直接用replaceOne结合前置查询判断更高效直观
• 完全覆盖更新：replaceOne会用传入的对象完全替换现有文档，符合需求中的"完全覆盖"要求
• 原子性优化：如果需要避免并发冲突，可改用findOneAndUpdate配合原子条件判断，确保更新逻辑的原子性

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