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-5x

  res.json(products);
});
// 每个商品 200 字节，20 个 = 4KB（性能 ↑100x）

// === find 基本语法 ===
db.products.find();
// 返回所有文档（cursor）

// === find 指定条件 ===
db.products.find({ category: "Electronics" });
// 返回所有电子产品

// === find 返回数组 ===
db.products.find({ category: "Electronics" }).toArray();
// 返回 Array<Document>

// === find 遍历（Cursor）===
db.products.find({ category: "Electronics" }).forEach(printjson);

// === findOne 返回单个文档 ===
db.products.findOne({ sku: "PHONE-001" });
// 返回第一个匹配的文档（或 null）

// === findOne 与 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() 返回 Cursor
  const cursor = collection.find({ category: "Electronics" });
  const products = await cursor.toArray();
  console.log(`Found ${products.length} products`);

  // 2. findOne() 返回 Document
  const product = await collection.findOne({ sku: "PHONE-001" });
  console.log(product);

  // 3. 遍历 Cursor（流式）
  for await (const doc of collection.find({ category: "Electronics" })) {
    console.log(doc.title);
  }

  await client.close();
}

findProducts();

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

// === 精确匹配 ===
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();

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

// === 字段白名单（只返回指定字段）===
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（性能 ↑10x）

// === 方法 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);

// === 完整电商列表 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)
    }
  });
});

// API 端点响应（状态码 200）
// 返回 JSON 数据

// === 默认输出（紧凑）===
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);  // 返回所有（用作反向 sort）

// === 跳过前 10 条，返回第 11-20 条 ===
db.products.find().skip(10).limit(10);

// === 分页公式 ===
// 第 N 页（每页 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
    }
  });
});

// API 端点响应（状态码 200）
// 返回 JSON 数据

// === 统计所有文档 ===
db.products.countDocuments();
// 1250

// === 统计符合条件 ===
db.products.countDocuments({ category: "Electronics" });
// 250

// === 带选项 ===
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);  // 每批 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();

// === 场景：电商商品搜索 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
  });
});

// API 端点响应（状态码 200）
// 返回 JSON 数据