MongoDB: ドキュメントの挿入：MongoDBの作成操作をマスターする

// === Node.js一括インポートスクリプト（最適化版）===
const mongoose = require('mongoose');
const Product = require('./models/Product');

async function importProducts(products) {
  // バッチサイズ1000でバッチインサート
  const batchSize = 1000;
  const batches = [];

  for (let i = 0; i < products.length; i += batchSize) {
    batches.push(products.slice(i, i + batchSize));
  }

  console.log(`📦 Importing ${products.length} products in ${batches.length} batches...`);

  // 一括書き込み（ordered: false で失敗を許容）
  let inserted = 0;
  for (const batch of batches) {
    const operations = batch.map(p => ({
      insertOne: { document: p }
    }));

    const result = await Product.bulkWrite(operations, {
      ordered: false,  // 一部が失敗しても続行
      writeConcern: { w: 1 }  // ローカル開発用、本番では majority を使用
    });

    inserted += result.insertedCount;
    console.log(`✅ Inserted ${inserted}/${products.length}`);
  }

  console.log(`🎉 Import complete: ${inserted} products`);
}

// 使用例
const products = [];  // 100,000件の商品データ
await importProducts(products);

// === 単一ドキュメントの挿入 ===
db.products.insertOne({
  sku: "PHONE-001",
  title: "Smartphone X",
  price: 599.99,
  stock: 50
})

// === カスタム主キーを指定 ===
db.products.insertOne({
  _id: "PHONE-001",  // カスタム主キー
  title: "Smartphone X",
  price: 599.99
})

// 検索時はカスタム主キーを使用
db.products.findOne({ _id: "PHONE-001" })

// === 例1：最小限のドキュメント（自動生成_id）===
db.users.insertOne({ name: "Alice" })

// === 例2：ネストされたドキュメント ===
db.users.insertOne({
  name: "Bob",
  email: "bob@example.com",
  address: {
    street: "123 Main St",
    city: "Tokyo",
    country: "Japan"
  },
  hobbies: ["reading", "coding", "hiking"]
})

// === 例3：異なるBSONデータ型 ===
db.accounts.insertOne({
  accountId: "ACC-001",
  balance: NumberDecimal("12345.67"),  // Decimal128
  createdAt: new Date(),                // Date
  isActive: true,                       // Boolean
  tags: ["premium", "verified"]         // Array
})

// === 複数ドキュメントの一括挿入 ===
db.products.insertMany([
  { sku: "PHONE-001", title: "Smartphone X", price: 599.99 },
  { sku: "LAPTOP-001", title: "Laptop Y", price: 1299.99 },
  { sku: "TABLET-001", title: "Tablet Z", price: 499.99 }
])

// === ordered: falseで失敗時に続行 ===
db.products.insertMany([
  { _id: "PHONE-001", title: "Smartphone X" },
  { _id: "PHONE-001", title: "Duplicate ID" },  // 重複エラー
  { _id: "LAPTOP-001", title: "Laptop Y" }
], { ordered: false })

// === 1000件のドキュメントを一括インポート ===
const products = [];
for (let i = 1; i <= 1000; i++) {
  products.push({
    sku: `PROD-${i.toString().padStart(5, '0')}`,
    title: `Product ${i}`,
    price: Math.random() * 1000,
    stock: Math.floor(Math.random() * 100)
  });
}

// バッチインサート
const result = db.products.insertMany(products, { ordered: false });
print(`Inserted ${result.insertedCount} products`);

// === 種類の混在一括書き込み ===
db.products.bulkWrite([
  { insertOne: { document: { sku: "NEW-001", title: "New Product" } } },
  { updateOne: {
      filter: { sku: "PHONE-001" },
      update: { $set: { price: 549.99 } }
  }},
  { deleteOne: { filter: { sku: "OLD-001" } } }
])

// === 一括インポート（insertOneの配列）===
const operations = [];
for (let i = 1; i <= 5000; i++) {
  operations.push({
    insertOne: {
      document: {
        sku: `PROD-${i}`,
        title: `Product ${i}`,
        price: Math.random() * 1000
      }
    }
  });
}

const result = db.products.bulkWrite(operations, { ordered: false });
print(`Inserted ${result.insertedCount} products`);

// === アップサートを含む一括書き込み ===
db.products.bulkWrite([
  // 新規作成
  { insertOne: { document: { sku: "PHONE-002", title: "Phone 2", price: 699 } } },

  // 既存商品の価格を更新
  { updateOne: {
      filter: { sku: "PHONE-001" },
      update: { $inc: { price: 50 } }
  }},

  // アップサート（存在しない場合は作成）
  { updateOne: {
      filter: { sku: "PHONE-003" },
      update: { $set: { title: "Phone 3", price: 799 } },
      upsert: true
  }},

  // 廃止商品を削除
  { deleteMany: {
      filter: { status: "discontinued" }
  }}
], { ordered: false })

