MongoDB: 查询运算符：30+运算符完全指南

// ❌ 反例：先查询所有再过滤
const allProducts = await Product.find();
const filtered = allProducts.filter(p =>
  p.price >= 100 && p.price <= 500 &&
  p.stock > 0 &&
  (p.tags.includes('bestseller') || p.tags.includes('new')) &&
  p.rating >= 4
);
// 100 万数据，只返回 100 条，但查询了全部

// ✅ 正例：一次查询，用运算符组合
const products = await Product.find({
  price: { $gte: 100, $lte: 500 },
  stock: { $gt: 0 },
  tags: { $in: ['bestseller', 'new'] },
  rating: { $gte: 4 }
});
// 数据库层过滤，100 万 → 100 条，性能 ↑1000x

// === 价格区间 ===
db.products.find({
  price: { $gte: 100, $lte: 500 }   // 100 <= price <= 500
});

// === 多值匹配 ===
db.products.find({
  category: { $in: ['Electronics', 'Books'] }
});

// === 排除特定值 ===
db.users.find({
  role: { $nin: ['banned', 'deleted'] }
});

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

// === 隐式 $and ===
db.products.find({
  category: 'Electronics',
  stock: { $gt: 0 }
  // 等同于 { $and: [{ category: 'Electronics' }, { stock: { $gt: 0 } }] }
});

// === 显式 $and（同一字段多个条件）===
db.products.find({
  $and: [
    { price: { $gte: 100 } },
    { price: { $lte: 500 } }
    // 必须用 $and，因为同一字段不能直接写多个条件
  ]
});

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

// === $nor（都不匹配）===
db.products.find({
  $nor: [
    { category: 'Books' },
    { stock: 0 }
  ]
});
// 返回既不是 Books 分类、又有库存的商品

// === 嵌套逻辑 ===
db.products.find({
  $and: [
    { category: 'Electronics' },
    {
      $or: [
        { tags: 'bestseller' },
        { rating: { $gte: 4.5 } }
      ]
    }
  ]
});

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

// === 字段存在 ===
db.products.find({ discount: { $exists: true } });
// 有 discount 字段的商品

// === 字段不存在 ===
db.users.find({ lastLoginAt: { $exists: false } });
// 从未登录的用户

// === 配合其他条件 ===
db.products.find({
  discount: { $exists: true, $ne: null }
});
// 有 discount 且不为 null

// === 类型码对照 ===
// 1: Double, 2: String, 3: Object, 4: Array
// 5: Binary, 7: ObjectId, 8: Boolean, 9: Date
// 10: Null, 16: Int32, 18: Long, 19: Decimal128

// === 字符串类型 ===
db.products.find({ sku: { $type: "string" } });

// === 数值类型（多种）===
db.products.find({ price: { $type: ["number", "decimal"] } });
// Double 或 Decimal128

// === 实际应用：找出类型错误的字段 ===
db.products.find({ price: { $type: "string" } });
// 找出 price 字段被错误存为字符串的文档（数据迁移常见问题）

// === 查找缺失字段的脏数据 ===
db.users.find({
  $or: [
    { email: { $exists: false } },
    { username: { $exists: false } }
  ]
});

// === 类型修复 ===
db.products.find({ price: { $type: "string" } }).forEach(doc => {
  db.products.updateOne(
    { _id: doc._id },
    { $set: { price: NumberDecimal(doc.price) } }
  );
});

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

// === 必须包含所有指定元素（顺序无关）===
db.products.find({ tags: { $all: ['5g', 'amoled'] } });
// 同时包含 5g 和 amoled 的商品

// === 等同于 $and ===
db.products.find({
  $and: [
    { tags: '5g' },
    { tags: 'amoled' }
  ]
});

// === 数组长度精确匹配 ===
db.products.find({ tags: { $size: 3 } });
// 标签数量恰好为 3

// === 不支持范围，需用 $expr ===
db.products.find({
  $expr: { $gt: [{ $size: "$tags" }, 3] }
});
// 标签数量 > 3

// === 场景：查询评论中评分 >= 4 且含关键词 "good" 的评论 ===
db.products.find({
  reviews: {
    $elemMatch: {
      rating: { $gte: 4 },
      content: /good/i
    }
  }
});
// ✅ 正确：单条评论同时满足两个条件

// === 反例：不使用 $elemMatch ===
db.products.find({
  "reviews.rating": { $gte: 4 },
  "reviews.content": /good/i
});
// ⚠️ 错误：可能匹配到不同评论（一条评论高评分，另一条含关键词）

// === 场景：学生选课系统 ===
db.students.insertMany([
  {
    name: "Alice",
    courses: [
      { name: "Math", score: 85 },
      { name: "Physics", score: 92 },
      { name: "Chemistry", score: 78 }
    ]
  },
  // ...
]);

// 查询：选了 Math 且分数 >= 90 的学生
db.students.find({
  courses: {
    $elemMatch: { name: "Math", score: { $gte: 90 } }
  }
});

// 查询：选了 3 门以上课程的学生
db.students.find({
  $expr: { $gte: [{ $size: "$courses" }, 3] }
});

// 查询：所有课程分数都 >= 80 的学生
db.students.find({
  courses: {
    $not: {
      $elemMatch: { score: { $lt: 80 } }
    }
  }
});

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

// === 简单正则 ===
db.products.find({ title: /^iPhone/ });
// 标题以 "iPhone" 开头

// === 不区分大小写 ===
db.products.find({ title: { $regex: 'phone', $options: 'i' } });

// === 多模式匹配 ===
db.products.find({
  title: { $regex: 'phone|mobile', $options: 'i' }
});

// === 性能优化：正则锚定（避免 ^.* 通配）===
// ✅ 快：db.products.find({ title: /^iPhone/ })
// ⚠️ 慢：db.products.find({ title: /iPhone/ })

// === 字段间比较 ===
db.products.find({
  $expr: { $gt: ["$discount", "$price"] }
});
// discount > price（异常数据）

// === 数组长度比较 ===
db.products.find({
  $expr: { $gte: [{ $size: "$tags" }, 5] }
});

// === 字符串操作 ===
db.products.find({
  $expr: { $eq: [{ $substr: ["$title", 0, 5] }, "Hello"] }
});

// === 字段值对 N 取模 ===
db.products.find({ price: { $mod: [100, 0] } });
// 价格能被 100 整除

// === 价格对 100 取模 = 50 ===
db.products.find({ price: { $mod: [100, 50] } });

// === 场景：电商高级搜索 ===
// 价格 100-1000、Electronics 或 Computers、库存 > 0、
// 标签包含 'bestseller' 或 'new'、评分 >= 4、有 discount
db.products.find({
  $and: [
    { price: { $gte: 100, $lte: 1000 } },
    {
      $or: [
        { category: 'Electronics' },
        { category: 'Computers' }
      ]
    },
    { stock: { $gt: 0 } },
    { tags: { $in: ['bestseller', 'new'] } },
    { rating: { $gte: 4 } },
    { discount: { $exists: true, $ne: null } }
  ]
});

// === 性能测试：100 万文档 ===

// ❌ 慢：未索引字段 + $exists
db.users.find({ lastLoginAt: { $exists: true } });
// ~500ms（全表扫描）

// ✅ 快：索引字段 + 范围查询
db.users.find({ age: { $gte: 18, $lt: 30 } });
// ~5ms（索引扫描）

// ❌ 慢：正则未锚定
db.products.find({ title: /phone/i });
// ~300ms（全表扫描 + 正则匹配）

// ✅ 快：正则锚定
db.products.find({ title: /^iPhone/ });
// ~10ms（前缀索引）

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