// 基本插入
db.users.insertOne({
  username: "alice",
  email: "alice@example.com",
  age: 25
})

// 插入后获取返回结果
db.users.insertOne({
  username: "bob",
  email: "bob@example.com"
}).then(result => {
  print("插入的文档 ID:", result.insertedId)
})

// 显式指定 _id
db.users.insertOne({
  _id: "user_001",
  username: "charlie",
  email: "charlie@example.com"
})

// 批量插入多个文档
db.users.insertMany([
  { username: "dave", email: "dave@example.com", age: 30 },
  { username: "eve", email: "eve@example.com", age: 28 },
  { username: "frank", email: "frank@example.com", age: 35 }
])

// 批量插入并设置有序/无序
db.users.insertMany(
  [
    { username: "user1", email: "user1@example.com" },
    { username: "user2", email: "user2@example.com" }
  ],
  { ordered: false }  // 无序插入，一个失败继续插入其他
)

// 有序插入（默认），遇到错误停止
db.users.insertMany(
  [
    { username: "user1" },
    { _id: "duplicate_id", username: "user2" }  // 会导致插入失败
  ],
  { ordered: true }
)

// 不推荐使用 insert，已废弃
db.users.insert({ username: "test" })

// 不推荐使用 save，已废弃
// 建议使用 insertOne 或 replaceOne
db.users.save({ _id: ObjectId("..."), username: "updated" })

// 查询所有文档
db.users.find()

// 格式化输出
db.users.find().pretty()

// 限制返回字段（投影）
db.users.find(
  {},  // 查询条件
  { username: 1, email: 1, _id: 0 }  // 只返回 username 和 email
)

// 排除字段
db.users.find(
  {},
  { password: 0, __v: 0 }  // 排除 password 和 __v
)

// 嵌套字段投影
db.users.find(
  {},
  { "profile.firstName": 1, "profile.lastName": 1 }
)

// 查询单个文档
db.users.findOne({ username: "alice" })

// 查询并排序
db.users.findOne(
  { status: "active" },
  {},
  { sort: { created_at: -1 } }
)

// 查询第一个文档
db.users.findOne()

// 比较操作符示例
db.users.find({ age: { $gte: 18, $lte: 65 } })

db.users.find({ 
  status: { $in: ["active", "pending"] }
})

db.users.find({ 
  username: { $nin: ["admin", "root"] }
})

// 使用 $eq 的完整形式
db.users.find({ username: { $eq: "alice" } })

// AND 操作
db.users.find({
  $and: [
    { age: { $gte: 18 } },
    { status: "active" }
  ]
})

// OR 操作
db.users.find({
  $or: [
    { username: "alice" },
    { email: "alice@example.com" }
  ]
})

// 组合条件
db.users.find({
  $and: [
    { $or: [{ age: { $lte: 18 } }, { age: { $gte: 65 } }] },
    { status: "active" }
  ]
})

// NOR 示例
db.users.find({
  $nor: [
    { status: "banned" },
    { role: "admin" }
  ]
})

// 字段存在
db.users.find({ phone: { $exists: true } })
db.users.find({ profile: { $exists: false } })

// 字段类型
db.users.find({ age: { $type: "number" } })
db.users.find({ _id: { $type: "objectId" } })

// 正则表达式（区分大小写）
db.users.find({ username: { $regex: "^admin", $options: "i" } })

// 使用正则的简洁语法
db.users.find({ email: /@gmail\.com$/ })

// 查询包含特定标签的文章
db.articles.find({ tags: { $all: ["mongodb", "database"] } })

// 查询数组中至少有一个元素满足条件
db.scores.find({
  results: { 
    $elemMatch: { 
      subject: "Math",
      score: { $gte: 90 }
    } 
  }
})

// 查询标签数量为 3 的文档
db.articles.find({ tags: { $size: 3 } })

// 查询空数组
db.articles.find({ tags: { $size: 0 } })

// 精确匹配内嵌文档（字段顺序必须一致）
db.users.find({ profile: { firstName: "Alice", lastName: "Smith" } })

// 查询嵌套字段（使用点号）
db.users.find({ "profile.address.city": "Beijing" })
db.users.find({ "profile.phone.mobile": { $exists: true } })

// 嵌套数组查询
db.orders.find({
  "items.product_id": ObjectId("...")
})

// 基本更新
db.users.updateOne(
  { username: "alice" },
  { $set: { email: "new_email@example.com" } }
)

