MongoDB: 插入文档：insertOne与insertMany详解

// === 使用 bulkWrite + ordered: false 解决部分失败问题 ===
const products = [...];  // 100 万条产品数据

const BATCH_SIZE = 1000;
for (let i = 0; i < products.length; i += BATCH_SIZE) {
  const batch = products.slice(i, i + BATCH_SIZE);

  try {
    await Product.bulkWrite(
      batch.map(doc => ({
        insertOne: { document: doc }
      })),
      { ordered: false }  // 允许部分失败，继续执行
    );
  } catch (err) {
    console.error(`Batch ${i / BATCH_SIZE} 失败：${err.writeErrors?.length} 条`);
  }
}

// === 使用 Write Concern 确保数据持久化 ===
await Product.bulkWrite(
  batch.map(doc => ({ insertOne: { document: doc } })),
  {
    ordered: false,
    writeConcern: { w: 'majority', j: true, wtimeout: 5000 }
  }
);

// === insertOne 基本用法 ===
db.products.insertOne({
  sku: "PHONE-001",
  title: "Smartphone X",
  price: NumberDecimal("599.99"),
  category: "Electronics",
  stock: 50,
  createdAt: new Date()
});

// 返回结果：
// {
//   acknowledged: true,
//   insertedId: ObjectId('507f1f77bcf86cd799439011')
// }

const result = db.products.insertOne({
  sku: "TEST-001",
  title: "Test Product"
});

print(result.acknowledged);   // true（写入已确认）
print(result.insertedId);      // ObjectId('507f1f77bcf86cd799439012')

// === 不指定 _id（自动生成 ObjectId）===
db.users.insertOne({
  name: "Alice",
  email: "alice@example.com"
});
// 自动生成 _id: ObjectId('507f1f77bcf86cd799439011')

// === 手动指定 _id ===
db.users.insertOne({
  _id: "user_001",       // 字符串 ID
  name: "Alice"
});

db.users.insertOne({
  _id: ObjectId(),       // 手动生成 ObjectId
  name: "Bob"
});

db.users.insertOne({
  _id: NumberLong(1700000000000),  // 时间戳作为 ID
  name: "Charlie"
});

// === _id 重复的错误处理 ===
try {
  db.users.insertOne({
    _id: "user_001",     // 已存在
    name: "Alice Duplicate"
  });
} catch (err) {
  // E11000 duplicate key error collection: shopdb.users index: _id_
  print("❌ _id 已存在：" + err.message);
}

// === 使用 upsert 处理重复 ===
db.users.updateOne(
  { _id: "user_001" },
  { $set: { name: "Alice Updated" } },
  { upsert: true }       // 不存在则插入，存在则更新
);

// === 插入不同类型的字段 ===
db.products.insertOne({
  // 字符串
  sku: "PHONE-X-256-BLK",
  title: "Smartphone X 256GB Black",

  // 数值类型
  price: NumberDecimal("599.99"),       // Decimal128（精确）
  stock: NumberInt(50),                  // Int32
  viewCount: NumberLong(1000000),         // Long

  // 布尔
  isActive: true,
  isFeatured: false,

  // 日期
  createdAt: new Date(),
  releaseDate: ISODate("2026-01-01"),

  // 数组
  tags: ["5g", "amoled", "fast-charging"],
  colors: ["Black", "White", "Blue"],

  // 嵌套文档
  specs: {
    screen: "6.5 inch OLED",
    battery: "4500mAh",
    camera: "108MP"
  },

  // 二进制
  thumbnail: BinData(0, "iVBORw0KGgoAAAANSUhEUgAA..."),

  // Null
  discount: null
});

// 执行成功

// === 策略 1：自动 ObjectId（默认）===
const r1 = db.users.insertOne({ name: "Alice", email: "alice@example.com" });
print(`Auto ObjectId: ${r1.insertedId}`);

// === 策略 2：字符串业务键 ===
const r2 = db.orders.insertOne({
  _id: "ORD-20260701-0001",
  total: NumberDecimal("599.99"),
  status: "pending"
});
print(`Business key: ${r2.insertedId}`);

// === 策略 3：嵌套文档 + 数组 ===
const r3 = db.products.insertOne({
  _id: ObjectId(),
  sku: "PHONE-X-256-BLK",
  specs: { screen: "6.5 inch OLED", battery: "4500mAh" },
  tags: ["5g", "amoled"],
  price: NumberDecimal("599.99")
});
print(`Nested doc: ${r3.insertedId}`);

