MongoDB 相关操作命令。

最新推荐文章于 2023-02-18 16:59:12 发布

youngxuebo

最新推荐文章于 2023-02-18 16:59:12 发布

阅读量374

点赞数

分类专栏： Mongodb

本文链接：https://blog.csdn.net/qq_32783151/article/details/118082974

版权

Mongodb 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、启动 MongoDB服务命令

./bin/mongod -config ./data/mongodb.conf

二、关闭 MongoDB服务命令

./bin/mongod -shutdown -config ./data/mongodb.conf

三、MongoDB 连接

mongodb://username:password@hostname/dbname

标准格式：
mongodb://username:password@host1:port1,host2:port2,…,hostN:portN/dbname/?option1;option2

四、数据库操作

4.1、创建数据库：use DATABASE_NAME

MongoDB通过命令use 数据库名创建数据库。如果数据库不存在，该命令将创建一个数据库，否则切换已有数据库。

4.2、查看当前所在的数据库：db

4.3、展示所有数据库：show dbs

4.4、删除数据库：db.dropDatabase()

删除当前数据库

五、集合操作

5.1 创建集合： db.createCollection(name, options)

命令中，name是要创建的集合名称，options是一个文档，用于指定集合的配置。
----------------------------------------------------------
参数类型描述
Name String 要创建的集合名称
Options Document (可选)指定内存大小、索引等选项/td>

如详情

5.2 展示集合： show collections

5.3 删除集合： db.COLLECTION_NAME.drop()

六、文档操作

6.1 插入文档

要将数据插入MongoDB集合，需要使用insert()或save()方法。

命令：db.COLLECTION_NAME.insert(document)

例子：

> db.mycollection_table.insert({
   title: 'MongoDB入门', 
   description: 'MongoDB是开源的NoSQL数据库',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 888
})

要在一次查询中插入多个文档，可以在insert()命令中，传递一个文档数组。

> db.mycollection_table.insert([
   {
      title: 'MongoDB入门', 
      description: 'MongoDB是一个以文档为中心的NOSQL数据库',
      tags: ['mongodb', 'database', 'NoSQL'],
      likes: 88
   },

   {
      title: 'MongoDB优势', 
      description: "MongoDB相对于RDBMS的优势",
      tags: ['mongodb', 'database', 'NoSQL'],
      comments: [   
         {
            user:'user1',
            message: 'My first comment',
            dateCreated: new Date(2018,11,10,2,35),
            like: 0 
         }
      ]
   }
])

将数据定义为一个变量插入

> document=({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
});

> db.mycollection_table.insert(document)
WriteResult({ "nInserted" : 1 })
>

要插入文档，还可以使用db.post.save(document)方法。如果没指定_id，那么save()方法将与insert()方法一样，自动生成_id。如果指定_id，则它将替换_id所标识文档的整个数据。

6.2 删除文档

remove() 方法

remove() 方法的基本语法格式如下所示：

db.mycollection_table.remove(
   <query>,
   <justOne>
)

#如果MongoDB 是 2.6 版本以后的，语法格式如下：
db.mycollection_table.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)

参数说明：

query :（可选）删除的文档的条件。
justOne : （可选）如果设为 true 或 1，则只删除一个文档。
writeConcern :（可选）抛出异常的级别。

举例：

#符合条件的全删除
>db.mycollection_table.remove({'title':'MongoDB 教程'})

#只想删除第一条找到的记录可以设置 justOne 为 1
>db.mycollection_table.remove(DELETION_CRITERIA,1)
>db.col.remove({'title':'MongoDB 教程'},1)

#删除所有数据，可以使用以下方式（类似常规 SQL 的 truncate 命令清空表）
>db.mycollection_table.remove({})
>>db.mycollection_table.remove()

6.3 更新文档

（1）MongoDB数据更新可以使用update()函数。

db.mycollection_table.update( criteria, objNew, upsert, multi )

update()函数接受以下四个参数：

