Bootstrap

Mongodb命令大全

Mongodb命令大全

一、数据库相关命令

  • 选择数据库
// 语法
use <database_name>

// 示例
use  mydatabase
  • 显示当前数据库
db
  • 查询数据库列表
show dbs
  • 删除当前所在数据库
db.dropDatabase()
  • 创建数据库
在插入数据时自动创建，见文档下面的插入数据

二、集合相关命令

  • 显示集合列表
show collections
  • 创建集合
// 语法
db.createCollection(<collection_name>, { options })

// 示例
db.createCollection("products")


// 创建固定大小的集合，当集合达到指定的大小时，它会覆盖最早的文档。固定大小的集合的文档一旦插入就不允许修改
 
// 示例，创建固定大小的集合，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.products.drop()

三、文档(数据)相关命令

1、_id 字段说明

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

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

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

MongoDB 会自动生成一个 ObjectId 作为 _id，如下：

{
  "_id": ObjectId("60a7c0c8b59b3c001c8e4f2d"),
  "name": "Alice",
  "age": 25
}

2、查询

  • 使用 _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 })

2.1、 查询操作符

查询操作符

符号说明
$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 } });
  • 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" }
});

2.2、内嵌文档查询

// 数据结构
[
  {
    "_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" });

2.3、数组文档查询

$elemMatch：匹配数组中满足条件的元素

// 数据结构
[
  {
    "_id": 1,
    "name": "Alice",
    "age": 30,
    "friends": [
      { "name": "Bob", "age": 25 },
      { "name": "Charlie", "age": 32 }
    ]
  },
  {
    "_id": 2,
    "name": "David",
    "age": 28,
    "friends": [
      { "name": "Eve", "age": 22 },
      { "name": "Frank", "age": 29 }
    ]
  }
]


// 查询语句，查找friends中包含年龄大于 30 岁的用户
db.users.find({ "friends": { $elemMatch: { age: { $gt: 30 } } } })

2.4、去重查询

// 给 age 字段去重
db.users.distinct("age");
 
// age 大于 25 的用户的去重 name 字段
db.users.distinct("name", { age: { $gt: 25 } });

2.5、查询排序 sort

// 使用关键字sort，按照 age 升序排序
db.users.find().sort({ age: 1 });

// 按照 age 降序排序
db.users.find().sort({ age: -1 });

2.6、分页查询

// 使用 limit 关键字，返回前5条数据
db.users.find().limit(5);


// 分页查询，跳过前 5 个文档，并返回接下来的 5 个文档
db.users.find().skip(5).limit(5)

2.7、指定列投影查询返回

  • 查询只返回指定列 投影

// 返回 name age,不返回_id， 0表示不返回，1表示返回
db.users.find({}, { name: 1, age: 1, _id: 0 });
  • 查询不返回指定的列 投影
// 不返回 name, 其他字段都返回，0表示不返回，1表示返回
db.users.find({}, { name: 0 });

2.8、查询统计个数 count

// 查询集合中的所有文档数量
db.users.count();
 
// 查询年龄大于 30 的文档的个数
db.users.count({ age: { $gt: 10 } });
db.users.find({ age: { $gt: 10 } }).count()


// 这里要使用聚合aggregate，$match的意思和find一样
db.<collection_name>.aggregate([
  { $match: { name: "Tom" } },
  { $count: "total" }
])

3、聚合查询

聚合操作符

符号说明
$sum计算和
$avg计算平均值
$min计算最小值
$max计算最大值
$first取每组中的第一个文档
$last取每组中的最后一个文档
$push将每组中的某个值添加到数组中
$addToSet将每组中的唯一值添加到数组中（去重）
$count计算文档数量

算数操作符