// === insertMany 基本用法 ===
db.products.insertMany([
  { sku: "PHONE-001", title: "Phone A", price: 599.99 },
  { sku: "PHONE-002", title: "Phone B", price: 699.99 },
  { sku: "PHONE-003", title: "Phone C", price: 799.99 }
]);

// 返回结果：
// {
//   acknowledged: true,
//   insertedIds: {
//     '0': ObjectId('507f1f77bcf86cd799439011'),
//     '1': ObjectId('507f1f77bcf86cd799439012'),
//     '2': ObjectId('507f1f77bcf86cd799439013')
//   },
//   insertedCount: 3
// }

// === ordered: true（默认）— 中间失败则停止 ===
db.products.insertMany([
  { _id: 1, sku: "A" },
  { _id: 2, sku: "B" },
  { _id: 1, sku: "C" },    // ❌ _id 冲突
  { _id: 4, sku: "D" }     // ⚠️ 不会插入（前面失败）
]);
// 错误：E11000 duplicate key error
// 实际插入：A, B（2 条），C 和 D 未插入

// === ordered: false — 跳过失败，继续执行 ===
db.products.insertMany([
  { _id: 1, sku: "A" },
  { _id: 2, sku: "B" },
  { _id: 1, sku: "C" },    // ❌ _id 冲突
  { _id: 4, sku: "D" }     // ✅ 仍然插入
], { ordered: false });

// 错误信息包含所有失败的文档索引：
// BulkWriteError: 1 document(s) failed
// writeErrors: [
//   { index: 2, code: 11000, errmsg: 'duplicate key' }
// ]
// 实际插入：A, B, D（3 条），C 未插入

// === 电商产品批量插入示例 ===
const products = [
  { sku: "LAPTOP-001", title: "Laptop Pro", price: NumberDecimal("1299.99"), category: "Electronics", stock: 20 },
  { sku: "LAPTOP-002", title: "Laptop Air", price: NumberDecimal("999.99"), category: "Electronics", stock: 30 },
  { sku: "PHONE-001", title: "Smartphone X", price: NumberDecimal("599.99"), category: "Electronics", stock: 50 },
  { sku: "BOOK-001", title: "JavaScript Guide", price: NumberDecimal("29.99"), category: "Books", stock: 200 },
  { sku: "BOOK-002", title: "MongoDB Tutorial", price: NumberDecimal("34.99"), category: "Books", stock: 150 }
];

// === 默认模式（有序）===
try {
  const result = db.products.insertMany(products);
  print(`✅ 插入 ${result.insertedCount} 条产品`);
} catch (err) {
  print(`❌ 批量失败：${err.message}`);
}

// === 容错模式（无序）===
try {
  const result = db.products.insertMany(products, { ordered: false });
  print(`✅ 插入 ${result.insertedCount} 条产品`);
} catch (err) {
  print(`⚠️ 部分失败：成功 ${err.result.insertedCount} 条，失败 ${err.writeErrors.length} 条`);
  err.writeErrors.forEach(e => print(`  失败索引 ${e.index}: ${e.errmsg}`));
}

// 执行成功

// === w: 0 — 不等待确认（最快，可能丢失）===
db.products.insertOne(
  { sku: "TEST-001", title: "Test" },
  { writeConcern: { w: 0 } }
);
// 立即返回，不保证写入成功

// === w: 1 — Primary 节点确认（默认）===
db.products.insertOne(
  { sku: "TEST-002", title: "Test" },
  { writeConcern: { w: 1 } }
);
// Primary 写入即返回

// === w: "majority" — 大多数节点确认（最安全）===
db.products.insertOne(
  { sku: "TEST-003", title: "Test" },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
);
// 副本集中大多数节点写入磁盘才返回（推荐生产环境）

// === 集群级别设置（推荐）===
db.adminCommand({
  setDefaultRWConcern: 1,
  defaultWriteConcern: { w: "majority", j: true, wtimeout: 10000 },
  defaultReadConcern: { level: "majority" }
});

// === 单次写入指定 ===
db.orders.insertOne(
  { userId: "user_001", total: 599.99, items: [...] },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
);

// === mongoose 中设置 ===
const OrderSchema = new mongoose.Schema({
  userId: String,
  total: mongoose.Schema.Types.Decimal128,
  items: Array
}, {
  writeConcern: { w: 'majority', j: true, wtimeout: 5000 }
});

// mongoose 操作成功执行
// 数据库查询/更新结果

// === _id 重复的错误 ===
db.users.insertOne({ _id: 1, name: "Alice" });
// { acknowledged: true, insertedId: 1 }

