个人博客

选择数据库

// 语法
use <database_name>

// 示例
use blog

#查询所有数据库
show dbs

#删除当前所在数据库
db.dropDatabase()

查询所有集合

// 语法
db.createCollection(<collection_name>, { options })
// 示例
db.createCollection("articles")

// 创建固定大小的集合，当集合达到指定的大小时，它会覆盖最早的文档。
// 固定大小的集合的文档一旦插入就不允许修改
 
// 示例，创建固定大小的集合，capped=true表示集合有大小上限，size是字节单位
db.createCollection("products", {capped: true, size: 1048576 })
 
// 示例，创建固定大小的集合，capped=true表示集合有大小上限，size是字节单位，max是最大文档数
db.createCollection("products", {capped: true, size: 1048576, max: 1000})

删除集合

// 语法
db.<collection_name>.drop()
// 示例
db.articles.drop()

文档命令

_id 字段是每个文档的唯一标识符，确保每个文档在集合中是唯一的。这个字段在每个文档中都是必须的，并且在插入文档时会自动生成。如果没有显式指定 _id，MongoDB 会为其生成一个唯一的 ObjectId。

假如我们在插入数据时没有指定_id值

db.users.insertOne({ "name": "Alice", "age": 25 })

// MongoDB 会自动生成一个 ObjectId 作为 _id，如下：
{
  "_id": ObjectId("60a7c0c8b59b3c001c8e4f2d"),
  "name": "Alice",
  "age": 25
}

//使用 _id 进行查询
db.users.find({ "_id": ObjectId("60a7c0c8b59b3c001c8e4f2d") })
//指定_id值
db.users.insertOne({ "_id": 1, "name": "Bob", "age": 30 })
{
  "_id": 1,
  "name": "Bob",
  "age": 30
}
// 使用_id查询
db.users.find({ "_id": 1 })

插入

// 插入单个文档（插入一条数据） insertOne
// 语法
db.<collection_name>.insertOne({})

// 示例
db.users.insertOne({
  name: "Tom",
  age: 30,
  email: "tom@example.com"
})

// 插入多个文档（插入多条数据） insertMany
// 语法
db.<collection_name>.insertMany([
  {}, {}
])
// 示例
db.orders.insertMany([
  { item: "book", qty: 10, price: 15 },
  { item: "pen", qty: 20, price: 1.5 }
])

修改

//1. 更新 name 为 "Alice" 的文档的 age 字段

db.users.updateOne(
  { name: "Alice" },
  { $set: { age: 26 } }
)

//2. 如果没有找到文档，则插入一个新文档  upsert: true

db.users.updateOne(
  { name: "Charlie" },
  { $set: { age: 35 }, $setOnInsert: { createdAt: new Date() } },
  { upsert: true }
)

//更新多个文档（修改多条数据） updateMany

// 1. 将所有 age 小于 30 的用户的 status 更新为 "young"
db.users.updateMany(
  { age: { $lt: 30 } },
  { $set: { status: "young" } }
)

//2. 如果没有找到文档，则插入一个新文档  upsert: true 
db.users.updateMany(
  { status: "inactive" },
  { $set: { status: "active" } },
  { upsert: true }
)

//替换文档中的所有字段值  replaceOne

//1. 用新文档替换 name 为 "Alice" 的文档
db.users.replaceOne(
  { name: "Alice" },
  { name: "Alice", age: 27, status: "active" }
)

//2. 如果没有找到文档，则插入一个新文档  upsert: true
db.users.replaceOne(
  { name: "David" },
  { name: "David", age: 40, status: "new" },
  { upsert: true }
)

// 重命名字段  $rename
db.users.updateOne(
  { name: "Alice" },
  { $rename: { "address.city": "address.town" } }
)

//向文档中添加时间字段，时间为当前时间  $currentDate
db.users.updateOne(
  { name: "Alice" },
  { $currentDate: { create_time: true } }
)

//向文档中的数组插入数据 $addToSet
db.users.updateOne(
  { name: "Tom" },
  { $addToSet: { address: "Shenzhen" } }
)

//从文档数组中移除数据  $pull
db.users.updateOne(
  { name: "Tom" },
  { $pull: { address: "Shenzhen" } }
)

删除

//删除一个文档（删除一条数据） deleteOne
db.users.deleteOne({ name: "Tom" })

//删除多个文档（删除多条数据） deleteMany
// 删除所有 age 小于 30 的文档
db.users.deleteMany({ age: { $lt: 30 } })

//删除集合，包括集合中的所有文档（删除表）
// 语法
db.<collection_name>.drop()
// 示例
db.users.drop()

