当前位置：Gxlcms > 数据库问题 > mongodb常用命令

mongodb常用命令

时间：2021-07-01 10:21:17 帮助过：7人阅读

1. 数据库

1. 创建数据库

语法

use database_name

示例

> show dbs;
admin   0.000GB
config 0.000GB
local   0.000GB
> use ajing
switched to db ajing
> show dbs;
admin   0.000GB
config 0.000GB
local   0.000GB
> db.mycollection.insert({"name": "ajing"})
WriteResult({ "nInserted" : 1 })
> show dbs;
admin   0.000GB
ajing   0.000GB
config 0.000GB
local   0.000GB
>

2. 删除数据库

语法

db.dropDatabase()

示例

> show dbs;
admin   0.000GB
ajing   0.000GB
config 0.000GB
local   0.000GB
> use ajing
switched to db ajing
> db.dropDatabase()
{ "dropped" : "ajing", "ok" : 1 }
> show dbs
admin   0.000GB
config 0.000GB
local   0.000GB
>

2. 集合

1. 创建并查看集合

语法

# 创建集合
db.createCollection(name, options)
# 查看集合
show collecitons
# 或者
show tables

参数说明:

  • name: 要创建的集合名称
  • options: 可选参数, 指定有关内存大小及索引的选项 options 可以是如下参数:
字段  类型  描述
capped  布 尔                                                                             (可选)如果为 true，则创建固定集合。固定集合是指有着固定大小的集 合，当达到最大值时，它会自动覆盖最早的文档。当该值为 true 时，必 须指定 size 参数。                                                                
autoIndexId 布 尔 (可选)如为 true，自动在 _id 字段创建索引。默认为 false。
size        数 值 (可选)为固定集合指定一个最大值(以字节计)。如果 capped 为 true**，也需要指定该字段。**                                                               
max 数 值 (可选)指定固定集合中包含文档的最大数量。

在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。

示例

> use test
switched to db test
> show collections
> show tables
> db.createCollection("mycollection")
{ "ok" : 1 }
> show tables
mycollection
> show collections
mycollection

2. 删除集合

语法

db.collection_name.drop()

示例

> use test
switched to db test
> show tables
mycollection
> db.mycollection.drop()
true
> show collections
>

3. 文档

1. 插入文档

语法

db.colleciton_name.insert(document)

示例

> var document = { "name": "ajing", "age": 18, "address": "beijing" }
> document
{ "name" : "ajing", "age" : 18, "address" : "beijing" }
> db.mycollection.insert(document)
WriteResult({ "nInserted" : 1 })

2. 查询文档

语法

db.collection_name.find(query, projection)

query :可选，使用查询操作符指定查询条件 projection :可选，使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参 数即可(默认省略)。

如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下:

db.collection_name.find().pretty()

示例

> show tables;
mycollection
> db.mycollection.find()
{ "_id" : ObjectId("5ebf25b8bbc6542a50be8234"), "name" : "ajing", "age" : 18, "address" : "beijing" }
> db.mycollection.find().pretty()
{
"_id" : ObjectId("5ebf25b8bbc6542a50be8234"),
"name" : "ajing",
"age" : 18,
"address" : "beijing"
}

3. 删除文档

语法

# 删除一条后者多条
db.collection_name.remove(<query>, <justOne>)
# 清空
db.collection_name.remove({})

如果你的 MongoDB 是 2.6 版本以后的，语法格式如下

db.collection_name.remove(
  <query>,
  {
    justOne: <boolean>,
    writeConcern: <document>
} )

参数说明:

query :(可选)删除的文档的条件。 justOne : (可选)如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值 false，则删除所有匹配条件的文档。 writeConcern :(可选)抛出异常的级别。

示例

> db.mycollection.find().pretty()
{
"_id" : ObjectId("5ebf25b8bbc6542a50be8234"),
"name" : "ajing",
"age" : 18,
"address" : "beijing"
}
> var document1 = { "name": "hello world", "age": 1, "address": "tianjin" }
> db.mycollection.insert(document1)
WriteResult({ "nInserted" : 1 })
> db.mycollection.find().pretty()
{
"_id" : ObjectId("5ebf25b8bbc6542a50be8234"),
"name" : "ajing",
"age" : 18,
"address" : "beijing"
}
{
"_id" : ObjectId("5ebf2836bbc6542a50be8235"),
"name" : "hello world",
"age" : 1,
"address" : "tianjin"
}
> db.mycollection.remove({"name": "ajing"}, 1)
WriteResult({ "nRemoved" : 1 })
> db.mycollection.find().pretty()
{
"_id" : ObjectId("5ebf2836bbc6542a50be8235"),
"name" : "hello world",
"age" : 1,
"address" : "tianjin"
}
>

