MongoDB: ドキュメント検索の基礎：findメソッドとプロジェクション

// ❌ 反例：全フィールドを返す
app.get('/api/products', async (req, res) => {
  const products = await Product.find();  // 全フィールドを返す
  res.json(products);
});
// 各商品 5KB、100件 = 500KB
// ネットワークが遅い + フロントエンドのパースが遅い

// ✅ 正例：必要なフィールドのみ返す
app.get('/api/products', async (req, res) => {
  const products = await Product.find(
    { isActive: true },
    {
      projection: {
        sku: 1,
        title: 1,
        price: 1,
        thumbnail: 1,
        _id: 0   // _idを除外
      }
    }
  )
    .sort({ createdAt: -1 })
    .limit(20)
    .lean();   // mongooseのhydrateをスキップ、パフォーマンス↑3-5倍

  res.json(products);
});
// 各商品 200 Byte、20件 = 4KB（パフォーマンス↑100倍）

// === find基本構文 ===
db.products.find();
// 全ドキュメントを返す（カーソル）

// === find条件指定 ===
db.products.find({ category: "Electronics" });
// 全Electronics製品を返す

// === find配列として返す ===
db.products.find({ category: "Electronics" }).toArray();
// Array<Document>を返す

// === findイテレート（カーソル）===
db.products.find({ category: "Electronics" }).forEach(printjson);

// === findOneは単一ドキュメントを返す ===
db.products.findOne({ sku: "PHONE-001" });
// 最初に一致したドキュメントを返す（またはnull）

// === findOne vs find().limit(1)の違い ===
const doc1 = db.products.findOne({ sku: "PHONE-001" });
const doc2 = db.products.find({ sku: "PHONE-001" }).limit(1).next();
// 結果は同じ、findOneの方が簡潔

// === mongoose: findは配列を返す ===
const products = await Product.find({ category: "Electronics" });
// Array<Product>

// === mongoose: findOneはオブジェクトを返す ===
const product = await Product.findOne({ sku: "PHONE-001" });
// Product | null

// === 検索結果が空の場合の処理 ===
const product = await Product.findOne({ sku: "NOT_EXIST" });
if (!product) {
  return res.status(404).json({ error: "Product not found" });
}

// === mongoshでの検索 ===
// 全ドキュメントを検索
db.products.find();

// 指定条件で検索
db.products.find({ category: "Electronics" });

// 複数条件検索（AND）
db.products.find({
  category: "Electronics",
  stock: { $gt: 0 }     // 在庫が0より大きい
});

// 検索してフォーマット
db.products.find({ category: "Electronics" }).pretty();

// 検索してカウント
db.products.find({ category: "Electronics" }).count();

// === Node.jsでの検索 ===
const { MongoClient } = require('mongodb');

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

  // 1. find()はカーソルを返す
  const cursor = collection.find({ category: "Electronics" });
  const products = await cursor.toArray();
  console.log(`Found ${products.length} products`);

  // 2. findOne()はドキュメントを返す
  const product = await collection.findOne({ sku: "PHONE-001" });
  console.log(product);

  // 3. カーソルをイテレート（ストリーム）
  for await (const doc of collection.find({ category: "Electronics" })) {
    console.log(doc.title);
  }

  await client.close();
}

findProducts();

// === 完全一致 ===
db.products.find({ sku: "PHONE-001" });

// === 複数条件AND ===
db.products.find({
  category: "Electronics",
  stock: 50,
  isActive: true
});

// === フィールド不在 ===
db.products.find({ discount: { $exists: false } });

// === ネストドキュメント検索 ===
db.products.find({ "specs.battery": "4500mAh" });

// === 配列要素マッチング ===
db.products.find({ tags: "5g" });

// === 配列内の複数要素マッチング ===
db.products.find({ tags: { $all: ["5g", "amoled"] } });

// === $eq（等しい、デフォルト）===
db.products.find({ price: { $eq: 599.99 } });
// { price: 599.99 } と同等

// === $ne（等しくない）===
db.products.find({ category: { $ne: "Books" } });

// === $gt / $gte（より大きい / 以上）===
db.products.find({ price: { $gt: 100 } });        // > 100
db.products.find({ price: { $gte: 100 } });       // >= 100

// === $lt / $lte（より小さい / 以下）===
db.products.find({ price: { $lt: 1000 } });
db.products.find({ price: { $lte: 1000 } });

// === $in / $nin（含む / 含まない）===
db.products.find({ category: { $in: ["Electronics", "Books"] } });
db.products.find({ category: { $nin: ["Clothing"] } });