db.users.insertOne({ _id: 1, name: "Bob Duplicate" });
// E11000 duplicate key error collection: shopdb.users index: _id_ dup key: { _id: 1 }

// === 策略 1：使用 ordered: false 跳过重复 ===
try {
  db.users.insertMany(
    [{ _id: 1, name: "Alice" }, { _id: 2, name: "Bob" }, { _id: 1, name: "Dup" }],
    { ordered: false }
  );
} catch (err) {
  print(`跳过 ${err.writeErrors.length} 条重复`);
}

// === 策略 2：使用 replaceOne 覆盖 ===
db.users.replaceOne(
  { _id: 1 },
  { _id: 1, name: "Alice Updated", updatedAt: new Date() },
  { upsert: true }
);

// === 策略 3：使用 updateOne + upsert ===
db.users.updateOne(
  { _id: 1 },
  { $set: { name: "Alice", email: "alice@example.com" } },
  { upsert: true }   // 不存在则插入，存在则更新
);

// === 策略 4：插入时让 MongoDB 自动生成 _id ===
const docs = externalData.map(d => {
  const { _id, ...rest } = d;   // 解构去掉 _id
  return rest;                   // 让 MongoDB 自动生成 _id
});
db.users.insertMany(docs);

// === 策略 5：重试机制（应用层）===
async function insertWithRetry(doc, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await db.collection('users').insertOne(doc);
    } catch (err) {
      if (err.code === 11000 && i < maxRetries - 1) {
        // 生成新的 _id 重试
        doc._id = new ObjectId();
        continue;
      }
      throw err;
    }
  }
}

// === 场景：导入 CSV 数据，部分 _id 已存在 ===
const csvData = [
  { _id: "USER-001", name: "Alice", email: "alice@example.com" },
  { _id: "USER-002", name: "Bob", email: "bob@example.com" },
  { _id: "USER-001", name: "Alice Duplicate", email: "alice2@example.com" },
  { _id: "USER-003", name: "Charlie", email: "charlie@example.com" }
];

// === 方案 A：忽略重复，仅插入新数据 ===
const insertedIds = [];
const duplicates = [];

csvData.forEach(doc => {
  try {
    const result = db.users.insertOne(doc);
    insertedIds.push(result.insertedId);
  } catch (err) {
    if (err.code === 11000) {
      duplicates.push(doc._id);
    } else {
      throw err;
    }
  }
});

print(`✅ 插入 ${insertedIds.length} 条新数据`);
print(`⚠️ 跳过 ${duplicates.length} 条重复：${duplicates.join(', ')}`);

// === 方案 B：覆盖重复，更新已有数据 ===
db.users.bulkWrite(
  csvData.map(doc => ({
    replaceOne: {
      filter: { _id: doc._id },
      replacement: doc,
      upsert: true
    }
  })),
  { ordered: false }
);

// 执行成功

// === 优化 1：合理的批量大小 ===
const BATCH_SIZE = 1000;  // 推荐 500-5000

for (let i = 0; i < data.length; i += BATCH_SIZE) {
  const batch = data.slice(i, i + BATCH_SIZE);
  db.collection.insertMany(batch, { ordered: false });
}

// === 优化 2：使用 bulkWrite 替代 insertMany ===
await Collection.bulkWrite(
  data.map(doc => ({ insertOne: { document: doc } })),
  { ordered: false }
);

// === 优化 3：禁用索引（导入期间）===
// ⚠️ 谨慎使用：导入完记得重建索引
db.products.dropIndexes();
db.products.insertMany(data);
// 重建索引
db.products.createIndex({ sku: 1 }, { unique: true });

// === 优化 4：使用 Write Concern 0（极快但不安全）===
db.products.insertMany(data, { writeConcern: { w: 0 } });
// ⚠️ 仅用于临时数据，不推荐生产

// === 优化 5：使用 mongoose bulkWrite ===
const result = await Product.bulkWrite(
  data.map(doc => ({
    insertOne: { document: doc }
  })),
  { ordered: false }
);

// === 导入 100 万产品数据（优化版）===
const fs = require('fs');
const readline = require('readline');
const { MongoClient } = require('mongodb');