4. limit()和skip()方法

limit()方法

语法

db.collection_name.find().limit(number)

类似sql的limit用法, 读取记录的条数

skip()方法

语法

db.collection_name.find.skip(number)

跳过指定数量的数据

5. 文档排序

语法

db.collection_name.find().sort({KEY: 1/-1})

在 MongoDB 中使用 sort() 方法对数据(文档)进行排序，sort() 方法可以通过参数指定排序的字段， 并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。

6. mongodb索引

1. 创建索引

语法

db.collection_name.createIndex(keys, options)

Key: 你要创建的索引字段, 1为升序, -1为降序创建索引

createIndex() 接收可选参数，可选参数列表如下:


                                                                                        Parameter                                                                                                                                                                       Type                                                                                                                                                                        Description                                                                             
                                                                                        background                                                                                                                                                                      Boolean                                                                                                                                                                         建索引过程会阻塞其它数据库操作，background可指定 以后台方式创建索引，即增加 "background" 可选参数。"background" 默认值为false。                                                                           
                                                                                        unique                                                                                                                                                                      Boolean                                                                                                                                                                         建立的索引是否唯一。指定为true创建唯一索引。默认值 为false.                                                                             
                                                                                        name                                                                                                                                                                        string                                                                                                                                                                      索引的名称。如果未指定，MongoDB的通过连接索引的 字段名和排序顺序生成一个索引名称。                                                                           
                                                                                        dropDups                                                                                                                                                                        Boolean                                                                                                                                                                         3.0+**版本已废弃。在建立唯一索引时是否删除重复记录, 指定 true 创建唯一索引。默认值为 false**.                                                                          
                                                                                        sparse                                                                                                                                                                      Boolean                                                                                                                                                                         对文档中不存在的字段数据不启用索引;这个参数需要特 别注意，如果设置为true的话，在索引字段中不会查询出 不包含对应字段的文档.。默认值为 false.                                                                           
                                                                                        expireAfterSeconds                                                                                                                                                                      integer                                                                                                                                                                         指定一个以秒为单位的数值，完成 TTL设定，设定集合的 生存时间。                                                                           
                                                                                        v                                                                                                                                                                       index version                                                                                                                                                                       索引的版本号。默认的索引版本取决于mongod创建索引 时运行的版本。                                                                         
                                                                                        weights                                                                                                                                                                         document                                                                                                                                                                        索引权重值，数值在 1 到 99,999 之间，表示该索引相对 于其他索引字段的得分权重。                                                                           
                                                                                        default_language                                                                                                                                                                        string                                                                                                                                                                      对于文本索引，该参数决定了停用词及词干和词器的规则 的列表。默认为英语                                                                             
                                                                                        language_override                                                                                                                                                                       string                                                                                                                                                                      对于文本索引，该参数指定了包含在文档中的字段名，语 言覆盖默认的language，默认值为 language.

实例:

db.test.createIndex({"name": 1, "age": -1}, {background: true})

test集合中, 那么字段正序, age反序创建索引, 并在后台创建索引

2. 查看集合索引

查看集合索引

db.colletion_name.getIndexes()

查看集合索引大小

db.collection_name.totalIndexSize()

3. 删除集合索引

删除集合所有索引

db.collection_name.dropIndexes()

删除集合指定索引

db.collection_name.dropIndex("索引名称")

> db.mycollection.getIndexes()
[
{
"v" : 2,
"key" : {
"_id" : 1
},
"name" : "_id_",
"ns" : "test.mycollection"
},
{
"v" : 2,
"key" : {
"name" : 1
},
"name" : "name_1",
"ns" : "test.mycollection"
}
]
> db.mycollection.dropIndex("name_1")
{ "nIndexesWas" : 2, "ok" : 1 }

索引名称就是上面中name的对应名字

7. 聚合查询

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。利用Aggregate聚合管道可以完成。MongoDB的聚合管道将 MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。表达式:处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

基本语法为:

