Inserting Documents: A Detailed Explanation of `insertOne` and `insertMany`

// === Usage bulkWrite + ordered: false Resolving Partial Failure Issues ===
const products = [...];  // 100,000 product records

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 }  // Allow for Partial Failure，Continue execution
    );
  } catch (err) {
    console.error(`Batch ${i / BATCH_SIZE} Failure：${err.writeErrors?.length} items`);
  }
}

// === Usage Write Concern Ensure Data Persistence ===
await Product.bulkWrite(
  batch.map(doc => ({ insertOne: { document: doc } })),
  {
    ordered: false,
    writeConcern: { w: 'majority', j: true, wtimeout: 5000 }
  }
);

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

// Return Results：
// {
//   acknowledged: true,
//   insertedId: ObjectId('507f1f77bcf86cd799439011')
// }

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

print(result.acknowledged);   // true（Write confirmed）
print(result.insertedId);      // ObjectId('507f1f77bcf86cd799439012')

// === Not specified _id（Automatically Generated ObjectId）===
db.users.insertOne({
  name: "Alice",
  email: "alice@example.com"
});
// Automatically Generated _id: ObjectId('507f1f77bcf86cd799439011')

// === Specify manually _id ===
db.users.insertOne({
  _id: "user_001",       // String ID
  name: "Alice"
});

db.users.insertOne({
  _id: ObjectId(),       // Generated Manually ObjectId
  name: "Bob"
});

db.users.insertOne({
  _id: NumberLong(1700000000000),  // Timestamps as ID
  name: "Charlie"
});

// === _id Handling Repeated Errors ===
try {
  db.users.insertOne({
    _id: "user_001",     // Already exists
    name: "Alice Duplicate"
  });
} catch (err) {
  // E11000 duplicate key error collection: shopdb.users index: _id_
  print("❌ _id Already exists：" + err.message);
}

// === Usage upsert Handling Duplicates ===
db.users.updateOne(
  { _id: "user_001" },
  { $set: { name: "Alice Updated" } },
  { upsert: true }       // If it doesn't exist, insert it，If it exists, update it
);

// === Inserting Different Types of Fields ===
db.products.insertOne({
  // String
  sku: "PHONE-X-256-BLK",
  title: "Smartphone X 256GB Black",

  // Numeric Types
  price: NumberDecimal("599.99"),       // Decimal128（Accurate）
  stock: NumberInt(50),                  // Int32
  viewCount: NumberLong(1000000),         // Long

  // Boolean
  isActive: true,
  isFeatured: false,

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

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

  // Nested Documents
  specs: {
    screen: "6.5 inch OLED",
    battery: "4500mAh",
    camera: "108MP"
  },

  // Binary
  thumbnail: BinData(0, "iVBORw0KGgoAAAANSUhEUgAA..."),

  // Null
  discount: null
});

// === Strategy 1：Automatic ObjectId（Default）===
const r1 = db.users.insertOne({ name: "Alice", email: "alice@example.com" });
print(`Auto ObjectId: ${r1.insertedId}`);

// === Strategy 2：String Business Key ===
const r2 = db.orders.insertOne({
  _id: "ORD-20260701-0001",
  total: NumberDecimal("599.99"),
  status: "pending"
});
print(`Business key: ${r2.insertedId}`);

// === Strategy 3：Nested Documents + Array ===
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 Basic Usage ===
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 }
]);

// Return Results：
// {
//   acknowledged: true,
//   insertedIds: {
//     '0': ObjectId('507f1f77bcf86cd799439011'),
//     '1': ObjectId('507f1f77bcf86cd799439012'),
//     '2': ObjectId('507f1f77bcf86cd799439013')
//   },
//   insertedCount: 3
// }

// === ordered: true（Default）— If it fails in the middle, stop ===
db.products.insertMany([
  { _id: 1, sku: "A" },
  { _id: 2, sku: "B" },
  { _id: 1, sku: "C" },    // ❌ _id Conflict
  { _id: 4, sku: "D" }     // ⚠️ Will not be inserted（Previous failure）
]);
// Error：E11000 duplicate key error
// Actual insertion：A, B（2 items），C and D Not inserted