criteria : update的查询条件，类似sql update查询内where后面的。
objNew :update的对象和一些更新的操作符（如 $,$ inc…）等，也可以理解为sql update查询内set后面的
upsert :这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi :mongodb默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。

举例：

#将title栏位的 MongoDB 优势，更新为 MongoDB 优点
> db.mycollection_table.update({'title':'MongoDB 优势'}, {$set:{'title':'MongoDB 优点'}})

#默认情况下，MongoDB只更新一个文档。要更新多个文档，需要将参数“multi”设置为true。
db.mycollection_table.update({'title':'MongoDB 入门'}, {$set:{'title':'MongoDB 概述'}},{multi:true})

#只更新第一条记录：
db.test.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } ); 

#全部更新：
db.test.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true ); 

#只添加第一条：
db.test.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false ); 

#全部添加加进去:
db.test.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true ); 
 
#全部更新：
db.test.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
 
#只更新第一条记录：
db.test.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

$inc 可以对文档的某个值为数字型（只能为满足要求的数字）的键进行增减的操作。
$set 用来指定一个键并更新键值，若键不存在并创建。

（2）更新内嵌的文档

> db.test.findOne({"name":"toyota"})
{
  "_id" : ObjectId("5003be465af21ff428dafbe7"),
  "name" : "toyota",
  "type" : "suv",
  "size" : {
    "height" : 10,
    "width" : 5,
    "length" : 15
  }
}

> db.test.update({"name":"toyota"},{"$set":{"size.height":8}})