db.collection_name.aggregate(AGGREGATE_OPTIOIN)

为了便于理解，先将常见的mongo的聚合操作和mysql的查询做下类比:


表达式                                                                                     SQL操作                                                                                                                                                                       描述
$group                                                                              group by    分组                                                                          
$sum    count()、sum()   计算总和。                                                                           
$avg    avg()       计算平均值                                                                           
$min        min()       获取集合中所有文档对应值得最小值。                                                                       
$max    max()                                                                                               获取集合中所有文档对应值得最大值。                                                           
$match  where、having                                                                                            查询条件                                                                            
$sort   order by                                                                                            排序                                                                          
$limit  limit                                                                                           取条数                                                                             
$project    select                                                                                          选择                                                                          
$lookup (v3.2 新增)       join                                                                                            连接

1. 数据准备

> db.list1.find().pretty()
{
"_id" : ObjectId("5ec22afc42b300f01671543f"),
"name" : "zhaoyun1",
"age" : 1,
"city" : "BJ"
}
{
"_id" : ObjectId("5ec22b0a42b300f016715440"),
"name" : "zhaoyun2",
"age" : 2,
"city" : "BJ"
}
{
"_id" : ObjectId("5ec22b1242b300f016715441"),
"name" : "zhaoyun3",
"age" : 3,
"city" : "BJ"
}
{
"_id" : ObjectId("5ec22b1a42b300f016715442"),
"name" : "zhaoyun4",
"age" : 4,
"city" : "BJ"
}
{
"_id" : ObjectId("5ec22b2242b300f016715443"),
"name" : "zhaoyun5",
"age" : 5,
"city" : "BJ"
}
{
"_id" : ObjectId("5ec22bff42b300f016715444"),
"name" : "zhaoyun6",
"age" : 6,
"city" : "TJ"
}
{
"_id" : ObjectId("5ec22c0b42b300f016715445"),
"name" : "zhaoyun7",
"age" : 7,
"city" : "TJ"
}
>

1. $group

城市分组

第一个列必须是_id, 否则报错

> db.list1.aggregate([{$group: {_id : "$city"}}])
{ "_id" : "BJ" }
{ "_id" : "TJ" }
>

2. $sum

按照城市分组获得每组年龄总和

> db.list1.aggregate([{$group: {_id : "$city", ageNumbers: {$sum : "$age"}}}])
{ "_id" : "TJ", "ageNumbers" : 13 }
{ "_id" : "BJ", "ageNumbers" : 15 }
>

3.$avg

按照城市分组获得每组平均年龄

> db.list1.aggregate([{$group: {_id : "$city", avg: {$avg : "$age"}}}])
{ "_id" : "BJ", "avg" : 3 }
{ "_id" : "TJ", "avg" : 6.5 }

4.$min

按照城市分组获得每组最小年龄

> db.list1.aggregate([{$group: {_id : "$city", min: {$min : "$age"}}}])
{ "_id" : "TJ", "min" : 6 }
{ "_id" : "BJ", "min" : 1 }

5.$max

按照城市分组获得每组最大年龄

> db.list1.aggregate([{$group: {_id : "$city", max: {$max : "$age"}}}])
{ "_id" : "TJ", "max" : 7 }
{ "_id" : "BJ", "max" : 5 }

6.$match

年龄大于2, 小于等于5