// === ordered: false — Skip failure，Continue execution ===
db.products.insertMany([
  { _id: 1, sku: "A" },
  { _id: 2, sku: "B" },
  { _id: 1, sku: "C" },    // ❌ _id Conflict
  { _id: 4, sku: "D" }     // ✅ Still inserted
], { ordered: false });

// The error message lists all documents that failed to be indexed：
// BulkWriteError: 1 document(s) failed
// writeErrors: [
//   { index: 2, code: 11000, errmsg: 'duplicate key' }
// ]
// Actual insertion：A, B, D（3 items），C Not inserted

// === Example of Batch Importing E-commerce Products ===
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 }
];

// === Default Mode（Orderly）===
try {
  const result = db.products.insertMany(products);
  print(`✅ Insert ${result.insertedCount} Items`);
} catch (err) {
  print(`❌ Batch Failure：${err.message}`);
}

// === Fault-Tolerant Mode（Disorder）===
try {
  const result = db.products.insertMany(products, { ordered: false });
  print(`✅ Insert ${result.insertedCount} Items`);
} catch (err) {
  print(`⚠️ Partial failure：Success ${err.result.insertedCount} items，Failure ${err.writeErrors.length} items`);
  err.writeErrors.forEach(e => print(`  Index of Failures ${e.index}: ${e.errmsg}`));
}

// === w: 0 — Do not wait for confirmation（Fastest，May be missing）===
db.products.insertOne(
  { sku: "TEST-001", title: "Test" },
  { writeConcern: { w: 0 } }
);
// Return Now，Write success is not guaranteed

// === w: 1 — Primary Node Confirmation（Default）===
db.products.insertOne(
  { sku: "TEST-002", title: "Test" },
  { writeConcern: { w: 1 } }
);
// Primary Write and Return

// === w: "majority" — Confirmed by a majority of nodes（Safest）===
db.products.insertOne(
  { sku: "TEST-003", title: "Test" },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
);
// The replica waits until most nodes have written to disk before returning（Recommended Production Environment）

// === Cluster-Level Settings（Recommendations）===
db.adminCommand({
  setDefaultRWConcern: 1,
  defaultWriteConcern: { w: "majority", j: true, wtimeout: 10000 },
  defaultReadConcern: { level: "majority" }
});

// === Single-Write Specification ===
db.orders.insertOne(
  { userId: "user_001", total: 599.99, items: [...] },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
);

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

// === _id Repeated Mistakes ===
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 }

// === Strategy 1：Usage ordered: false Skip duplicates ===
try {
  db.users.insertMany(
    [{ _id: 1, name: "Alice" }, { _id: 2, name: "Bob" }, { _id: 1, name: "Dup" }],
    { ordered: false }
  );
} catch (err) {
  print(`Skip ${err.writeErrors.length} Duplicate entry`);
}

// === Strategy 2：Usage replaceOne Coverage ===
db.users.replaceOne(
  { _id: 1 },
  { _id: 1, name: "Alice Updated", updatedAt: new Date() },
  { upsert: true }
);

// === Strategy 3：Usage updateOne + upsert ===
db.users.updateOne(
  { _id: 1 },
  { $set: { name: "Alice", email: "alice@example.com" } },
  { upsert: true }   // If it doesn't exist, insert it，If it exists, update it
);

// === Strategy 4：When inserting, make sure to MongoDB Automatically Generated _id ===
const docs = externalData.map(d => {
  const { _id, ...rest } = d;   // Deconstruct and remove _id
  return rest;                   // let MongoDB automatically generate _id
});
db.users.insertMany(docs);

// === Strategy 5：Retry Mechanism（Application Layer）===
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) {
        // Generate a new one _id Retry
        doc._id = new ObjectId();
        continue;
      }
      throw err;
    }
  }
}

// === Scene：Import CSV Data，Part _id Already exists ===
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" }
];

// === Plan A：Ignore duplicates，Insert new data only ===
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(`✅ Insert ${insertedIds.length} new data entries`);
print(`⚠️ Skip ${duplicates.length} Duplicate entry：${duplicates.join(', ')}`);

// === Plan B：Duplicate Coverage，Update existing data ===
db.users.bulkWrite(
  csvData.map(doc => ({
    replaceOne: {
      filter: { _id: doc._id },
      replacement: doc,
      upsert: true
    }
  })),
  { ordered: false }
);