// === 範囲検索 ===
db.products.find({
  price: { $gte: 100, $lte: 1000 }  // 100 <= price <= 1000
});

// === $and（暗黙のAND）===
db.products.find({
  category: "Electronics",
  stock: { $gt: 0 }    // 暗黙のAND
});

// === $and（明示的AND）===
db.products.find({
  $and: [
    { category: "Electronics" },
    { $or: [{ stock: { $gt: 10 } }, { isFeatured: true }] }
  ]
});

// === $or ===
db.products.find({
  $or: [
    { category: "Electronics" },
    { tags: "bestseller" }
  ]
});

// === $not ===
db.products.find({ price: { $not: { $gt: 1000 } } });
// 価格 <= 1000

// === $nor（全て満たさない）===
db.products.find({
  $nor: [
    { category: "Electronics" },
    { category: "Books" }
  ]
});

// === シーン：価格100-1000、在庫0より大、ElectronicsまたはBooksカテゴリの商品を検索 ===
db.products.find({
  price: { $gte: 100, $lte: 1000 },
  stock: { $gt: 0 },
  $or: [
    { category: "Electronics" },
    { category: "Books" }
  ],
  isActive: true
}).sort({ price: 1 }).limit(20);

// === Mongoose相当の記述 ===
const products = await Product.find({
  price: { $gte: 100, $lte: 1000 },
  stock: { $gt: 0 },
  $or: [{ category: "Electronics" }, { category: "Books" }],
  isActive: true
})
  .sort({ price: 1 })
  .limit(20)
  .lean();

// === フィールドホワイトリスト（指定フィールドのみ返す）===
db.products.find(
  { category: "Electronics" },
  { sku: 1, title: 1, price: 1 }
);
// 返却：{ _id, sku, title, price }

// === _idはデフォルトで返却、明示的に除外が必要 ===
db.products.find(
  {},
  { sku: 1, title: 1, _id: 0 }  // _id: 0 で_idを除外
);

// === フィールドブラックリスト（指定フィールドを除外）===
db.products.find(
  {},
  { internalNotes: 0, debugInfo: 0 }  // 機密フィールドを除外
);

// === ネストドキュメントのプロジェクション ===
db.products.find(
  { sku: "PHONE-001" },
  {
    sku: 1,
    title: 1,
    "specs.screen": 1,    // specs.screenのみ返す
    "specs.battery": 1   // specs.batteryのみ返す
  }
);

// === 配列要素のプロジェクション（$slice）===
db.reviews.find(
  { productId: "PHONE-001" },
  {
    title: 1,
    content: 1,
    comments: { $slice: 3 }  // 最初の3件のコメントのみ返す
  }
);

// === パフォーマンステスト：100万ドキュメント、100件を検索 ===

// ❌ プロジェクションなし：5MB返却
db.products.find({ category: "Electronics" }).limit(100);
// 所要時間 800ms

// ✅ プロジェクションあり：200KB返却
db.products.find(
  { category: "Electronics" },
  { sku: 1, title: 1, price: 1, _id: 0 }
).limit(100);
// 所要時間 80ms（パフォーマンス↑10倍）

// === 方法1：projectionオプション ===
const products = await Product.find({ category: "Electronics" }, "sku title price");
// 文字列構文（スペース区切り）

// === 方法2：select()チェーン ===
const products = await Product.find()
  .select("sku title price")
  .select("-description -images");  // 特定フィールドを除外

// === 方法3：オブジェクト構文 ===
const products = await Product.find(
  { category: "Electronics" },
  { sku: 1, title: 1, price: 1, _id: 0 }
);

// === 方法4：lean() + select()で最高パフォーマンス ===
const products = await Product.find()
  .select("sku title price")
  .lean()  // mongooseのhydrateをスキップ
  .limit(100);

// === eコマースサイト一覧API完全版 ===
app.get('/api/products', async (req, res) => {
  const {
    category,
    minPrice,
    maxPrice,
    search,
    sort = 'createdAt',
    order = 'desc',
    page = 1,
    limit = 20
  } = req.query;

  // 1. 検索条件を構築
  const query = { isActive: true };
  if (category) query.category = category;
  if (minPrice || maxPrice) {
    query.price = {};
    if (minPrice) query.price.$gte = NumberDecimal(minPrice);
    if (maxPrice) query.price.$lte = NumberDecimal(maxPrice);
  }
  if (search) query.title = new RegExp(search, 'i');

  // 2. ソート
  const sortObj = { [sort]: order === 'desc' ? -1 : 1 };

  // 3. ページネーション
  const skip = (page - 1) * limit;

  // 4. 検索（プロジェクション + lean）
  const products = await Product.find(query)
    .select('sku title price thumbnail rating reviewCount')  // 6フィールドのみ返す
    .sort(sortObj)
    .skip(skip)
    .limit(Number(limit))
    .lean();   // 重要：mongooseのhydrateをスキップ

  // 5. 総件数
  const total = await Product.countDocuments(query);

  res.json({
    products,
    pagination: {
      page: Number(page),
      limit: Number(limit),
      total,
      pages: Math.ceil(total / limit)
    }
  });
});