> db.list1.aggregate([{$match:{age:{$gt : 2, $lte : 5}}}])
{ "_id" : ObjectId("5ec22b1242b300f016715441"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" }
{ "_id" : ObjectId("5ec22b1a42b300f016715442"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" }
{ "_id" : ObjectId("5ec22b2242b300f016715443"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" }
>

7.$sort

年龄呢从大到小排序

> db.list1.aggregate([{$sort:{age:-1}}])
{ "_id" : ObjectId("5ec22c0b42b300f016715445"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ" }
{ "_id" : ObjectId("5ec22bff42b300f016715444"), "name" : "zhaoyun6", "age" : 6, "city" : "TJ" }
{ "_id" : ObjectId("5ec22b2242b300f016715443"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" }
{ "_id" : ObjectId("5ec22b1a42b300f016715442"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" }
{ "_id" : ObjectId("5ec22b1242b300f016715441"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" }
{ "_id" : ObjectId("5ec22b0a42b300f016715440"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" }
{ "_id" : ObjectId("5ec22afc42b300f01671543f"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" }
>

8. $limit

求age最大的两个

> db.list1.aggregate([{$sort:{age:-1}}, {$limit: 2}])
{ "_id" : ObjectId("5ec22c0b42b300f016715445"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ" }
{ "_id" : ObjectId("5ec22bff42b300f016715444"), "name" : "zhaoyun6", "age" : 6, "city" : "TJ" }
>

9. $project

> db.list1.aggregate([{$project: {_id: 0, name: 1, city: 1, age: 1}}])
{ "name" : "zhaoyun1", "age" : 1, "city" : "BJ" }
{ "name" : "zhaoyun2", "age" : 2, "city" : "BJ" }
{ "name" : "zhaoyun3", "age" : 3, "city" : "BJ" }
{ "name" : "zhaoyun4", "age" : 4, "city" : "BJ" }
{ "name" : "zhaoyun5", "age" : 5, "city" : "BJ" }
{ "name" : "zhaoyun6", "age" : 6, "city" : "TJ" }
{ "name" : "zhaoyun7", "age" : 7, "city" : "TJ" }

10. $lookup

语法

{
  $lookup:
    {
      from: <collection to join>,
      localField: <field from the input documents>,
      foreignField: <field from the documents of the "from" collection>,
      as: <output array field>
    }
}

语法的解释说明

语法值 解释说明
from    同一个数据库下等待被Join的集合。
localField  源集合中的match值，如果输入的集合中，某文档没有 localField这个Key（Field），在处理的过程中，会默认为此文档含有 localField：null的键值对。
foreignField    待Join的集合的match值，如果待Join的集合中，文档没有foreignField 值，在处理的过程中，会默认为此文档含有 foreignField：null的键值对。
as  为输出文档的新增值命名。如果输入的集合中已存在该值，则会覆盖掉，

用于多文档关联, 类似sql的多表关联

示例

以上的语法介绍有些枯燥，不易理解，我们直接分析品味案例好了。

假设 有 订单集合， 存储的测试数据 如下：

db.orders.insert([
  { "_id" : 1, "item" : "almonds", "price" : 12, "quantity" : 2 },
  { "_id" : 2, "item" : "pecans", "price" : 20, "quantity" : 1 },
  { "_id" : 3 }
])
其中 ite
```m 对应 数据为 商品名称。

另外 一个 就是就是 商品库存集合 ，存储的测试数据 如下：

db.inventory.insert([
{ "_id" : 1, "sku" : "almonds", description: "product 1", "instock" : 120 },
{ "_id" : 2, "sku" : "bread", description: "product 2", "instock" : 80 },
{ "_id" : 3, "sku" : "cashews", description: "product 3", "instock" : 60 },
{ "_id" : 4, "sku" : "pecans", description: "product 4", "instock" : 70 },
{ "_id" : 5, "sku": null, description: "Incomplete" },
{ "_id" : 6 }
])

此集合中的 sku 数据等同于 订单 集合中的 商品名称。

在这种模式设计下，如果要查询订单表对应商品的库存情况，应如何写代码呢？

**很明显这需要两个集合Join。**

场景简单，不做赘述，直送答案 。其语句 如下：

db.orders.aggregate([
{
$lookup:
{
from: "inventory",
localField: "item",
foreignField: "sku",
as: "inventory_docs"
}
}
])

返回的执行结果如下：

{
"_id" : NumberInt("1"),
"item" : "almonds",
"price" : NumberInt("12"),
"quantity" : NumberInt("2"),
"inventory_docs" : [
{
"_id" : NumberInt("1"),
"sku" : "almonds",
"description" : "product 1",
"instock" : NumberInt("120")
}
]
}

{
"_id" : NumberInt("2"),
"item" : "pecans",
"price" : NumberInt("20"),
"quantity" : NumberInt("1"),
"inventory_docs" : [
{
"_id" : NumberInt("4"),
"sku" : "pecans",
"description" : "product 4",
"instock" : NumberInt("70")
}
]
}

{
"_id" : NumberInt("3"),
"inventory_docs" : [
{
"_id" : NumberInt("5"),
"sku" : null,
"description" : "Incomplete"
},
{
"_id" : NumberInt("6")
}
]
}

mongodb常用命令

标签：complete   读取数据   ioi   解释   基本   yun   取数   cas   操作   

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！