// === Optimization 1：Reasonable Batch Size ===
const BATCH_SIZE = 1000;  // Recommendations 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 });
}

// === Optimization 2：Usage bulkWrite Replace insertMany ===
await Collection.bulkWrite(
  data.map(doc => ({ insertOne: { document: doc } })),
  { ordered: false }
);

// === Optimization 3：Disable Index（During the import）===
// ⚠️ Use with caution：After the import is complete, remember to rebuild the indexes.
db.products.dropIndexes();
db.products.insertMany(data);
// Rebuild Index
db.products.createIndex({ sku: 1 }, { unique: true });

// === Optimization 4：Usage Write Concern 0（Extremely fast but unsafe）===
db.products.insertMany(data, { writeConcern: { w: 0 } });
// ⚠️ For temporary data only，Not recommended for production

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

// === Import 100 Product Data for 10,000 Items（Optimized Version）===
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. Temporarily Delete an Index（Import Speed ↑5x）
  await collection.dropIndexes().catch(() => {});
  await collection.createIndex({ sku: 1 }, { unique: true }); // Preserve the unique index（Duplicate Prevention）

  // 2. Streaming Read 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(`⚠️ Skip ${err.writeErrors.length} Duplicate entry`);
        }
      }
      buffer = [];
    }
  }

  // 3. Insert the remaining data
  if (buffer.length > 0) {
    await collection.insertMany(buffer, { ordered: false });
  }

  // 4. Rebuild Index
  await collection.createIndex({ category: 1, price: 1 });
  await collection.createIndex({ title: 'text' });

  console.log(`✅ Import Complete`);
  await client.close();
}

importLargeDataset().catch(console.error);

// === Current Time ===
db.logs.insertOne({ event: "login", timestamp: new Date() });

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

// === Create from a string ===
db.logs.insertOne({
  event: "purchase",
  timestamp: new Date("2026-07-01")
});

// === Automatically Generated ===
db.users.insertOne({ name: "Alice" });

// === Create Manually ===
db.users.insertOne({
  _id: new ObjectId(),
  name: "Bob"
});

// === Create from 24-digit hex string ===
db.users.insertOne({
  _id: ObjectId("507f1f77bcf86cd799439011"),
  name: "Charlie"
});

// === Created from a timestamp（Used for range queries）===
const startOfDay = ObjectId.createFromTime(
  Math.floor(new Date('2026-07-01').getTime() / 1000)
);
db.orders.insertOne({
  _id: startOfDay,
  total: 999.99
});

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

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

// === Order Documentation（Includes all special types）===
db.orders.insertOne({
  _id: ObjectId(),
  orderNumber: "ORD-20260701-0001",

  // String + Value
  userId: "user_001",
  total: NumberDecimal("1299.99"),
  tax: NumberDecimal("130.00"),

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

  // Status
  status: "pending",
  isPaid: false,

  // Date
  createdAt: new Date(),
  expectedDelivery: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days

  // Binary (PDF receipt)
  receiptPdf: BinData(0, "JVBERi0xLjQKJ..."),

  // Quote
  shippingAddressId: ObjectId("507f1f77bcf86cd799439011"),

  // Metadata
  metadata: {
    userAgent: "Mozilla/5.0...",
    ipAddress: "192.168.1.1"
  }
});

// === Enable detailed logging ===
db.adminCommand({ setParameter: 1, logComponentVerbosity: { write: { verbosity: 2 } } });

// === View the slow query log ===
db.system.profile.find().sort({ ts: -1 }).limit(5);

// === Check the document size ===
const doc = { /* your document */ };
print(`Document Size：${BSON.calculateObjectSize(doc)} bytes`);
print(`Nesting Depth：${getDepth(doc)}`);

// === View Current Database Operations ===
db.currentOp({ "op": "insert" });

// === Monitoring Write Performance ===
db.serverStatus().opcounters;
// {
//   insert: 12345,
//   query: 67890,
//   update: 2345,
//   delete: 100,
//   ...
// }

// === View Write Latency ===
db.serverStatus().opLatencies.writes;
// { latency: 12345, ops: 10000 }