// === デフォルト出力（コンパクト）===
db.products.findOne({ sku: "PHONE-001" });
// { _id: ObjectId('...'), sku: 'PHONE-001', title: 'Phone', ... }

// === pretty()フォーマット ===
db.products.findOne({ sku: "PHONE-001" }).pretty();
// {
//   _id: ObjectId('507f1f77bcf86cd799439011'),
//   sku: 'PHONE-001',
//   title: 'Smartphone X',
//   price: NumberDecimal('599.99'),
//   ...
// }

// === findもpretty対応 ===
db.products.find({ category: "Electronics" }).pretty();

# prettyは対話モードで有効、スクリプト出力に違いなし
mongosh "mongodb://localhost:27017" --eval "db.products.find().pretty()"

// === printjson()の使用 ===
db.products.find().forEach(printjson);
// 完全なJSON構造を出力

// === tojson()の使用 ===
const doc = db.products.findOne();
print(tojson(doc));

// === フォーマット出力（pretty 2）===
printjson(doc, null, 2);

// === 10件返却 ===
db.products.find().limit(10);

// === 条件との組み合わせ ===
db.products.find({ category: "Electronics" }).limit(5);

// === limit(0)はlimit(1)と同等 ===
db.products.find().limit(0);  // 1件返却

// === limit(-1)は全件返却（特殊）===
db.products.find().limit(-1);  // 全件返却（逆順ソートとして使用）

// === 最初の10件をスキップ、11-20件を返却 ===
db.products.find().skip(10).limit(10);

// === ページ番号の公式 ===
// Nページ目（1ページ20件）：skip = (N - 1) * 20
db.products.find().skip((page - 1) * 20).limit(20);

// === skip + sortの一貫性 ===
db.products.find().sort({ _id: 1 }).skip(10).limit(10);

// === 昇順（1）===
db.products.find().sort({ price: 1 });     // 価格（昇順）

// === 降順（-1）===
db.products.find().sort({ createdAt: -1 }); // 最新順

// === 複数フィールドでソート ===
db.products.find().sort({ category: 1, price: -1 });
// まずcategoryで昇順、次にpriceで降順

// === ネストフィールドのソート ===
db.products.find().sort({ "specs.rating": -1 });

// === 配列フィールドのソート ===
db.products.find().sort({ "tags.0": 1 });  // tagsの最初の要素でソート

// === 完全なページネーション検索 ===
db.products
  .find({ category: "Electronics", isActive: true })
  .sort({ price: 1, createdAt: -1 })  // 価格昇順、作成日逆順
  .skip(20)                            // 20件スキップ
  .limit(10);                          // 10件返却

// === Mongoose相当の記述 ===
const products = await Product
  .find({ category: "Electronics", isActive: true })
  .sort({ price: 1, createdAt: -1 })
  .skip(20)
  .limit(10)
  .lean();

// === 従来のページネーション（遅いページ送り）===
const page1 = await Product.find().skip(0).limit(20);
const page1000 = await Product.find().skip(20000).limit(20);  // 遅い！

// === カーソルベースページネーション（推奨）===
const lastId = null;  // 初回
const products1 = await Product.find({ _id: { $gt: lastId } }).limit(20);

const nextLastId = products1[products1.length - 1]._id;
const products2 = await Product.find({ _id: { $gt: nextLastId } }).limit(20);
// パフォーマンス安定、ページ深度の影響なし

// === 総合実習：商品一覧APIのページネーション ===
app.get('/api/products', async (req, res) => {
  const page = parseInt(req.query.page) || 1;
  const limit = Math.min(parseInt(req.query.limit) || 20, 100);
  const sortBy = req.query.sort || 'createdAt';
  const order = req.query.order === 'asc' ? 1 : -1;

  const products = await Product.find({ isActive: true })
    .select('sku title price thumbnail rating')
    .sort({ [sortBy]: order })
    .skip((page - 1) * limit)
    .limit(limit)
    .lean();

  const total = await Product.countDocuments({ isActive: true });

  res.json({
    data: products,
    pagination: {
      page,
      limit,
      total,
      pages: Math.ceil(total / limit),
      hasNext: page * limit < total,
      hasPrev: page > 1
    }
  });
});