//删除集合中的所有文档，保留集合
db.users.deleteMany({})

批量操作 bulkWrite

bulkWrite() 方法允许执行多种插入、更新和删除操作的批量操作。它适用于需要一次性处理多个写操作的场景。

//执行多种操作（插入、更新、删除）
db.users.bulkWrite([
  { insertOne: { document: { name: "Grace", age: 29, email: "grace@example.com" } } },
  { updateOne: { filter: { name: "Bob" }, update: { $set: { age: 31 } } } },
  { deleteOne: { filter: { name: "Charlie" } } }
])

//设置 ordered 选项为 false，使得即使遇到错误也会继续执行其他操作
db.users.bulkWrite([
  { insertOne: { document: { name: "Hank", age: 45, email: "hank@example.com" } } },
  { updateOne: { filter: { name: "David" }, update: { $set: { status: "active" } } } }
], { ordered: false })

查询操作符

符号	-	查询操作符
$eq		等于
$ne		不等于
$gt		大于
$lt		小于
$gte		大于等于
$lte		小于等于

逻辑操作符

符号	-	查询操作符
$and		与
$or		或
$not		非
$nor		非或

//查询单个文档（查询单个数据） findOne
// 语法
db.<collection_name>.findOne({ 列名: "值" });
// 示例，对比mysql：select * from users where name = 'Tom'
db.users.findOne({ name: "Tom" });

//查询多个文档（查询多个数据） find
// 示例，对比mysql：select * from users where age > 25
db.users.find({ age: { $gt: 25 } });
// 将返回结果游标转成数组
db.users.find({ age: { $gt: 25 } }).toArray();

//范围查询
// 查找年龄在 18 到 30 岁之间的用户
db.users.find({ age: { $gte: 18, $lte: 30 } });

//范围查询
// 查找年龄在 18 到 30 岁之间的用户
db.users.find({ age: { $gte: 18, $lte: 30 } });

//and 查询
// 查找年龄大于 25 岁且性别为 "男" 的用户
db.users.find({ $and: [{ age: { $gt: 25 } }, { gender: "男" }] });

//or 查询
// 查找年龄小于 18 岁或大于 60 岁的用户
db.users.find({ $or: [{ age: { $lt: 18 } }, { age: { $gt: 60 } }] });

//not 查询
// 查询 age 不等于 25 的文档
db.users.find({
    age: { $not: { $eq: 25 } }
});
 
 
// 等价于
db.users.find({
    age: { $ne: 25 }
});

//nor 查询
//nor可以理解为多个not条件的组合
// 查询年龄不是 25 且地址不是Shenzhen的文档
db.users.find({
    $nor: [
        { age: 25 },
        { address: "Shenzhen" }
    ]
});
 
 
// 查询年龄不是 25 或 30 的用户, 且地址不是Shenzhen的文档
db.users.find({
    $nor: [
        { age: 25 },
        { age: 30},
        { address: "Shenzhen" }
    ]
});

//in 查询
// 查询年龄是 25 和 35 的文档
db.users.find({ age: { $in: [25, 35] } });

//nin 查询
// 查询年龄不是是 25 和 35 的文档
db.users.find({ age: { $nin: [25, 35] } });

//正则查询 regex
// 查询 name 中包含 Tom 的文档
db.users.find({
    name: { $regex: "Tom" }
});
 
 
// i 忽略大小写
db.users.find({
    name: { $regex: "tom", $options: "i" }
});
 // 匹配电子邮件以 "dave" 开头的用户
db.users.find({
    email: { $regex: "^dave" }
});
 
// 匹配电子邮件以 "domain.com" 结尾的用户
db.users.find({
    email: { $regex: "domain\\.com$" }
});
 
// 多行模式，匹配电子邮件包含 "example" 或 "domain" 的用户
db.users.find({
    email: { $regex: "example|domain" }
});

//内嵌文档查询
// 数据结构
[
  {
    "_id": 1,
    "name": "Alice",
    "age": 30,
    "address": {
      "street": "123 Elm St",
      "city": "New York",
      "state": "NY",
      "zip": "10001"
    }
  },
  {
    "_id": 2,
    "name": "Bob",
    "age": 25,
    "address": {
      "street": "456 Oak St",
      "city": "Los Angeles",
      "state": "CA",
      "zip": "90001"
    }
  }
]
// 查询语句，查找有地址的用户，并且地址的城市是 "New York"
db.users.find({ "address.city": "New York" });

第一部分结束

MongoDB 操作手册一

评论 (0)