符号说明
$add两个数、日期、时间相加
$subtract两个数、日期、时间相减
$multiply两个数相乘
$divide两个数相除
$mod两个数取余
$abs数字的绝对值
$ceil数字向上取整
$floor数字向下取整
$exp返回 e（自然对数的底数）取指定数字次方的值
$ln数字的自然对数
$log数字以指定底数为底的对数
$log10数字以10为底的对数
$pow指定数字的指定次方的值
$sqrt数字的平方根
$trunc数字截断为整数的值（删除小数部分）
  • $match
    $match 是 MongoDB 聚合管道中的一个重要阶段，用于筛选文档，仅输出符合指定条件的文档。它的作用类似于 find 操作，但它是聚合管道的一部分，通常用于数据预处理和过滤，以便后续阶段能够处理更少、更相关的数据。

语法：

db.<collection_name>.aggregate([
  { $match: { <query> } }
])
 
// <query>：标准的查询条件，类似于 find 方法中的查询条件。

3.1、查询用户表中name=tom的文档

db.users.aggregate([
  { $match: { name: "Tom" } }
])

3.2、查询订单表中 amount大于 300 的订单

db.orders.aggregate([
  { $match: { amount: { $gt: 300 } } }
])

3.3、查询订单中 status = 1 并且 amount 大于 300 的订单

db.orders.aggregate([
  { $match: { $and: [ { status: "A" }, { amount: { $gt: 300 } } ] } }
])

3.4、内嵌查询

db.orders.aggregate([
  { $match: { "address.city": "New York" } }
])

3.5、查找 amount 大于 200 的订单，并按 amount 降序排序

db.orders.aggregate([
  { $match: { amount: { $gt: 200 } } },
  { $sort: { amount: -1 } }
])

4、分组查询group

有sales集合数据如下:

[
  { "_id": 1, "item": "apple", "price": 10, "quantity": 2, "date": "2023-01-01" },
  { "_id": 2, "item": "banana", "price": 5, "quantity": 10, "date": "2023-01-01" },
  { "_id": 3, "item": "apple", "price": 10, "quantity": 5, "date": "2023-01-02" },
  { "_id": 4, "item": "banana", "price": 5, "quantity": 7, "date": "2023-01-02" },
  { "_id": 5, "item": "orange", "price": 8, "quantity": 8, "date": "2023-01-03" }
]

4.1、按 item 字段分组并计算总销售量

db.sales.aggregate([
  {
    $group: {
      _id: "$item",
      totalQuantity: { $sum: "$quantity" }
    }
  }
])

结果

[
  { "_id": "apple", "totalQuantity": 7 },
  { "_id": "banana", "totalQuantity": 17 },
  { "_id": "orange", "totalQuantity": 8 }
]

4.2、按 date 字段分组并计算总销售额

db.sales.aggregate([
  {
    $group: {
      _id: "$date",
      totalSales: { $sum: { $multiply: ["$price", "$quantity"] } }
    }
  }
])

结果：

[
  { "_id": "2023-01-01", "totalSales": 70 },
  { "_id": "2023-01-02", "totalSales": 85 },
  { "_id": "2023-01-03", "totalSales": 64 }
]

4.3、按 item 分组，并计算每种商品的平均价格和总销售量

db.sales.aggregate([
  {
    $group: {
      _id: "$item",
      avgPrice: { $avg: "$price" },
      totalQuantity: { $sum: "$quantity" }
    }
  }
])

结果：

[
  { "_id": "apple", "avgPrice": 10, "totalQuantity": 7 },
  { "_id": "banana", "avgPrice": 5, "totalQuantity": 17 },
  { "_id": "orange", "avgPrice": 8, "totalQuantity": 8 }
]

4.4、按 item 分组，并创建一个包含所有销售日期的数组

db.sales.aggregate([
  {
    $group: {
      _id: "$item",
      dates: { $push: "$date" }
    }
  }
])

结果：

[
  { "_id": "apple", "dates": ["2023-01-01", "2023-01-02"] },
  { "_id": "banana", "dates": ["2023-01-01", "2023-01-02"] },
  { "_id": "orange", "dates": ["2023-01-03"] }
]

4.5、按 item 分组，并创建一个包含唯一销售日期的数组

