黑马程序员技术交流社区

标题: 【广州python】 mongodb数据库操作 [打印本页]

---

作者: 唐伯虎（0）    时间: 2019-8-29 14:27
标题: 【广州python】 mongodb数据库操作



### 安装在Ubuntu16.04：


```bash
# 创建数据库文件夹，这个是默认存放数据的地方，但MongoDB不会自动创建
mkdir -p /data/db
# 增加权限
chown -R $USER:$USER /data/db
wget -qO - https://www.mongodb.org/static/pgp/server-4.0.asc | sudo apt-key add -  # 导入公钥
echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/4.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.0.list  # 为MongoDB创建列表文件
sudo apt-get update  # 重新加载本地数据包
sudo apt-get install -y mongodb-org=4.0.12 mongodb-org-server=4.0.12 mongodb-org-shell=4.0.12 mongodb-org-mongos=4.0.12 mongodb-org-tools=4.0.12  # 安装软件包
echo "mongodb-org hold" | sudo dpkg --set-selections
echo "mongodb-org-server hold" | sudo dpkg --set-selections
echo "mongodb-org-shell hold" | sudo dpkg --set-selections
echo "mongodb-org-mongos hold" | sudo dpkg --set-selections
echo "mongodb-org-tools hold" | sudo dpkg --set-selections  # 保持目前的版本，防止自动更新
# 启动
sudo service mongodb start #或者
systemctl start mongodb
```


### 卸载


```bash
sudo apt-get purge mongodb-org*
sudo rm -r /var/log/mongodb
sudo rm -r /var/lib/mongodb
```


### 通过systemctl start mongodb 启动时的错误解决


报错如下：


Failed to start mongodb.service: Unit mongodb.service not found.


解决：


```bash
sudo nano /etc/systemd/system/mongdb.service  # 创建服务文件
```


```bash
[Unit]
Description=High-performance, schema-free document-oriented database
After=network.target

[Service]
User=mongodb
ExecStart=/usr/bin/mongod --quiet --config /etc/mongod.conf
# 制定需要执行的命令的位置，                                #  制定项目运行所需要的配置文件位置
[Install]
WantedBy=multi-user.target
```


- 按ctrl + x 保存退出
- systemctl  start mongodb
- 永久有效： systemctl enable mongodb


### 1、文档中值的数据类型


在mongodb中数据是以文档的形式存在的


1、每个文档相当于一条记录


2、多个文档组合在一起，就是集合，一个集合就相当于一张数据表


3、多个集合组合在一起，就是数据库，每个数据库就是一个文件夹


- Object ID： ⽂档ID
- String： 字符串， 最常⽤， 必须是有效的UTF-8
- Boolean： 存储⼀个布尔值， true或false
- Integer： 整数可以是32位或64位， 这取决于服务器
- Double： 存储浮点值
- Arrays： 数组或列表， 多个值存储到⼀个键
- Object： ⽤于嵌⼊式的⽂档， 即⼀个值为⼀个⽂档
- Null： 存储Null值
- Timestamp： 时间戳， 表示从1970-1-1到现在的总秒数
- Date： 存储当前⽇期或时间的UNIX时间格式


### 2、Mongo  shell


- 使用mongo命令自动启动shell，并连接数据库服务器，该shell能够解析JavaScript的语法
- 通过shell可以完成一些列的增删改查工作


### 3、文档的基本增删改查


- 增加：使用insert（）函数，将要插入的数据放到集合中


  - 比如增加一个文档，首先先创建文档变量


    post = {"title": "my first mongo"}


  - 插入文档到blog集合中


    db.blog.insert(post)


  - 批量插入：同样适用inset方法，将你需要插入的文档全部存放到一个数组中


  - 当我们连接到服务器之后，**db**会自动指向正在使用的数据库，blog为集合名，没有会自动创建


- 查找：使用find（）或者findOne（）


  - find（）默认显示20条数据


    db.blog.find()


  - findOne（）只显示一条数据


    db.blog.findOne()


- 更新：使用**update（）**方法， 该方法接收两个参数，第一个为需要修改的文档，第二个修改过的文档


  **update()方法除了接收前两个参数外，还可以接收另外两个参数，并且这两个参数都是布尔值**


  **例如：db.blog.update({"title": "My Blog Post"}, {"title": "My Blog Get"}, true, true)**


  **第三个参数表示upsert，能够保证操作的原子性，同时在没有查询到制定的集合情况下，会以查询条件和更新文档为基础新建一个文档，第四个参数默认是true，表示更新所有符合条件的集合，若改为false，则只更新第一个。**


  - 第一：先更改文档对象的属性，也就是键值对，比如前文使用到的post变量


    给他增加一个属性：post.comments = []


  - 找到旧文档，替换为新的文档,根具给出的一个参数中的具体信息可以找到旧文档


    db.blog.update({"title":"my first mongo"}, post)