async function importLargeDataset() {
  const client = new MongoClient('mongodb://localhost:27017');
  await client.connect();
  const collection = client.db('shopdb').collection('products');

  // 1. 临时删除索引（导入速度 ↑5x）
  await collection.dropIndexes().catch(() => {});
  await collection.createIndex({ sku: 1 }, { unique: true }); // 保留唯一索引（防重复）

  // 2. 流式读取 CSV
  const fileStream = fs.createReadStream('products.csv');
  const rl = readline.createInterface({ input: fileStream });

  let buffer = [];
  const BATCH_SIZE = 2000;

  for await (const line of rl) {
    const [sku, title, price, category] = line.split(',');
    buffer.push({
      sku,
      title,
      price: price ? NumberDecimal(price) : null,
      category,
      createdAt: new Date()
    });

    if (buffer.length >= BATCH_SIZE) {
      try {
        await collection.insertMany(buffer, { ordered: false });
      } catch (err) {
        if (err.writeErrors) {
          console.warn(`⚠️ 跳过 ${err.writeErrors.length} 条重复`);
        }
      }
      buffer = [];
    }
  }

  // 3. 插入剩余数据
  if (buffer.length > 0) {
    await collection.insertMany(buffer, { ordered: false });
  }

  // 4. 重建索引
  await collection.createIndex({ category: 1, price: 1 });
  await collection.createIndex({ title: 'text' });

  console.log(`✅ 导入完成`);
  await client.close();
}

importLargeDataset().catch(console.error);

// 执行成功

// === 当前时间 ===
db.logs.insertOne({ event: "login", timestamp: new Date() });

// === 指定时间 ===
db.logs.insertOne({
  event: "signup",
  timestamp: ISODate("2026-07-01T10:30:00Z")
});

// === 从字符串创建 ===
db.logs.insertOne({
  event: "purchase",
  timestamp: new Date("2026-07-01")
});

// === 自动生成 ===
db.users.insertOne({ name: "Alice" });

// === 手动创建 ===
db.users.insertOne({
  _id: new ObjectId(),
  name: "Bob"
});

// === 从 24 位 hex 字符串创建 ===
db.users.insertOne({
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "Charlie"
});

// === 从时间戳创建（用于范围查询）===
const startOfDay = ObjectId.createFromTime(
  Math.floor(new Date('2026-07-01').getTime() / 1000)
);
db.orders.insertOne({
  _id: startOfDay,
  total: 999.99
});

// === 嵌套对象 ===
db.products.insertOne({
  sku: "PHONE-001",
  specs: {
    screen: { size: "6.5", type: "OLED" },
    battery: { capacity: "4500mAh", type: "Li-Po" }
  }
});

// === 数组 ===
db.products.insertOne({
  sku: "SHIRT-001",
  sizes: ["S", "M", "L", "XL"],
  colors: [
    { name: "Red", hex: "#FF0000" },
    { name: "Blue", hex: "#0000FF" }
  ]
});

// === 订单文档（含所有特殊类型）===
db.orders.insertOne({
  _id: ObjectId(),
  orderNumber: "ORD-20260701-0001",

  // 字符串 + 数值
  userId: "user_001",
  total: NumberDecimal("1299.99"),
  tax: NumberDecimal("130.00"),

  // 数组 + 嵌套
  items: [
    { sku: "LAPTOP-001", qty: 1, price: NumberDecimal("1299.99") },
    { sku: "MOUSE-001", qty: 2, price: NumberDecimal("29.99") }
  ],

  // 状态
  status: "pending",
  isPaid: false,

  // 日期
  createdAt: new Date(),
  expectedDelivery: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 天后

  // 二进制（PDF 收据）
  receiptPdf: BinData(0, "JVBERi0xLjQKJ..."),

  // 引用
  shippingAddressId: ObjectId("507f1f77bcf86cd799439011"),

  // 元数据
  metadata: {
    userAgent: "Mozilla/5.0...",
    ipAddress: "192.168.1.1"
  }
});

// 执行成功

// === 启用详细日志 ===
db.adminCommand({ setParameter: 1, logComponentVerbosity: { write: { verbosity: 2 } } });

// === 查看慢查询日志 ===
db.system.profile.find().sort({ ts: -1 }).limit(5);

// === 检查文档大小 ===
const doc = { /* your document */ };
print(`文档大小：${BSON.calculateObjectSize(doc)} bytes`);
print(`嵌套深度：${getDepth(doc)}`);

// === 查看当前数据库操作 ===
db.currentOp({ "op": "insert" });

// === 监控写入性能 ===
db.serverStatus().opcounters;
// {
//   insert: 12345,
//   query: 67890,
//   update: 2345,
//   delete: 100,
//   ...
// }

// === 查看写入延迟 ===
db.serverStatus().opLatencies.writes;
// { latency: 12345, ops: 10000 }