db.sales.aggregate([
  {
    $group: {
      _id: "$item",
      uniqueDates: { $addToSet: "$date" }
    }
  }
])

结果：

[
  { "_id": "apple", "uniqueDates": ["2023-01-01", "2023-01-02"] },
  { "_id": "banana", "uniqueDates": ["2023-01-01", "2023-01-02"] },
  { "_id": "orange", "uniqueDates": ["2023-01-03"] }
]

4.6、查询结果后再分组

db.sales.aggregate([
  { $match: { item: "apple" } },
  {
    $group: {
      _id: "$date",
      totalQuantity: { $sum: "$quantity" },
      avgPrice: { $avg: "$price" }
    }
  }
])

结果：

[
  { "_id": "2023-01-01", "totalQuantity": 2, "avgPrice": 10 },
  { "_id": "2023-01-02", "totalQuantity": 5, "avgPrice": 10 }
]

4.7、对分组结果进行排序

db.sales.aggregate([
  {
    $group: {
      _id: "$item",
      totalQuantity: { $sum: "$quantity" }
    }
  },
  { $sort: { totalQuantity: -1 } }
])

结果：

[
  { "_id": "banana", "totalQuantity": 17 },
  { "_id": "apple", "totalQuantity": 7 },
  { "_id": "orange", "totalQuantity": 8 }
]

2、插入

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

// 示例
db.users.insertOne({
  name: "Tom",
  age: 30,
  email: "[email protected]"
})
  • 插入多个文档（插入多条数据） insertMany
// 语法
db.<collection_name>.insertMany([
  {}, {}
])


// 示例
db.orders.insertMany([
  { item: "book", qty: 10, price: 15 },
  { item: "pen", qty: 20, price: 1.5 }
])

3、修改

  • 更新一条文档（修改一条数据） updateOne
  1. 更新 name 为 “Alice” 的文档的 age 字段
db.users.updateOne(
  { name: "Alice" },
  { $set: { age: 26 } }
)
  1. 如果没有找到文档，则插入一个新文档 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" } }
)

4、删除

  • 删除一个文档（删除一条数据） 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({})

5、计划查询

有users集合数据如下：

[
  { "_id": 1, "name": "Alice", "age": 25, "address": { "city": "New York", "state": "NY" }, "score": 80 },
  { "_id": 2, "name": "Bob", "age": 30, "address": { "city": "Los Angeles", "state": "CA" }, "score": 90 }
]
  • 查询结果只返回指定字段 投影
db.users.aggregate([
  {
    $project: {
      name: 1,
      age: 1
    }
  }
])

结果：

[
  { "_id": 1, "name": "Alice", "age": 25 },
  { "_id": 2, "name": "Bob", "age": 30 }
]
  • 查询结果不返回指定字段 投影
db.users.aggregate([
  {
    $project: {
      address: 0
    }
  }
])

结果：

[
  { "_id": 1, "name": "Alice", "age": 25, "score": 80 },
  { "_id": 2, "name": "Bob", "age": 30, "score": 90 }
]
  • 重命名字段
db.users.aggregate([
  {
    $project: {
      username: "$name",
      age: 1
    }
  }
])

结果：

[
  { "_id": 1, "username": "Alice", "age": 25 },
  { "_id": 2, "username": "Bob", "age": 30 }
]
  • 计算新字段
    计算新的字段 discountedScore，其值为 score 的 90%：
db.users.aggregate([
  {
    $project: {
      name: 1,
      age: 1,
      discountedScore: { $multiply: ["$score", 0.9] }
    }
  }
])

结果：

[
  { "_id": 1, "name": "Alice", "age": 25, "discountedScore": 72 },
  { "_id": 2, "name": "Bob", "age": 30, "discountedScore": 81 }
]
  • 只显示指定的嵌套字段
db.users.aggregate([
  {
    $project: {
      name: 1,
      age: 1,
      "address.city": 1
    }
  }
])

结果：