> db.test.findOne({"name":"toyota"})
{
  "_id" : ObjectId("5003be465af21ff428dafbe7"),
  "name" : "toyota",
  "type" : "suv",
  "size" : {
    "height" : 8,
    "width" : 5,
    "length" : 15
  }

（3）Save() 方法

save()方法根据文档参数更新现有文档或插入新文档。

#语法
db.COLLECTION_NAME.save({_id:ObjectId(), NEW_DATA})

#下面的示例，把新内容保存到_id为’5cf7b4839ad87fde6fd23a03’的文档中。

> db.mycollection_table.save(
   {
      "_id" : ObjectId("5cf7b4839ad87fde6fd23a03"), "title":"MongoDB 介绍",
      "by":"qikegu.com"
   }
)

6.4 查询文档

find() 方法

find()方法的基本语法如： db.COLLECTION_NAME.find()

除了find()方法之外，还有findOne()方法，它只返回一个结果。

pretty() 方法

要以格式化的方式显示结果，可以使用pretty()方法。

> db.mycollection_table.find().pretty()

#需要返回的键,0 为不返回，1为返回
> db.mycollection_table.find({"key":"value"},{"key":1}).pretty()
#相当于sql:
select key from mycollection_table where key = 'value'

MongoDB查询条件与SQL Where对比

find()方法可以传入查询条件，为便于理解，下表列出了等价的SQL Where语句。

操作	语法	例子	等价于
等于	{<key>:<value>}	db.mycol.find({“title”:”MongoDB教程”}).pretty()	where title = ‘MongoDB教程’
小于	{<key>:{$lt:<value>}}	db.mycol.find({“likes”:{$lt:50}}).pretty()	where likes < 50
小于等于	{<key>:{$lte:<value>}}	db.mycol.find({“likes”:{$lte:50}}).pretty()	where likes <= 50
大于	{<key>:{$gt:<value>}}	db.mycol.find({“likes”:{$gt:50}}).pretty()	where likes > 50
大于等于	{<key>:{$gte:<value>}}	db.mycol.find({“likes”:{$gte:50}}).pretty()	where likes >= 50
小于等于	{:{$ne:<value>}}	db.mycol.find({“likes”:{$ne:50}}).pretty()	where likes != 50

举例如下：

db.col.find({"likes" : {$gt : 100}})
#类似于SQL语句：
Select * from mycollection_table where likes > 100;

db.col.find({likes : {$lte : 150}})
#类似于SQL语句：
Select * from col where likes <= 150;

db.mycollection_table.find({likes : {$lt :200, $gt : 100}})
#类似于SQL语句：
Select * from mycollection_table where likes>100 AND  likes<200;

（1） AND 条件语法

> db.mycollection_table.find(
   {
      $and: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

//and 可以省略
> db.mycollection_table.find(
   {
    key1:value1, 
    key2:value2
   }
).pretty()

（2） OR 条件语法

> db.mycollection_table.find(
   {
      $or: [
         {"key1": "value1"}, {"key2":"value2"}
      ]
   }
).pretty()

（3） AND 和 OR混合

> db.mycollection_table.find(
   {
      $and: [
         {"key1": "value1"}, {"key2":"value2"}
      ],
      $or: [
         {"key1": "value1"}, {"key2":"value2"}
      ]
   }
).pretty()

（4）Limit 方法

limit()方法限定返回行数，基本语法如下所示：

>db.COLLECTION_NAME.find().limit(NUMBER)

#如查询mycollection_table集合，显示title列，不显示_id列，返回两行数据：
>db.mycollection_table.find({},{"title":1,_id:0}).limit(2)

（5） LIKE模糊查询

1、LIKE模糊查询userName包含A字母的数据(%A%)

#SQL:
SELECT * FROM UserInfo WHERE userName LIKE "%A%"

#MongoDB:
db.UserInfo.find({"userName": /A/})

2、LIKE模糊查询userName以字母A开头的数据(A%)

#SQL:
SELECT * FROM UserInfo WHERE userName LIKE "A%"

#MongoDB:
db.UserInfo.find({"userName":/^A/})

3、正则表达式查询 $regex

>db.posts.find({post_text:{$regex:"runoob"}})

#以上查询也可以写为：
>db.posts.find({post_text:/runoob/})

#例子：
select * from member where name like '%XXX%'
#在mongodb中：
db.member.find({"name":{ $regex:/XXX/}})

#查询以某字段为开头的文档
db.member.find({"name":{$regex:/^XXX/}})
#查询以某字段为结尾的文档
db.member.find({"name":{$regex:/XXX^/}})
#查询忽略大小写
db.member.find({"name":{$regex:/XXX/i}})
db.member.find( { name: { $regex: /XXX/, $options: 'i' } } )

参考：mongodb中$regex的用法

（6）特定类型查询

参考：查询条件

6.5 排序

sort()方法

通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。

db.COLLECTION_NAME.find().sort({KEY:1})

七、其他操作

7.1 索引

索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。

ensureIndex() 方法

MongoDB使用 ensureIndex() 方法来创建索引

#语法中 Key 值为你要创建的索引字段，1为指定按升序创建索引，如果你想按降序来创建索引指定为-1即可。
>db.COLLECTION_NAME.ensureIndex({KEY:1})

#复合索引
>db.mycol.ensureIndex({"title":1,"description":-1})

#在后台创建索引：
db.values.ensureIndex({"title":1,"description":-1}, {background: true})

7.2 聚合

主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。

7.2.1 aggregate() 方法

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

#不包含_id
db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

#相当于sql：
select title,author from article

mongoDB中聚合(aggregate)的具体使用

7.2.2 管道符

MongoDB的聚合管道与Linux管道相似，将文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。

先来看一个分组的例子，本例中 $group 是一个管道操作符，获得的结果可以接着输出到下一个管道，而内部的$sum是一个表达式操作符。

db.article.aggregate([ 
        {
            $group: {
                _id: '$time', 
                num: {$sum: 1}
            }
        }
    ])
#_id字段表示你要基于哪个字段来进行分组(即制定字段值相同的为一组)
#num字段的值$sum: 1表示的是获取满足time字段相同的这一组的数量乘以后面给定的值(本例为1，那么就是同组的数量)。
#类似sql： select time,count(*) from article group by time

看完上述例子之后，mongoDB中还有其他的一些管道操作符和表达式操作符：

在这里插入图片描述
mongo的聚合操作和mysql的查询做下类比：

SQL 操作/函数	mongodb聚合操作
where	$match
group by	$group
having	$match
select	$project
order by	$sort
limit	$limit
sum()	$sum
count()	$sum
join	$lookup （v3.2 新增）

实例：

下面举了一些常用的mongo聚合例子和sql的对比：

#以下表数据：
{
  cust_id: "abc123",
  ord_date: ISODate("2012-11-02T17:04:11.102Z"),
  status: 'A',
  price: 50,
  items: [ { sku: "xxx", qty: 25, price: 1 },
           { sku: "yyy", qty: 25, price: 1 } ]
}

1. 统计orders表decocument数量
db.orders.aggregate( [
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

类似sql:
SELECT COUNT(*) AS count FROM orders


2.对orders表计算所有price求和
db.orders.aggregate( [
   {
     $group: {
        _id: null,
        total: { $sum: "$price" }
     }
   }
] )

类似sql;
SELECT SUM(price) AS total  FROM orders

3.对每一个唯一的cust_id, 计算price总和
db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )

类似sql:
SELECT cust_id,
       SUM(price) AS total
  FROM orders
 GROUP BY cust_id

4.对每一个唯一对cust_id和ord_date分组，计算price总和，不包括日期的时间部分
db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        },
        total: { $sum: "$price" }
     }
   }
] )