// === 書き込み確認を指定 ===
db.products.insertOne(
  { sku: "PHONE-001", title: "Smartphone X" },
  { writeConcern: { w: "majority", j: true } }
)

// === タイムアウト付き書き込み確認 ===
db.products.insertOne(
  { sku: "PHONE-002", title: "Smartphone Y" },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
)

// === エラーハンドリング（Node.js）===
const mongoose = require('mongoose');

async function insertProduct(productData) {
  try {
    const product = await Product.create(productData);
    console.log('✅ Product inserted:', product._id);
    return product;
  } catch (err) {
    if (err.code === 11000) {
      console.error('❌ Duplicate key error:', err.message);
      // アップサートまたはスキップ
      return await Product.findOneAndUpdate(
        { sku: productData.sku },
        productData,
        { upsert: true, new: true }
      );
    } else if (err.name === 'ValidationError') {
      console.error('❌ Validation error:', err.message);
      throw err;  // クライアントに返す
    } else {
      console.error('❌ Database error:', err);
      throw err;
    }
  }
}

// === 一括インポート（エラーハンドリング付き）===
async function bulkImport(products) {
  const operations = products.map(p => ({
    insertOne: { document: p }
  }));

  try {
    const result = await Product.bulkWrite(operations, {
      ordered: false,
      writeConcern: { w: 1 }
    });
    console.log(`✅ Inserted ${result.insertedCount} products`);
    return result;
  } catch (err) {
    if (err.name === 'MongoBulkWriteError') {
      console.log('⚠️ Partial success:');
      console.log(`  Inserted: ${err.insertedCount}`);
      console.log(`  Errors: ${err.writeErrors.length}`);
      
      // 失敗したドキュメントをログ
      err.writeErrors.forEach(e => {
        console.log(`  Failed index ${e.index}: ${e.errmsg}`);
      });
      
      return err;
    }
    throw err;
  }
}

// === mongooseスキーマの定義 ===
const mongoose = require('mongoose');

const productSchema = new mongoose.Schema({
  sku: { type: String, required: true, unique: true },
  title: { type: String, required: true },
  price: { type: Number, required: true, min: 0 },
  stock: { type: Number, default: 0 },
  category: { type: String, enum: ['Electronics', 'Clothing', 'Books'] },
  isActive: { type: Boolean, default: true }
}, { timestamps: true });  // createdAt, updatedAtを自動管理

const Product = mongoose.model('Product', productSchema);

// === 単一ドキュメントの作成 ===
const product = await Product.create({
  sku: "PHONE-001",
  title: "Smartphone X",
  price: 599.99,
  stock: 50
});
console.log(product._id);           // ObjectId
console.log(product.createdAt);     // 自動生成
console.log(product.updatedAt);     // 自動生成

// === 複数ドキュメントの一括作成 ===
const products = await Product.insertMany([
  { sku: "LAPTOP-001", title: "Laptop Y", price: 1299.99 },
  { sku: "TABLET-001", title: "Tablet Z", price: 499.99 }
], { ordered: false });

// === インスタンスを作成して保存（ミドルウェア実行）===
const newProduct = new Product({
  sku: "WATCH-001",
  title: "Smart Watch",
  price: 299.99
});
await newProduct.save();  // pre/postフックが実行される

// === mongoose一括インポート（エラーハンドリング付き）===
async function importProducts(productsData) {
  try {
    // スキーマ検証をスキップ（高速化）
    const result = await Product.insertMany(productsData, {
      ordered: false,
      rawResult: true  // 詳細な結果を取得
    });
    
    console.log(`✅ Imported ${result.insertedCount} products`);
    return result;
  } catch (err) {
    if (err.name === 'MongoBulkWriteError') {
      console.log(`⚠️ Partial import: ${err.insertedCount} succeeded`);
      console.log(`   Failed: ${err.writeErrors.length}`);
      return err;
    }
    throw err;
  }
}

// 使用例
const products = [];
for (let i = 1; i <= 10000; i++) {
  products.push({
    sku: `PROD-${i}`,
    title: `Product ${i}`,
    price: Math.random() * 1000
  });
}

await importProducts(products);

// === パフォーマンステスト（1万件のドキュメント）===
async function performanceTest() {
  const count = 10000;
  const products = [];
  for (let i = 1; i <= count; i++) {
    products.push({
      sku: `PROD-${i}`,
      title: `Product ${i}`,
      price: Math.random() * 1000
    });
  }

  // テスト1：単一インサート
  console.time('insertOne');
  for (const p of products) {
    await Product.create(p);
  }
  console.timeEnd('insertOne');  // ~30秒

  // テスト2：バッチインサート
  console.time('insertMany');
  await Product.insertMany(products, { ordered: false });
  console.timeEnd('insertMany');  // ~2秒
}

performanceTest();