// 使用 updateOne 返回结果
db.users.updateOne(
  { username: "alice" },
  { $set: { status: "inactive" } }
).then(result => {
  print("匹配文档数:", result.matchedCount)
  print("修改文档数:", result.modifiedCount)
})

// 批量更新
db.users.updateMany(
  { status: "pending" },
  { $set: { status: "active", updated_at: new Date() } }
)

// 更新多个字段
db.products.updateMany(
  { category: "Electronics" },
  { 
    $set: { 
      tax_rate: 0.13,
      currency: "USD"
    }
  }
)

// $set - 设置字段
db.users.updateOne(
  { _id: ObjectId("...") },
  { $set: { "profile.avatar": "https://..." } }
)

// $unset - 删除字段
db.users.updateOne(
  { _id: ObjectId("...") },
  { $unset: { temp_field: 1 } }
)

// $rename - 重命名字段
db.users.updateMany(
  {},
  { $rename: { "first_name": "firstName", "last_name": "lastName" } }
)

// $inc - 递增
db.counters.updateOne(
  { _id: "order_id" },
  { $inc: { seq: 1 } }
)

// $mul - 乘法
db.products.updateMany(
  {},
  { $mul: { price: 1.1 } }  // 所有价格涨 10%
)

// $push - 添加元素
db.users.updateOne(
  { _id: ObjectId("...") },
  { $push: { tags: "developer" } }
)

// $push + $each - 批量添加
db.users.updateOne(
  { _id: ObjectId("...") },
  { $push: { tags: { $each: ["python", "golang"] } } }
)

// $addToSet - 添加唯一元素（不会重复）
db.users.updateOne(
  { _id: ObjectId("...") },
  { $addToSet: { skills: "mongodb" } }
)

// $pop - 删除最后一个元素 (1) 或第一个元素 (-1)
db.lists.updateOne(
  { _id: ObjectId("...") },
  { $pop: { items: 1 } }
)

// $pull - 移除匹配的元素
db.users.updateOne(
  { _id: ObjectId("...") },
  { $pull: { tags: "old_tag" } }
)

// $pull + $in - 批量移除
db.users.updateOne(
  { _id: ObjectId("...") },
  { $pull: { tags: { $in: ["temp", "unused"] } } }
)

// 替换整个文档（保留 _id）
db.users.replaceOne(
  { _id: ObjectId("...") },
  {
    username: "alice",
    email: "alice@example.com",
    status: "active",
    updated_at: new Date()
  }
)

// 删除单个文档
db.users.deleteOne({ username: "alice" })

// 删除结果
db.users.deleteOne({ _id: ObjectId("...") }).then(result => {
  print("删除文档数:", result.deletedCount)
})

// 批量删除
db.users.deleteMany({ status: "inactive", last_login: { $lt: ISODate("2023-01-01") } })

// 删除所有文档（谨慎使用）
db.temp_data.deleteMany({})

// 删除整个集合（包括索引）
db.users.drop()

// 检查是否删除成功
db.getCollectionNames()  // users 应该不在列表中

// 删除当前数据库
db.dropDatabase()

// 删除指定数据库
use mydb
db.dropDatabase()

// 限制返回数量
db.users.find().limit(10)

// 跳过前 N 条（分页）
db.users.find().skip(20).limit(10)

// 分页查询（每页 10 条）
const page = 2
const pageSize = 10
db.users.find().skip((page - 1) * pageSize).limit(pageSize)

// 单字段排序（1 升序，-1 降序）
db.users.find().sort({ created_at: -1 })

// 多字段排序
db.articles.find().sort({
  category: 1,
  view_count: -1,
  created_at: -1
})

// 结合其他操作
db.users.find(
  { status: "active" },
  {},
  { sort: { created_at: -1 }, limit: 10 }
)

// 统计满足条件的文档数
db.users.countDocuments({ status: "active" })

// 统计集合总文档数
db.users.countDocuments({})

// 使用 estimatedDocumentCount（更快，但不接受查询条件）
db.users.estimatedDocumentCount()

// 获取字段的所有不重复值
db.users.distinct("country")

// 带查询条件的去重
db.orders.distinct("status", { created_at: { $gte: ISODate("2024-01-01") } })

// 数组字段去重
db.articles.distinct("tags")

// 遍历游标
const cursor = db.users.find({ status: "active" })
while (cursor.hasNext()) {
  printjson(cursor.next())
}

// 使用 forEach
db.users.find().forEach(user => {
  print(`User: ${user.username}`)
})

// 使用 toArray
const users = db.users.find().toArray()

// 限制和转换
const usernames = db.users.find({}, { username: 1, _id: 0 }).toArray()