```java
[
  { "_id": 1, "name": "Alice", "age": 25, "address": { "city": "New York" } },
  { "_id": 2, "name": "Bob", "age": 30, "address": { "city": "Los Angeles" } }
]

6、多表连接查询 $lookup

  • 两张集合，关联查询
    有两个集合 orders 订单表和 products 产品表，orders 集合中的文档中的 productId 字段，指向 products 集合中 _id 字段，数据内容如下：
// orders 集合
{ "_id": 1, "productId": 101, "quantity": 2 }
{ "_id": 2, "productId": 102, "quantity": 1 }
 
// products 集合
{ "_id": 101, "name": "Widget", "price": 19.99 }
{ "_id": 102, "name": "Gadget", "price": 29.99 }

内联查询语句：

db.orders.aggregate([
    {
        $lookup: {
            from: "products",
            localField: "productId",
            foreignField: "_id",
            as: "productDetails"
        }
    }
])

参数说明：
db.orders.aggregate([…])：aggregate 方法在 orders 集合上运行。这意味着整个聚合管道操作是针对 orders 集合的。

from：指定要连接的目标集合的名称。示例中我们是从 products 集合中查询关联数据。

localField：指定当前集合（orders源集合）中用于连接的字段名称。示例中和products关联的是productId字段。

foreignField：指定目标集合（from 集合）中用于连接的字段名称，示例中和orders关联的是_id字段。

  • 三张集合，关联查询
    orders 订单表和 products 表关联，products 表和 categories 关联，数据内容如下：
// orders  订单表
{ "_id": 1, "productId": 101, "quantity": 2 }
{ "_id": 2, "productId": 102, "quantity": 1 }
 
// products 产品表
{ "_id": 101, "categoryId": 201, "name": "Widget" }
{ "_id": 102, "categoryId": 202, "name": "Gadget" }
 
// categories 产品类别表
{ "_id": 201, "name": "Electronics" }
{ "_id": 202, "name": "Home Goods" }

内联查询语句：

db.orders.aggregate([
    {
        $lookup: {
            from: "products",
            localField: "productId",
            foreignField: "_id",
            as: "productDetails"
        }
    },
    {
        $lookup: {
            from: "categories",
            localField: "productDetails.categoryId",
            foreignField: "_id",
            as: "productDetails.categoryDetails"
        }
    }
])
  • 外联查询 $unwind
    $unwind 是 MongoDB 聚合管道中的另一个操作符，用于将数组字段展开成多个文档。如果在使用 $lookup 时，目标集合的字段是一个数组（如上面的例子中 productDetails 是一个数组），使用 $unwind 可以将每个数组元素展开为独立的文档。

示例一：配置 $lookup 使用

db.orders.aggregate([
    {
        $lookup: {
            from: "products",
            localField: "productId",
            foreignField: "_id",
            as: "productDetails"
        }
    },
    {
        $unwind: "$productDetails"
    }
])

示例二：展开数组

有如下基础数据：

db.users.insertMany([
  { _id: 1, name: "Alice", address: ["广州", "北京", "杭州"] },
  { _id: 2, name: "Bob", address: ["上海", "武汉"] },
  { _id: 3, name: "Charlie", address: [] }
])

外联查询语句

db.users.aggregate([
    { $unwind: "$address" }
])

查询结果

[
  { "_id": 1, "name": "Alice", "address": "广州" },
  { "_id": 1, "name": "Alice", "address": "北京" },
  { "_id": 1, "name": "Alice", "address": "杭州" },
  { "_id": 2, "name": "Bob", "address": "上海" },
  { "_id": 2, "name": "Bob", "address": "武汉" }
]

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
【错】'generator' object is not subscriptable
1688 详情 API 接口的优势体现在哪些方面？
42、JSTL的if标签
MySQL基础总结(六) 变量
vue 两个input框设置结束时间大于开始时间
数据从哪来到哪去
C++ primer plus 第16章string 类和标准模板库, 容器种类
c++魔塔游戏实现
Bean作用域
Spring底层核心原理以及手写模拟实现
;