- 删除：remove（），在不给出参数的情况下，删除集合中的所有文档，给出参数后，会删除对应的文档


  - db.blog.remove({"title":"my first mongo"})


### 4、基于shell的其他命令，利用help查看


```shell
> help
```


| db.help()                  | help on db methods                                        |
| -------------------------- | --------------------------------------------------------- |
| db.mycoll.help()           | help on collection methods                                |
| sh.help()                  | sharding helpers                                          |
| rs.help()                  | replica set helpers                                       |
| help admin                 | administrative help                                       |
| help keys                  | key shortcuts                                             |
| help connect               | connecting to a db help                                   |
| help misc                  | misc things to know                                       |
| help mr                    | mapreduce                                                 |
| show dbs                   | show database names                                       |
| show collections           | show collections in current database                      |
| show users                 | show users in current database                            |
| show profile               | show most recent system.profile entries with time >= 1ms  |
| show logs                  | show the accessible logger names                          |
| use <db_name>              | set current database                                      |
| db.foo.find()              | list objects in collection foo                            |
| db.foo.find( { a : 1 } )   | list objects in foo where a == 1                          |
| it                         | result of the last line evaluated; use to further iterate |
| DBQuery.shellBatchSize = x | set default number of items to display on shell           |
| exit                       | quit the mongo shell                                      |


### 5、访问集合


1、当集合名与内置的函数名相同时，是没有办法通过**db.集合名**来访问的


2、当集合名名包含**-**时，比如：**six-four**，同样没有办法通过正常的方法访问集合，引文shell对其的解释是两个变量的相减


**最终的解决办法是通过__getCollection()__来访问，**例如：db.getCollection("version"),db.getCollection("six-four")这样才能正常访问


### 6、save shell


save是一个shell函数，可以在文档不存在的时候插入，存在的时候更新，它只有一个参数，即文档本身


save会调用upsert，即实现文档的自动创建和更新


var x = db.foo.findOne()


x.num = 12


db.foo.save(x)


### 7、修改器，以$号开头的特殊字符串