// === countDocuments：正確なカウント ===
// 全ドキュメントをカウント
db.products.countDocuments();

// 条件を満たす件数を統計
db.products.countDocuments({ category: "Electronics" });

// === オプション付き ===
db.products.countDocuments(
  { category: "Electronics" },
  { limit: 1000 }   // 最大1000件スキャン
);

// === Mongoose相当 ===
const count = await Product.countDocuments({ category: "Electronics" });
// 250

// === 総数の推定（メタデータベース、超高速）===
db.products.estimatedDocumentCount();
// 1250（概算値）

// === 適用シーン ===
// - 一覧ページで「全1000件」と表示（正確さ不要）
// - リアルタイム不要の統計

// === パフォーマンス比較 ===
// countDocuments({}): ~100ms（全表スキャン）
// estimatedDocumentCount(): ~1ms（メタデータ読み取り）

// === 商品カテゴリ別統計（正確）===
const stats = await Product.aggregate([
  { $group: { _id: "$category", count: { $sum: 1 } } },
  { $sort: { count: -1 } }
]);
// [
//   { _id: 'Electronics', count: 250 },
//   { _id: 'Books', count: 200 },
//   { _id: 'Clothing', count: 180 }
// ]

// === 一覧ページの総件数（推定）===
const totalProducts = await Product.estimatedDocumentCount();
const electronicsCount = await Product.countDocuments({ category: "Electronics" });

res.json({
  total: totalProducts,        // 推定 1250
  electronics: electronicsCount // 正確 250
});

// === mongoshでイテレート ===
db.products.find({ category: "Electronics" }).forEach(doc => {
  print(`SKU: ${doc.sku}, Title: ${doc.title}`);
});

// === Node.jsでイテレート ===
const cursor = collection.find({ category: "Electronics" });

// 方法1：toArray()
const products = await cursor.toArray();

// 方法2：for await...of
for await (const doc of collection.find({ category: "Electronics" })) {
  console.log(doc.title);
}

// 方法3：手動next()
const cursor2 = collection.find({ category: "Electronics" });
while (await cursor2.hasNext()) {
  const doc = await cursor2.next();
  console.log(doc);
}

// === バッチサイズの設定 ===
const cursor = collection.find({ category: "Electronics" })
  .batchSize(100);  // 1バッチ100件

// === 最大返却数の制限 ===
const cursor = collection.find({ category: "Electronics" })
  .limit(1000);

// === カーソルタイムアウトの制限 ===
const cursor = collection.find({ category: "Electronics" })
  .maxTimeMS(5000);  // 5秒タイムアウト

// === 完全なMongooseクエリチェーン ===
const products = await Product.find({ category: "Electronics" })
  .where('price').gt(100).lt(1000)        // 価格 100-1000
  .where('stock').gt(0)                   // 在庫あり
  .select('sku title price')              // プロジェクション
  .sort({ price: 1 })                     // ソート
  .skip(20)                               // ページネーション
  .limit(10)                              // 制限
  .populate('categoryId', 'name slug')    // 結合検索
  .lean();                                // パフォーマンス最適化

// === 同等の簡潔な記述 ===
const products2 = await Product.find({
  category: "Electronics",
  price: { $gt: 100, $lt: 1000 },
  stock: { $gt: 0 }
})
  .select('sku title price')
  .sort({ price: 1 })
  .skip(20)
  .limit(10)
  .lean();

// === シーン：eコマース商品検索API ===
app.get('/api/products/search', async (req, res) => {
  const { q, category, minPrice, maxPrice, sortBy = 'relevance' } = req.query;

  // 1. クエリを構築
  const query = { isActive: true };
  if (q) query.$text = { $search: q };
  if (category) query.category = category;
  if (minPrice || maxPrice) {
    query.price = {};
    if (minPrice) query.price.$gte = NumberDecimal(minPrice);
    if (maxPrice) query.price.$lte = NumberDecimal(maxPrice);
  }

  // 2. ソート
  const sortObj = sortBy === 'price_asc' ? { price: 1 } :
                  sortBy === 'price_desc' ? { price: -1 } :
                  sortBy === 'newest' ? { createdAt: -1 } :
                  { score: { $meta: 'textScore' } };  // 全文検索関連度順

  // 3. 検索
  const products = await Product.find(query, sortObj.score ? { score: { $meta: 'textScore' } } : {})
    .sort(sortObj)
    .limit(40)
    .lean();

  // 4. 統計
  const total = await Product.countDocuments(query);

  res.json({
    query: { q, category, minPrice, maxPrice },
    total,
    products
  });
});