类似sql：
SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date

5.对于有多个记录的cust_id，返回cust_id和对应的数量
db.orders.aggregate( [
   {
     $group: {
        _id: "$cust_id",
        count: { $sum: 1 }
     }
   },
   { $match: { count: { $gt: 1 } } }
] )

类似sql:
SELECT cust_id,
       count(*)
FROM orders
GROUP BY cust_id
HAVING count(*) > 1

6.对每个唯一的cust_id和ord_date分组，计算价格总和，并只返回price总和大于250的记录，且排除日期的时间部分
db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        },
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

类似sql:
SELECT cust_id,
       ord_date,
       SUM(price) AS total
FROM orders
GROUP BY cust_id,
         ord_date
HAVING total > 250


7.对每个唯一的cust_id且status=A，计算price总和
db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   }
] )

类似sql:
SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id


8.对每个唯一的cust_id且status=A，计算price总和并且只返回price总和大于250的记录
db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {
        _id: "$cust_id",
        total: { $sum: "$price" }
     }
   },
   { $match: { total: { $gt: 250 } } }
] )

类似sql:
SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250


9.对于每个唯一的cust_id，将与orders相关联的相应订单项order_lineitem的qty字段进行总计
db.orders.aggregate( [
   { $unwind: "$items" },
   {
     $group: {
        _id: "$cust_id",
        qty: { $sum: "$items.qty" }
     }
   }
] )

类似sql:
SELECT cust_id,
       SUM(li.qty) as qty
FROM orders o,
     order_lineitem li
WHERE li.order_id = o.id
GROUP BY cust_id


10.统计不同cust_id和ord_date分组的数量，排除日期的时间部分
db.orders.aggregate( [
   {
     $group: {
        _id: {
           cust_id: "$cust_id",
           ord_date: {
               month: { $month: "$ord_date" },
               day: { $dayOfMonth: "$ord_date" },
               year: { $year: "$ord_date"}
           }
        }
     }
   },
   {
     $group: {
        _id: null,
        count: { $sum: 1 }
     }
   }
] )

类似sql:
SELECT COUNT(*)
FROM (SELECT cust_id, ord_date
      FROM orders
      GROUP BY cust_id, ord_date)
      as DerivedTable

八、参考地址

参考1
参考2

youngxuebo

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
MongoDB 相关操作命令。

1、启动 MongoDB服务命令：./bin/mongod -config ./data/mongodb.conf2、关闭 MongoDB服务命令：./bin/mongod -shutdown -config ./data/mongodb.conf3、MongoDB 连接：mongodb://username:password@hostname/dbname标准格式：mongodb://[username:password@]host1[:port1][,host2[:port2],...[
复制链接

扫一扫