| 修改器 | 用法 | 作用 |
| ---- | :--- | :--- |
| $inc | db.x.update({"a":1}, {$inc: {"b":1}}) |在原有b的基础上加1|
| $set | db.x.update({"a":1}, {$set: {"b":"a"}}) |将原有b的数据修改为a，若b不存在，则创建一个|
| $unset | db.x.update({"a":1}, {$unset: {"b":1}}) |撤销修改，此时的数值1，表示条件为真的意思|
| $push | db.x.update({"a":1}, {$push:{"comments": {"name":"json"}}}) |该修改器只作用于数组，可以向文档中已有数组中添加值，当然数组不存在时，创建一个数组并添加对应内容|
| $pop | db.x.update({"a":1}, {$pop:{"comments": 1}})                                      db.x.update({"a":1}, {$pop:{"comments": -1}}) |基于数组位置的删除，1表示从数组的尾部删除一个元素，-1表示从数组的头部删除一个元素|
| $addToSet | db.x.update({"a":1}, {$addToSet:{"email": "aa@163.com"}) |该修改器只作用于数组，可以向数组中添加一个值，若数组中已经有了该值，则添加失败|
| $each | db.x.update({"a":1}, {$addToSet:{"email":  {$each: ["1", "2", "3"]}}) |可以遍历出数组中的每个值，通常与$addToSet搭配使用，完成多个值得添加，如果存在不添加|
| $pull | db.x.update({"a":1}, {$pull:{"email":  "1"}}) |指定数组中的具体元素进行删除，若匹配到多个值，匹配多少删除多少|
| $数组定位符 | db.x.update({"comments.author": "jhon"}, {$set:{"comments.$.author": 'lili'}}) |定位符只匹配第一个匹配到的文档|


### 8、查询


#### 8.1、指定键返回查询


- 查询使用find函数或者findOne函数
- 查询返回指定字段，也就是查询指定键
- db.blog.find({"a":2}, {"ss":1, "wo": 0}),当匹配到包含{"a":2}的文档后，只返回"_id" 和"ss"两个键，"_id"是默认返回的，其中1表示真，0表示假


#### 8.2、条件查询


| 命令    | 用法                                                        | 作用                                                         |
| ------- | ----------------------------------------------------------- | ------------------------------------------------------------ |
| $gt     | db.users.find({"age": {"$gt": 20}})                         | 查询users集合中年龄大于20的文档                              |
| $gte    | db.users.find({"age": {"$gte": 20}})                        | 查询users集合中年龄大于等于20的文档                          |
| $lt     | db.users.find({"age": {"$lt": 20}})                         | 查询users集合中年龄小于20的文档                              |
| $lte    | db.users.find({"age": {"$lte": 20}})                        | 查询users集合中年龄小于等于20的文档                          |
| $ne     | db.users.find({"username": {"$ne": "andy"}})                | 查询users集合中用户名不等于andy的文档                        |
| $or     | db.users.find({"$or": [{"age": 20},{"username": "andy"} ]}) | $or 键对应的值是一个数组，满足数组中任何一个条件的文档都会被查找出来，可作用于不同的键 |
| $in     | db.users.find({"age": {"$in": [12 ,10, 22]}})               | $in键对应的值是一个数组，满足数组中任何一个条件的文档都会被查找出来，但是它只作用于同一个键 |
| $nin    | db.users.find({"age": {"$nin": [12 ,10, 22]}})              | $nin键对应的值是一个数组，不满足数组中任何一个条件的文档都会被查找出来，它也只作用于同一个键 |
| $mod    | db.users.find({"age": {"$mod": [5, 1]}})                    | $mod表示取模运算，运算完成后在作为查询条件，它对应的值是一个数组，该数组只有两个值且有顺序，第一个表示除数，第二个表示余数，在这里表达的意思是，找出年龄除以5后余数为1的文档 |
| $not    | db.users.find({"$not":{"age": {"$mod": [5, 1]}}})           | $not是元条件查询，即作用其他条件查询之上，例如他与$mod取模运算结合使用，表示取非 |
| $existe | db.users.find({"x":{"$existe": true}})                      | $existe判断该键是否真实存在，存在则显示出来                  |
| /joy/i  | db.users.find({"username": /joy/i})                         | 这里是利用正则表达式去匹配所查询文档的某个键对应的值，i表示不区分大小写 |


$where 自定义查询


```js
db.stu.find({
    $where:function() {
        return this.age>30;}  // this 代表当前查询的文档，找出年龄大于30岁的文档
})
```


#### 8.3、数组查询


##### 8.3.1、$all


- 创建如下集合并加入三条文档：


  db.fruit.insert({"_id": 1, "fruits": ["banana", "peach", "apple"]})


  db.fruit.insert({"_id": 2, "fruits": ["orange", "kumquat", "apple"]})


  db.fruit.insert({"_id": 3, "fruits": ["banana", "cherry", "apple"]})


- {"$all": ["banana", "apple"]},作用于数组，


  使用db.fruit.find({"fruits": {"$all" : ["banana", "apple"]}}),执行结果是数值fruits中只要包含有"banana"和"apple"元素的文档，全部返回，忽略数组中元素的顺序


- 特殊用法


  {"fruits": {"$all" : ["banana"]}}和{"fruits":"banana"}，这两条查询效果是一样的


- 基于数组下标的查找


  比如：db.fruit.find({"fruits.2":"apple"})，只要数组中指定位置的元素匹配正确，就会返回结果


##### 8.3.2、$size


- 查询固定数组长度的文档


  - 用法：db.fruit.find({"fruits": {"$size": 3}})
  - 不能配合其他条件命令使用，例如$gt，而实际生产中，总是需要我们去查找数组范围的文档


- 在文档中创建一个size的字段来专门描述数组的长度，变相的通过size的值来范围查找


  - 例如上文：增加一个size字段，db.fruit.update({"_id": 1}, {"$inc": {"size": 3}})


  - 增加数组的内容时，同时增加size的值


    db.fruit.update({"_id": 1}, {"$push" : {"fruits": "pear"}, "$inc" : {"size": 1}})


  - 最后就可以进行范围查找了


    db.fruit.find({"size": {"$gt": 3}})


##### 8.3.3、$slice


- 对查找到的数组进行切片处理，并返回新的切片后的文档


  - 使用$slice必须配合find函数的第二个参数使用，find的第二参数是指定文档中的键返回的，未提及或者对应值为0，将不会被返回，当使用$slice后，即使不提及文档中的其他键同样会返回


    ```mongo
    db.fruit.find({"_id" : 1}, {"fruits": 1})
    >{ "_id" : 1, "fruits" : [ "banana", "peach", "apple", "pear"]}  # 这里_id默认返回
    # 如果将_id的值变为0，则不会被返回
    db.fruit.find({"_id" : 1}, {"fruits": 1, "_id": 0})  # 数字代表真假
    >{"fruits" : [ "banana", "peach", "apple", "pear"]}
    # 当对返回的键使用切片后$slice，文档中所有的键默认都会返回
    db.fruit.find({"_id": 1}, {"fruit": {"$slice": 3}})
    >{ "_id" : 1, "fruits" : [ "banana", "peach", "apple" ], "size" : 4 }
    ```


- 对数组正向切割


  db.fruit.find({"_id": 1}, {"fruit": {"$slice": 3}}), $slcie对应的值是正数即可，得到数组的前三个元素


- 对数组反向切割


  db.fruit.find({"_id": 1}, {"fruit": {"$slice": -3}}), $slcie对应的值是负数即可，得到数组的后三个元素


- 对数组指定范围切片


  db.fruit.find({"_id": 1}, {"fruit": {"$slice": [1, 3]}})，$slice对应的值为数组，该数组表示你要操作的数组下标


  ，得到结果：**{ "_id" : 1, "fruits" : [ "peach", "apple", "pear" ], "size" : 4 }**，包含起始和结束下标


#### 8.4、查询内嵌文档


- 在mongodb中文档的表现形式，像极了javascript中的对象，所以可以通过**对象.属性**的方法，来访问MongoDB中的内嵌文档，但也可以匹配整个内嵌文档


- 方法一：如有文档


  {"name": {"first": "Joe", "last": "Schmoe"}, "age": 27}，在集合people中


  db.people.find({"name": {"first": "Joe", "last": "Schmoe"}})，这里可以找到有这个内嵌文档的文档，但是有一个缺点，就是查询条件必须匹配整个内嵌文档，否则就会匹配失败，同时顺序也不能够错，也就是要求精确匹配


- 方法二：通过**对象.属性**的方法来访问，就不存在限制了


  db.people.find({"name.first": "Joe", "name.last": "Schmoe"}),这里就要求精确匹配了


- $elemMatch


  将限定条件进行分组，仅当需要对一个内嵌文档的多个键操作时才会用到


  db.blog.find({"comments": {"$elemMatch": {"author": "joe", "score": {"$gte": 5}}}})


### 9、排序、分页和跳过


#### 9.1、排序sort


- 使用方法：db.collection.find().sort({"username": 1})


- 返回结果按升序排列，同时可以设置多个键排序


  db.collection.find().sort({"username":1, "age": -1})


  先以username升序排列，若username相同，则按照age降序排列


#### 9.2、分页limit


- 使用方法：


  db.collection.find().limit(20)，表示每页返回20条数据


#### 9.3、跳过skip


- db.collection.find().skip(20)，跳过前20个数据


**组合实现分页查询**


- db.collection.find().limit(20).sort({"age": -1})


  按照年龄从大到小取出前二十条文档


- db.collection.find().limit(20).skip(20).sort({"age": -1})


  跳过前20条，取后20条的结果


### 10、创建索引


- 方法：db.users.ensureindex({"username": 1})


### 11、游标对象


使用find函数返回的对象可以赋值给一个变量，这个变量就可以理解为是一个游标对象


**游标对象属性** ：可迭代(iterable)


**游标对象方法** ：hasNext()判断是否还有下一条数据


next()获取下一条数据


### 12、聚合函数(aggregate)


#### 12.1、count函数


db.stu.count()  # 返回fruit集合中的总文档数


现有如下集合mycol：


```javascript
{ "_id" : 1, "name" : "tom", "sex" : "男", "score" : 100, "age" : 34 }
{ "_id" : 2, "name" : "jeke", "sex" : "男", "score" : 90, "age" : 24 }
{ "_id" : 3, "name" : "kite", "sex" : "女", "score" : 40, "age" : 36 }
{ "_id" : 4, "name" : "herry", "sex" : "男", "score" : 90, "age" : 56 }
{ "_id" : 5, "name" : "marry", "sex" : "女", "score" : 70, "age" : 18 }
{ "_id" : 6, "name" : "john", "sex" : "男", "score" : 100, "age" : 31 }
```


#### 12.2、$group,$sum


db.stu.aggregate({$group:{_id: "$sex", Count: {"$sum": 1}}})


#### 12.3、$group,$push


```json
db.stu.aggregate(
     {$group:
         {
            _id:"$gender",
             name:{$push:"$name"}
         }
     }
)  把所有的数据放到一起
$$ROOT, 把整个文档放到一个数组中
db.stu.aggregate(
     {$group:
         {
             _id:null,
             name:{$push:"$$ROOT"}
         }
     }
)
```


#### 12.4、$match`


```json
db.stu.aggregate(
     {$match:{age:{$gt:20}}
     )
```


#### 12.5、$project


```json
db.stu.aggregate(
     {$project:{_id:0,name:1,age:1}}
     ) //控制显示的文档键
```


#### 12.6、$sort


```json
db.stu.aggregate(
     {$group:{_id:"$gender",counter:{$sum:1}}},
     {$sort:{counter:-1}}
)
```


#### 12.7、$limit,$skip


```json
db.stu.aggregate(
     {$group:{_id:"$gender",counter:{$sum:1}}},
     {$sort:{counter:-1}},
     {$skip:1},
     {$limit:1}
)
```


### 13、数据库命令(runCommand)


#### 13.1、distinct函数


db.runCommand({"distinct": "fruit" , "key": "fruits"})


runCommand指令表示运行命令，括号内的参数的第一个键为具体的指令，指令所对应的的值是要操作的集合，key对应的是要操作的键。


distinct所表达的意思是找出集合中某个键对应多少不同的值，也就是去重。


#### 13.2、group函数


- 对文档进行分组，stocks集合中有以下文档：


  db.stock.insert({"day" : "2010/10/03", "time": "10/03/2010 03:57:01 GMT-400", "price": "4.23"})


  db.stock.insert({"day" : "2010/10/04", "time": "10/04/2010 11:28:39 GMT-400", "price": "4.27"})


  db.stock.insert({"day" : "2010/10/03", "time": "10/03/2010 05:00:22 GMT-400", "price": "4.10"})


  db.stock.insert({"day" : "2010/10/06", "time": "10/06/2010 05:27:58 GMT-400", "price": "4.30"})


  db.stock.insert({"day" : "2010/10/04", "time": "10/04/2010 08:34:50 GMT-400", "price": "4.01"})


  获取到每天最新的股票交易价格


- 使用数据库命令的模式来执行group命令：


  ```javascript
  db.runCommand({"group":{
      "ns": "stock",
      "key": {"day": true},  // 程序执行到这里之后，就已经对集合分组完毕了
      "$keyf": function(X){
          return X.toLowerCase() // 将需要排序的键进行转换，比如进行大小写转换
      },
      "initial":{"time":0},  // 每组文档遍历时候的初始值
      "$reduce":function(doc, prev){
          if(doc.time>prev.time){  // 判断时间大小，更新要显示的最近时间
              prev.time = doc.time;
              prev.price= doc.price;
          }
      },
      "condition": {"day": {"$gt": "2010/10/03"}},// 对分组进行条件限制，必须大于条件时间
      "finalize":function(prev){  //对返回结果做最后的修改，和限定
          ...
      }
  }})
  ```


  **参数解析**


  group:对集合执行的操作，即分组


  ns：需要操作的数据集


  key：以文档中的哪个键进行分组


  $keyf: 对需要分组的键进行条件转换


  initial: 每组文档的初始化值，也就是最终分完组后显示的字段的初始化值


  $reduce: 对分组后的显示文档做最后的操作，在上述案例中，就是找到那一组文档中时间最新的文档，然后把他的时间和股票交易价格显示到我们可以看到的结果


  condition: 对分组进行条件限制


  finalize： 对返回的结果做最后的修改


  #### 13.3、findAndModify


  db.runCommand({"findAndModify": "stock",  # 操作集合stock


  ​        "query": {"day":{"$gt": "2010/09/30"}},    # 查询条件


  ​        "sort": {"day": -1},  # 排序键


  ​        "remove": true  # 是否删除文档true


  })


  #### 13.4、创建固定大小的集合


  db.creatCollection("my_collection",{"capped": true, "size": 100000})


  **参数解析**


  my_collection:集合名


  capped:表示是否限值集合的大小，true表示限值，false表示不限制


  size：表示集合大小，这里表示100000个字节

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2