MongoDB

时间 2019-11-19

标签 mongodb 栏目 MongoDB 繁體版

原文原文链接

MongoDB

本文很是长，共计12200词，请注意阅读时间，撰写四天时间，原创不易，转载请注明。python

1、概述

1.数据

可以输入到计算机中并被识别处理的信息集合c++

2. 数据结构

研究一个数据集合中，数据元素关系web

3. 数据库

按照数据结构，存储管理数据的仓库，数据仓库是在数据库管理系统控制下在必定介质中建立的算法

4.数据库管理系统

数据库管理软件sql

5.数据库系统

由数据库和数据库管理系统等构成的数据开发工具集合mongodb

2、关系与非关系

1. 关系型数据库

采用关系模型（二维表）来组织数据结构的数据库shell

Oracle、DB二、SQLServer、MySQL、SQLite数据库

优势编程

逻辑清晰，容易理解，结构相似于常见的表格
使用SQL语句，技术成熟，使用方便
关系型数据库比较成熟，可使用一些复杂的操做

缺点ubuntu

每次操做都须要专门的SQL解析
关系型数据库结构严格，内部加锁
在应对海量数据并发处理时读写速度差

2. 非关系型数据库

没有采用关系模型（二维表）来组织数据结构的数据库

键值型：Redis

列存储：HBase

文档型：MongoDB

图形：Graph

优势

读写速度快，能更好的针对并发处理
使用灵活，容易扩展

缺点

没有sql那样统一成熟的语句
技术程度较差，缺乏一些复杂的操做

应用场景

对数据结构要求不严格，比较灵活
对数据处理的速度，特别是海量数据的并发处理速度要求比较高
特定场景：须要灵活扩展，须要做为缓存

3、MongoDB

1. 特色

非关系型数据库，是属于文档型数据库
开源数据库，使用普遍
由c++编写的数据库管理系统
支持丰富的存储类型和数据操做
提供了丰富的编程语言接口
方便扩展和部署

2. 安装

Ubuntu：sudo apt-get install mongodb

Mac：brew install mongodb

Windows：www.mongodb.com

ubuntu安装位置：/var/lib/mongodb

配置文件：/etc/mongodb.conf

命令集：/usr/bin/

3. 基础命令

名称：mongodb shell

命令：mongo

退出：quit()

mongod 设置MongoDB的基本信息

mongod -h //查看帮助

mongod --dbpath [dir] //设置数据库存储位置

mongod --port [port] //设置数据库端口

*默认端口为27017

4、数据结构

数据组织结构：键值对-->文档-->集合-->数据库

例如：

MySQL

MongoDB

MySQL	MongoDB	含义
databases	databases	数据库
table	collection	表/集合
column	field	字段/域
row	document	记录/文档
index	index	索引

5、数据库操做

1. 数据库操做

use [database]建立数据库

use实际是选择使用哪一个数据库，当这个数据库不存在的时候，自动建立

可是不会当即创建，只有插入数据的时候才会真正创建

show dbs查看数据库

db.class.insert({"name":"Lily","age":"17"}) 插入简单的数据

db.dropDatabase() 删除当前数据库，在use以后执行，就会删除当前数据库

数据库命名规则

使用UTF-8字符串

不能含有空格``.``/``\``\0字符

不能超过64字节长度

不要和系统库重名

db表明当前正在使用的数据库，进入数据库默认使用`tes

2. 备份恢复

数据库的备份恢复

mongodump -h [host] -d [db] -o {path]备份

mongorestore -h [host:port] -d [db] [bak] 恢复

3. 运行监控

3.1 运行状态

mongostat 查看数据库运行状态（只要修改磁盘的都是写操做，查是读操做）

insert query update delete 每秒增查改删的次数

getmore

command 每秒执行MongoDB命令的次数

dirty

used

flushes每秒刷新磁盘的次数

vsize虚拟内存使用状况

res物理内存使用状况

qrw

arw

net_in

net_out

conn

time当前时间

3.2 读写时长

mongotop 查看数据库读写时长

2019-08-01T11:14:53.678+0800 connected to: 127.0.0.1
ns    total    read    write    2019-08-01T11:14:54+08:00
admin.system.roles      0ms     0ms      0ms
admin.system.version 0ms 0ms 0ms
config.system.sessions 0ms 0ms 0ms
local.startup_log 0ms 0ms 0ms
local.system.replset 0ms 0ms 0ms
stu.class 0ms 0ms 0ms
student.class 0ms 0ms 0ms

获得每一个集合在每秒以内的读写时间

6、集合操做

db.createCollection(collectionName) 建立集合

show collections或者show tables 查看集合

db.collection.insert(...) 插入数据（若是该集合不存在，则自动建立）

db.collection.drop() 删除集合

db.collection.renameCollection(NewName) 集合重命名

集合命名规则

使用UTF-8字符

不能含有'\0'

不要以system.开头，这是系统集合默认开头

不要和关键字重名

7、文档操做

1. 概述

文档是MongoDB中基本的数据组织单元

文档由键值对构成，每一个键值对表达一个数据项

MongoDB的文档属于bson类型数据

bson-->Json-->JavaScript

文档键值对特色

无序的
经过键值对取值
不能重复
键是UTF-8字符串，不能有\0字符

2. 数据类型

2.1 整型

int: 整数

2.2 浮点型

double : 小数

2.3 布尔

boolean : true/false

2.4 字符串

string : utf-8字符串

2.5 ObjectID

id对象

> db.class0.find()
{ "_id" : ObjectId("5d42519a1ae0b26ac7985b89"), "name" : "Lily", "age" : 17 }

其实质就是一串16进制，经过必定的算法，生成不重复的24位的16进制值

MongoDB插入文档时，每一个文档都要有一个_id与，能够本身指定一个不重复的值，也能够由系统自动生成

3.集合文档设计

一个集合中的文档能够有不一样的域，域的个数也能够不一致
集合中的文档层次不宜嵌套过多，若是层次过多时应考虑分为多个集合
在一个集合中的文档应该尽可能表达相同类型的数据类型

8、数据操做

1. 插入文档

db.collection.insertOne(doc)

功能：插入一条文档

参数：一条要插入的文档

> db.class0.insertOne({"name":"Lucy","age":18,"sex":"女"})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5d428df01bc9a3414430192e")
}

操做时，键能够不加引号

能够本身设置_id值，可是不能重复

db.collection.insertMany([{...},{...},{...}])

功能：插入多条文档

参数：数组中为多个文档

> db.class.insertMany([{name:'波多野结衣',age:33,sex:"女"},{name:"苍井空",age:36,sex:"
女"},{name:"麻生希",age:30,sex:"女" }])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5d42915d1bc9a34144301930"),
                ObjectId("5d42915d1bc9a34144301931"),
                ObjectId("5d42915d1bc9a34144301932")
        ]
}
> db.class.find()
{ "_id" : ObjectId("5d42915d1bc9a34144301930"), "name" : "波多野结衣", "age" : 33, "sex
" : "女" }
{ "_id" : ObjectId("5d42915d1bc9a34144301931"), "name" : "苍井空", "age" : 36, "sex" :
"女" }
{ "_id" : ObjectId("5d42915d1bc9a34144301932"), "name" : "麻生希", "age" : 30, "sex" :
"女" }

数组：使用[ ]表示的一组数据有序集合

特色：有序，使用序列号取值

练习

建立grade数据库

建立class集合

集合中插入若干数据项，格式以下

{name:xxx,age:xxx,sex:x,hobby:[xx,xx,xx]}

规则：年龄（7-15）、hobby（draw、dance、sing、football、basketball、computer、python）

use grade
db.class.insertOne(
    {name:"Chancey",age:18,sex:"男",hobby:["draw","dance","sing"]}
    )
db.class.insertMany([
    {name:"小红",age:18,sex:"女",hobby:["draw","python"]}, 
    {name:"小明",age:23,sex:"男",hobby:["sing","football"]},
    {name:"小花",age:35,sex:"女",hobby:["python","computer"]}, 
    {name:"小绿",age:22,sex:"女",hobby:["computer","draw"]},   
    ])

db.collection.insert()

功能：插入多条数据

参数：同insertOne + insertMany（能够是文档，也能够是数组里面嵌套文档）

官方已经不太推荐，因此使用上述两种方法插入数据更为稳定

db.collection.save()

功能：插入一条或者多条文档

参数：同insert

db.class0.save({name:'Alex',age:18,sex:"男"})

db.class0.save([
    {name:"小花",age:35,sex:"女",hobby:["python","computer"]}, 
    {name:"小绿",age:22,sex:"女",hobby:["computer","draw"]}
    ])

当_id冲突的时候，save则会覆盖掉已经存在的记录

2. 查询文档

2.1 find

db.clooect.find(query,field)

功能：查找全部的符合条件的文档

参数：query（要查找的文档）、field（要查找的域）

返回值：返回全部查找到的文档

参数使用方法

2.1.1 query

是一个键值对文档{}，空则表示查找全部

以键值对表示筛选条件，每每配合查找操做符完成

2.1.2 field

是一个键值对文档{}，field：0表示不查找这个域，field：1表示查找这个域

> db.class0.find({age:18},{name:1,age:1})
{ "_id" : ObjectId("5d428df01bc9a3414430192e"), "name" : "Lucy", "age" : 18 }
{ "_id" : ObjectId("5d42a1621bc9a3414430193b"), "name" : "Alex", "age" : 18 }
> db.class0.find({age:18},{_id:0})
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
> db.class0.find({age:18},{_id:0,sex:0})
{ "name" : "Lucy", "age" : 18 }
{ "name" : "Alex", "age" : 18 }
> db.class0.find({age:18},{_id:0,age:1,sex:1})
{ "age" : 18, "sex" : "女" }
{ "age" : 18, "sex" : "男" }

_id域若是不想查找，则_d:0

其余域要么全为0，要么全为1

2.2 findOne

db.collection.findOne(query,field)

功能：查找第一个符合条件的文档

参数：同find

返回值：返回查找到的文档

> db.class.findOne()
{
        "_id" : ObjectId("5d42915d1bc9a34144301930"),
        "name" : "波多",
        "age" : 33,
        "sex" : "女"
}
> db.class0.findOne({age:18})
{
        "_id" : ObjectId("5d428df01bc9a3414430192e"),
        "name" : "Lucy",
        "age" : 18,
        "sex" : "女"
}
> db.class0.findOne({age:20},{_id:0})
{ "name" : "素心", "age" : 20, "sex" : "男" }

若是没有参数则默认查找全部记录的第一条

2.3 query操做符

操做符：MongoDB中使用$注明的一个有特殊意义的字符串，用以表达丰富的含义，好比：$lt表示小于

2.3.1 比较操做符

序号	字符	汉义	符号
1	$eq	等于	=
2	$lt	小于	<
3	$gt	大于	>
4	$lte	小于等于	<=
5	$gte	大于等于	>=
6	$ne	不等于	!=
7	$in	包含
8	$nin	不包含

#查找年龄为20的
> db.class0.find({age:{$eq:20}},{_id:0}) 
{ "name" : "素心", "age" : 20, "sex" : "男" }
> db.class0.find({sex:{$eq:"女"}},{_id:0})
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }

#查找年龄小于16的
> db.class0.find({age:{$lt:16}},{_id:0}) 
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }

#查找年龄大于17切小于20的（区间查找）
> db.class0.find({age:{$gt:17,$lt:20}},{_id:0}) 
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }

#查找年龄小于等于13的
> db.class0.find({age:{$lte:13}},{_id:0})
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }

#查找年龄大于等于20的
> db.class0.find({age:{$gte:20}},{_id:0})
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }

#查找年龄不等于13的
> db.class0.find({age:{$ne:13}},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

# 查找年龄等于1三、1六、20的
> db.class0.find({age:{$in:[13,16,20]}},{_id:0})
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }

#查找年龄不等于1三、1六、20的
> db.class0.find({age:{$nin:[13,16,20]}},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

包含的关系的写法

在$ne的值里面填写数组，表示以该数组为集合查找任意符合条件的记录

2.3.2 逻辑操做符

序号	字符	汉义
1	$and	与
2	$or	或
3	$not	非
4	$nor	既不也不

# 查找年龄大于17且为男的
> db.class0.find({$and:[{age:{$gt:17}},{sex:"男"}]},{_id:0})
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
# 查找姓名小于Lily且年龄为17,19,21的
> db.class0.find({$and:[{name:{$lt:"Lily"}},{age:{$in:[17,19,21]}}]},{_id:0})
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

#查找年龄大于18或性别为女
> db.class0.find({$or:[{age:{$gt:18}},{sex:{$eq:"女"}}]},{_id:0})
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
#查找年龄小于18或大于19
> db.class0.find({$or:[{age:{$lt:18}},{age:{$gt:19}}]},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

#查找年龄不大于18的
> db.class0.find({age:{$not:{$gt:18}}},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

#查找年龄不大于18性别也不为男
> db.class0.find({$nor:[{age:{$gt:18}},{sex:{$eq:"男"}}]},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }

使用逻辑操做符的时候，在特殊符号的值应为数组，数组里面包含条件

$not的格式与三目运算不同，注意

2.3.3 混合查询

#年龄大于等于17的男生，或者名字叫Addy或者Emmm
> db.class0.find({$or:[{$and:[{age:{$gt:17}},{sex:{$eq:"男"}}]},{$or:[{name:"Addy"},{na me:"Emmm"}]}]},{_id:0})
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }

2.3.4 数组操做符

查找数组中包含元素

# 查找score数组大于90的记录
> db.class2.find({score:{$gt:90}},{_id:0})
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }

当键对应的值为一个数组的时候，query填入一个包含关系的元素便可查找

查找数组中同时包含多项

$all

# 查找既包含87，又包含89的
> db.class2.find({score:{$all:[87,89]}},{_id:0})
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }

根据数组的元素个数查找

$size

查找数组元素个数为3的记录
> db.class2.find({score:{$size:3}},{_id:0})
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 90, 79, 90 ] }

切片操做

用于field参数，表示查找数组哪些项

$slice

# 查找指定数组的前两项
> db.class2.find({},{_id:0,score:{$slice:2}})
{ "name" : "小明", "age" : 10, "score" : [ 87, 69 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 90, 79 ] }
# 跳过前一项，查看以后的两项
> db.class2.find({},{_id:0,score:{$slice:[1,2]}})
{ "name" : "小明", "age" : 10, "score" : [ 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 79, 90 ] }

能够指定哪些数组显示哪些元素

[m,n]表示跳过m项，查询m项以后的n项元素

若是超过数组元素个数，则显示最多的元素

经过索引查找

query中域名.序列号表示查找该数组某元素指定值的范围

# 查找socre下第1项大于80的记录
> db.class2.find({"score.1":{$gt:80}},{_id:0})
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }

数组序列号也是从0开始数

2.3.5 其余操做符

$exists 判断一个域是否存在

# 查找age域的全部文档
> db.class2.find({age:{$exists:true}},{_id:0})
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 90, 79, 90 ] }

$mod 根据除数余数筛选

# 查找年龄为奇数的文档
> db.class0.find({age:{$mod:[2,1]}},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

mod:[m,n]表示该数除以m，余n的文档

$type 根据类型筛选

> db.class0.find({age:{$type:2}},{_id:0})
> db.class0.find({age:{$type:1}},{_id:0})
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

数组能够嵌套，即{$type:90}

2.4. 数据操做函数

2.4.1 范围值

db.collection.distinct(field)

功能：获取集合中某个域的值范围

参数：域名

返回值：取值的范围数组

# 查找class0的age域有哪些值
> db.class0.distinct("age")
[ 17, 18, 20, 13, 21 ]
# 查找class0的sex域有哪些值
> db.class0.distinct("sex")
[ "女", "男" ]

2.4.2 格式化显示

pretty()

功能：将查询结果格式化显示

> db.class0.find({},{_id:0}).pretty()
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

2.4.3 限制显示

limit

功能：显示查询结果前n条

# 只显示前三条信息
> db.class0.find({},{_id:0}).limit(3)
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }

2.4.4 跳页显示

skip(n)

跳过前n条，显示后边的文档

> db.class0.find({},{_id:0}).skip(6)
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }

2.4.5 统计数量

count()

功能：统计查询结果数量

# 统计全部文档
> db.class0.find({},{_id:0}).count()
9

2.4.6 排序

sort({field:1/-1})

功能：对查找结果排序

参数：field表示排序的域，1升序、-1降序

> db.class0.find({},{_id:0}).skip(5).sort({age:1})
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }

> db.class0.find({},{_id:0}).skip(5).sort({age:-1})
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }

复合排序

> db.class0.find({},{_id:0}).skip(5).sort({age:-1,name:-1})
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }

2.4.7 函数连续调用

> db.class0.find({age:{$type:1}},{_id:0}).sort({afe:-1}).limit(3)
{ "name" : "Lily", "age" : 17 }
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }

2.4.8 序列号

经过序列号直接获取文档集合中的某一个

# 获取文档集合的第一项
> db.class0.find({},{_id:0}).sort({age:1})[0]
{ "name" : "Emmm", "age" : 13, "sex" : "男" }

4. 修改文档

4.1 修改函数

4.1.2 updateOne

db.collection.updateOne(query,update,upsert)

功能：修改第一个符合条件的文档

参数：查找条件、要修改的数据，同修改操做符一块儿使用、若是query没有筛选到文档，是否插入新的文档

update 键值对文档，表达将数据修改成什么样子

# 将name为小峰的age修改成16
db.class.updateOne({name:"小峰"},{$set:{age:16}})

upset 若是没有匹配到文档，则决定是否建立新的文档，默认false

> db.class.find({},{_id:0})
{ "name" : "小娅", "age" : 9, "sex" : "女", "hobby" : [ "draw", "football" ] }
> db.class.updateOne({name:"waller"},{$set:{age:16}},{upsert:true})
{
        "acknowledged" : true,
        "matchedCount" : 0,
        "modifiedCount" : 0,
        "upsertedId" : ObjectId("5d43ec85e7bb29c632f30a0d")
}
> db.class.find({},{_id:0})
{ "name" : "小娅", "age" : 9, "sex" : "女", "hobby" : [ "draw", "football" ] }
{ "name" : "waller", "age" : 16 }

4.1.3 updateMany

db.collection.updateMany(query,update,upsert)

功能：修改全部符合条件的文档

参数：同updateOne

# 将字符串的年龄修改成数字类型的年龄18
> db.class0.find({},{_id:0})
{ "name" : "waller", "age" : "\"20\"", "sex" : "男" }
{ "name" : "Mary", "age" : "\"18\"", "sex" : "男" }
> db.class0.updateMany({age:{$type:2}},{$set:{age:18}})
{ "acknowledged" : true, "matchedCount" : 2, "modifiedCount" : 2 }
> db.class0.find({},{_id:0})
{ "name" : "waller", "age" : 18, "sex" : "男" }
{ "name" : "Mary", "age" : 18, "sex" : "男" }

4.1.4 update

db.collection.update(query,update,upsert,multi)

功能：修改文档（可单一修改，也可多条修改）

参数：同、同、upsert=true等同于{upsert:true}、默认只修改一个文档（true为修改全部符合条件的文档）

upsert和multi的格式直接填写true或者false

> db.class0.update({name:"Jack"},{$set:{age:16}},true,true)
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 1,
        "nModified" : 0,
        "_id" : ObjectId("5d43f0bee7bb29c632f30ab6")
})
> db.class0.find({},{_id:0})
{ "name" : "waller", "age" : 18, "sex" : "男" }
{ "name" : "Mary", "age" : 18, "sex" : "男" }
{ "name" : "Jack", "age" : 16 }

官方已经不推荐使用该方式插入数据，更加偏向于updateOne、updateMany

4.1.5 findOneAndUpdate

db.collection.findOneAndUpdate(query,update)

功能：查找到一个文档并修改

参数：查找条件、修改数据

返回值：修改以前的文档

> db.class0.find({},{_id:0})
{ "name" : "waller", "age" : 18, "sex" : "男" }
> db.class0.findOneAndUpdate({name:"waller"},{$set:{age:19}})
{
        "_id" : ObjectId("5d43eef44f5000004c0054f2"),
        "name" : "waller",
        "age" : 18,
        "sex" : "男"
}
> db.class0.find({},{_id:0})
{ "name" : "waller", "age" : 19, "sex" : "男" }

4.1.6 findOneAndReplace

db.collection.findOneAndReplace(query,doc)

功能：查找一个文档并替换之

参数：查找条件、新的文档

返回值：原来的文档

> db.class0.find({},{_id:0})
{ "name" : "Lily", "age" : 17 }
> db.class0.findOneAndReplace({name:"Lily"},{name:"ame",age:17,sex:"女"})
{
        "_id" : ObjectId("5d42519a1ae0b26ac7985b89"),
        "name" : "Lily",
        "age" : 17
}
> db.class0.find({},{_id:0}) 
{ "name" : "ame", "age" : 17, "sex" : "女" }

4.2 修改器

4.2.1 set

$set：修改一个域的值或者增长一个域

# 修改一个域
> db.class0.find({},{_id:0}) 
{ "name" : "小小", "age" : 18 }
{ "name" : "waller", "age" : 19, "sex" : "男" }
{ "name" : "Mary", "age" : 18, "sex" : "男" }
{ "name" : "Jack", "age" : 16 }
> db.class0.updateOne({sex:{$exists:false}},{$set:{sex:"男"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class0.find({},{_id:0})
{ "name" : "小小", "age" : 18, "sex" : "男" }
{ "name" : "waller", "age" : 19, "sex" : "男" }
{ "name" : "Mary", "age" : 18, "sex" : "男" }
{ "name" : "Jack", "age" : 16 }

#修改多个域
 @(shell):1:33
> db.class0.find({},{_id:0}) 
{ "name" : "Lucy", "age" : 18, "sex" : "女" }
> db.class0.updateOne({name:"Lucy"},{$set:{age:20,sex:"男"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class0.find({},{_id:0}) 
{ "name" : "Lucy", "age" : 20, "sex" : "男" }

4.2.2 unset

$unset删除一个域

> db.class0.find({},{_id:0})                                 )
{ "name" : "Lucy", "age" : 20, "sex" : "男" }
> db.class0.updateOne({name:"Lucy"},{$unset:{sex:""}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class0.find({},{_id:0})
{ "name" : "Lucy", "age" : 20 }

当修改以后的域名为空时，即表示删除该域，注意使用$unset

4.2.3 rename

$rename重命名域

> db.class0.find({},{_id:0})
{ "name" : "ame", "age" : 17, "sex" : "女" }
{ "name" : "Lucy", "age" : 20 }
{ "name" : "Chancey", "age" : 17, "sex" : "女" }
{ "name" : "素心", "age" : 20, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Emmm", "age" : 13, "sex" : "男" }
{ "name" : "Abby", "age" : 21, "sex" : "男" }
{ "name" : "Alex", "age" : 18, "sex" : "男" }
{ "name" : "Alex", "age" : 17, "sex" : "男" }
{ "name" : "小小", "age" : 18, "sex" : "男" }
{ "name" : "waller", "age" : 19, "sex" : "男" }
{ "name" : "Mary", "age" : 18, "sex" : "男" }
{ "name" : "Jack", "age" : 16 }
{ "name" : "xx", "age" : 35 }
> db.class0.updateMany({},{$rename:{sex:"gender"}})
{ "acknowledged" : true, "matchedCount" : 14, "modifiedCount" : 11 }
> db.class0.find({},{_id:0})
{ "name" : "ame", "age" : 17, "gender" : "女" }
{ "name" : "Lucy", "age" : 20 }
{ "name" : "Chancey", "age" : 17, "gender" : "女" }
{ "name" : "素心", "age" : 20, "gender" : "男" }
{ "name" : "Emmm", "age" : 13, "gender" : "男" }
{ "name" : "Emmm", "age" : 13, "gender" : "男" }
{ "name" : "Abby", "age" : 21, "gender" : "男" }
{ "name" : "Alex", "age" : 18, "gender" : "男" }
{ "name" : "Alex", "age" : 17, "gender" : "男" }
{ "name" : "小小", "age" : 18, "gender" : "男" }
{ "name" : "waller", "age" : 19, "gender" : "男" }
{ "name" : "Mary", "age" : 18, "gender" : "男" }
{ "name" : "Jack", "age" : 16 }
{ "name" : "xx", "age" : 35 }

4.2.4 setOneInsert

$setOneInsert若是使用update*执行了插入文档操做，则做为插入的内容

# 若是执行了插入函数，则setOnInsert也会插入
> db.class0.find({},{_id:0})
{ "name" : "ame", "age" : 17, "gender" : "女" }
{ "name" : "Davil", "age" : 18, "gender" : "m" }
> db.class0.updateOne({name:"Davil"},{$set:{age:18},$setOnInsert:{gender:"m"}},{upsert:true})
{
        "acknowledged" : true,
        "matchedCount" : 0,
        "modifiedCount" : 0,
        "upsertedId" : ObjectId("5d43fb43e7bb29c632f30c02")
}
> db.class0.find({},{_id:0})
{ "name" : "ame", "age" : 17, "gender" : "女" }
{ "name" : "Davil", "age" : 18, "gender" : "m" }

uodate参数可使用多个修改器

语句：db.class0.updateOne({name:"Davil"},{$set:{age:18},$setOnInsert:{gender:"m"}},{upsert:true})

若是执行了upsert，则会连同setOnInsert的内容也会插入

4.2.5 inc

$inc加法修改器

功能：指定域加指定数

# 给age统统加1
> db.class.find({},{_id:0})
{ "name" : "波多", "age" : 33, "sex" : "女" }
{ "name" : "苍空", "age" : 36, "sex" : "女" }
{ "name" : "麻希", "age" : 30, "sex" : "女" }
> db.class.updateMany({},{$inc:{age:1}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
> db.class.find({},{_id:0})
{ "name" : "波多", "age" : 34, "sex" : "女" }
{ "name" : "苍空", "age" : 37, "sex" : "女" }
{ "name" : "麻希", "age" : 31, "sex" : "女" }

能够加整数、小数、负数、正数

注意：负数其实就是减法

4.2.6 mul

$mul 乘法修改器

# 给全部人年龄乘以2
> db.class.find({},{_id:0})
{ "name" : "波多", "age" : 34, "sex" : "女" }
{ "name" : "苍空", "age" : 37, "sex" : "女" }
{ "name" : "麻希", "age" : 31, "sex" : "女" }
> db.class.updateMany({},{$mul:{age:0.5}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
> db.class.find({},{_id:0})
{ "name" : "波多", "age" : 17, "sex" : "女" }
{ "name" : "苍空", "age" : 18.5, "sex" : "女" }
{ "name" : "麻希", "age" : 15.5, "sex" : "女" }

能够加整数、小数、负数、正数

4.2.7 max

$max修改某个域的值，若是小于指定值则改成指定值，大于则不变

> db.class.find({},{_id:0})
{ "name" : "波多", "age" : 17, "sex" : "女" }
{ "name" : "苍空", "age" : 18.5, "sex" : "女" }
{ "name" : "麻希", "age" : 15.5, "sex" : "女" }
# 若是age域小于30改成30，大于则不变
> db.class.updateMany({sex:"女"},{$max:{age:30}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
> db.class.find({},{_id:0})
{ "name" : "波多", "age" : 30, "sex" : "女" }
{ "name" : "苍空", "age" : 30, "sex" : "女" }
{ "name" : "麻希", "age" : 30, "sex" : "女" }

简记：能把小的改为大的

4.2.7 min

$min修改某个域的值，若是大于指定值则改成指定值，小于则不变

> db.class.find({},{_id:0}) 
{ "name" : "波多", "age" : 30, "sex" : "女" }
{ "name" : "苍空", "age" : 30, "sex" : "女" }
{ "name" : "麻希", "age" : 30, "sex" : "女" }
> db.class.updateMany({sex:"女"},{$min:{age:18}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
> db.class.find({},{_id:0}) 
{ "name" : "波多", "age" : 18, "sex" : "女" }
{ "name" : "苍空", "age" : 18, "sex" : "女" }
{ "name" : "麻希", "age" : 18, "sex" : "女" }

简记：能把大的改为小的

4.2.8 数组修改器

(1) push

$push 向数组中添加一项

# 给小红添加一项10分的成绩
> db.class2.find({},{_id:0})
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 90, 79, 90 ] }
> db.class2.updateOne({name:"小红"},{$push:{score:10}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0})
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87, 10 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 90, 79, 90 ] }

(2) pushAll

$pushAll 向数组中添加多项

# 向小红添加88,98的成绩

(3) pull

$pull 从数组中删除某个值

# 删除小刚score中的90

(4)pullAll

$puAll同时删除数组中多个组

# 删除小刚的79,90
> db.class2.find({},{_id:0})                         })
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87, 10 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 90, 79, 90 ] }
> db.class2.updateOne({name:"小刚"},{$pullAll:{score:[79,90]}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0})                                 })
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87, 10 ] }
{ "name" : "小刚", "age" : 9, "score" : [ ] }

(5) pop

$pop弹出数组中的一项

# 弹出小红的最后一项
> db.class2.updateOne({name:"小红"},{$pop:{score:1}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0})                       })
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 97, 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ ] }
# 弹出小红的第一项
> db.class2.updateOne({name:"小红"},{$pop:{score:-1}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0})                        })
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ ] }

弹出相似于删除

可是弹出只能删除两端的内容

若是为1则弹出数组中最后一项，为-1则弹出第一项

(6) addToSet

addToSet 向数组中添加一项，但不能和已有的数值重复

> db.class2.find({},{_id:0})                        })
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ ] }
> db.class2.updateOne({name:"小刚"},{$addToSet:{score:80}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0})                             })
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 80 ] }

(7) each

$each对多个值逐一操做

# 对90,10 都执行操做
>db.class2.updateOne({name:"小红"},{$push:{$each:[10,90]}})

(8) position

$position 指定数组插入位置，配合$each使用

# 将90插入到索引1位置
> db.class2.updateOne({name:"小刚"},{$push:{score:{$each:[90],$position:1}}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0})
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 80, 90 ] }

(9) sort

$sort给数组排序，配合$each使用

# 给score从按照降序排序
> db.class2.updateOne({name:"小红"},{$push:{score:{$each:[],$sort:-1}}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.class2.find({},{_id:0}) 
{ "name" : "小明", "age" : 10, "score" : [ 87, 69, 81 ] }
{ "name" : "小红", "age" : 9, "score" : [ 89, 87 ] }
{ "name" : "小刚", "age" : 9, "score" : [ 80, 90 ] }

-1为降序。1为升序

5. 删除文档

5.1 删除函数

5.1.1 deleteOne

db.collection.deleteOne(query)

功能：删除第一个符合条件的文档

参数：筛选条件

# 删除第一个不存在性别域的文档
db.class.deleteOne({sex:{$exsits:false}})

5.1.2 deleteMany

db.collection.deleteMany(query)

功能：删除全部

# 删除全部小于18岁的
> db.class.find({},{_id:0})
{ "name" : "小红", "age" : 9, "sex" : "女", "hobby" : [ "dance", "draw" ] }
{ "name" : "小明", "age" : 24, "hobby" : [ "football", "sing" ] }
{ "name" : "小花", "age" : 36, "sex" : "女", "hobby" : [ "python", "computer" ] }
{ "name" : "小绿", "age" : 23, "sex" : "女", "hobby" : [ "computer", "draw" ] }
{ "name" : "小兰", "age" : 17, "sex" : "女", "hobby" : [ "sing", "draw" ] }
{ "name" : "小黄", "age" : 21, "sex" : "男", "hobby" : [ "python", "draw" ] }
{ "name" : "小黑", "age" : 17, "sex" : "男", "hobby" : [ "football", "pthon" ] }
{ "name" : "Chancey", "age" : 9, "sex" : "男", "hobby" : [ "computer", "python" ] }
{ "name" : "小娅", "age" : 10, "sex" : "女", "hobby" : [ "draw", "football" ] }
{ "name" : "小刚", "age" : 13, "sex" : "男", "hobby" : [ "draw", "football" ] }
> db.class.deleteMany({age:{$lt:18}})
{ "acknowledged" : true, "deletedCount" : 12 }
> db.class.find({},{_id:0})
{ "name" : "Chancey", "age" : 19, "sex" : "男", "hobby" : [ "draw", "dance", "sing" ] }
{ "name" : "小明", "age" : 24, "hobby" : [ "football", "sing" ] }
{ "name" : "小花", "age" : 36, "sex" : "女", "hobby" : [ "python", "computer" ] }
{ "name" : "小绿", "age" : 23, "sex" : "女", "hobby" : [ "computer", "draw" ] }
{ "name" : "小黄", "age" : 21, "sex" : "男", "hobby" : [ "python", "draw" ] }

{}表示删除全部文档

即 db.class.deleteMany({})

5.1.3 remove

db.collection.remove(query,justOne)

功能：删除文档

参数：筛选条件、默认false，删除全部符合条件的文档，true只删除一个符合条件的文档

5.1.4 findOneAndDelete

db.collection.findOneAndDelete(query)

功能：查找一个文档并删除

参数：查找条件

返回：查找到的文档

# 查找Levi并删除
>db.class0.findAndDelete({name:"Levi"})

6. 练习（查询）

"_id","age","hobby","name","sex"
"5d4294091bc9a34144301933","18","[ ""draw"", ""dance"", ""sing"" ]","Chancey","男"
"5d4296a91bc9a34144301934","18","[ ""draw"", ""python"" ]","小红","女"
"5d4296a91bc9a34144301935","23","[ ""sing"", ""football"" ]","小明","男"
"5d4296a91bc9a34144301936","35","[ ""python"", ""computer"" ]","小花","女"
"5d4296a91bc9a34144301937","22","[ ""computer"", ""draw"" ]","小绿","女"
"5d43dbb4a5755f70bb10b68a","16","[ ""sing"", ""draw"" ]","小兰","女"
"5d43dbb4a5755f70bb10b68b","20","[ ""python"", ""draw"" ]","小黄","男"
"5d43dbb4a5755f70bb10b68c","16","[ ""football"", ""pthon"" ]","小黑","男"
"5d43dbb4a5755f70bb10b68d","6","[ ""basketball"", ""computer"" ]","小峰","男"
"5d43dbb4a5755f70bb10b68e","9","[ ""basketball"", ""python"", ""football"" ]","小浩","男"
"5d43dbb4a5755f70bb10b68f","10","[ ""sing"", ""draw"", ""computer"" ]","小娜","女"

查看班级中全部人信息

db.class.find({},{_id:0})
查看班级中年龄8岁的人员信息

db.class.find({age:{$eq:8}},{_id:0})

db.class.find({age:8},{_id:0})
查看年龄大于10岁的学生信息

db.class.find({age:{$gt:10}},{_id:0})
查看年龄在8-12岁之间的学生信息

db.class.find({$and:[{age:{$gt:7}},{age:{$lt:13}}]},{_id:0})

db.class.find($and:[{age:{$gte:8}},{age:{$lte:12}}],{_id:0})
查看年龄为9岁且喜欢画画的女生

db.class.find({age:9,sex:"女",hobby:"draw"},{_id:0})
查看年龄小于8岁大于12岁的同窗

db.class.find({$or:[{age:{$lt:8}},{age:{$gt:12}}]},{_id:0})
查看年龄9岁或者11岁的学生信息

db.class.find({$or:[{age:9},{age:11}]},{_id:0})

db.class.find({age:{$in:[9,11]}},{_id:0})
查看有两项兴趣爱好的学生

db.class.find({hobby:{$size:2}},{_id:0})
查找喜欢计算机的同窗

db.class.find({hobby:"computer"},{_id:0})
查找既喜欢画画也喜欢跳舞的同窗

db.class.find({$and:[{hobby:"draw"},{hobby:"dance"}]},{_id:0})

db.class.find({hobby:{$all:["draw","dance"]}},{_id:0})
统计兴趣爱好有3项的学生信息

db.class.find({hobby:{$size:3}},{_id:0})
找到班级中年龄第二大的同窗

db.class.find({},{_id:0}).sort({age:-1})[1]
找到班级中年龄最终小的三位女生

db.class.find({sex:'女'},{_id:0}).sort({age:1}).limit(3)

7. 练习（修改）

使用grade

将小红年龄修改成8岁，兴趣爱好改成跳舞画画

db.class.updateOne({name:"小红"},{$set:{age:8,hobby:["dance","draw"]}})
小明多了一个兴趣爱好唱歌

db.class.updateOne({name:"小明"},{$push:{hobby:"sing"}})
小王兴趣爱好多个吹牛、打篮球

db.class.updateOne({name:"小王"},{$push:{hobby:["吹牛","basketball"]}})
小李兴趣增长跑步，可是确保不和之前的重复

db.class.updateOne({name:"小李"},{$addToSet:{hobby:{$each:["tunning","sing"]}}})
班级全部同窗年龄增长1

db.class.updateMany({},{$inc:{age:1}})
删除小明的sex属性

db.class.updateOne({name:"小明"},{$unset:{sex:''}})
小李第一个兴趣爱好不要了

db.class.updateOne({name:"小明"},{$pop:{hobby:-1}})
小刚不喜欢画画了

db.class.update({name:"小刚"},{$pullAll:{hobby:["doraw","computer"]}})

8.练习（删除）

删除全部年龄小于8岁或者大于2岁的同窗

db.class0.deleteMany({$or:[{age:{$lt:8}},{age:{$gt:12}}]})
删除兴趣爱好中除了画画或者跳舞的同窗

db.class,deleteMany({hobby:{$nin:["draw","dance"]}})

9、时间类型

1.1 获取当前时间

new Date()自动生成当前时间（标准时间）

> db.class1.find({},{_id:0}) 
{ "name" : "python入门", "date" : ISODate("2019-08-03T08:05:20.409Z") }
{ "name" : "python精通", "date" : ISODate("2019-08-03T08:13:59.146Z") }

1.2 时间函数

ISODate()

功能：将指定的时间转换为标准时间存入

参数：默认同new Date(0)获取当前时间或者字符定制时间

# 传入指定的时间
> db.class1.insert({name:"python从入门到精通",date:ISODate()}))
WriteResult({ "nInserted" : 1 })
> db.class1.find({},{_id:0}) 
{ "name" : "python入门", "date" : ISODate("2019-08-03T08:05:20.409Z") }
{ "name" : "python精通", "date" : ISODate("2019-08-03T08:13:59.146Z") }
{ "name" : "python从入门到精通", "date" : ISODate("2019-08-03T08:17:31.467Z") }
> db.class1.insert({name:"疯狂的python",date:ISODate("2019-01-01 08:08:08")})
WriteResult({ "nInserted" : 1 })
> db.class1.find({},{_id:0}) 
{ "name" : "python入门", "date" : ISODate("2019-08-03T08:05:20.409Z") }
{ "name" : "python精通", "date" : ISODate("2019-08-03T08:13:59.146Z") }
{ "name" : "python从入门到精通", "date" : ISODate("2019-08-03T08:17:31.467Z") }
{ "name" : "疯狂的python", "date" : ISODate("2019-01-01T08:08:08Z") }

"2019-01-01 08:08:08"

"20190101 8:8:8"

"20190101"

1.3 时间戳

valueOf()

功能：将标准化时间转化为时间戳

# 将标准时间转换为时间戳
> db.class1.insertOne({book:"Python涅槃",date:ISODate().valueOf()})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5d45443bac70897becf59e7e")
}
> db.class1.find({},{_id:0})
{ "name" : "python入门", "date" : ISODate("2019-08-03T08:05:20.409Z") }
{ "name" : "python精通", "date" : ISODate("2019-08-03T08:13:59.146Z") }
{ "name" : "python从入门到精通", "date" : ISODate("2019-08-03T08:17:31.467Z") }
{ "name" : "疯狂的python", "date" : ISODate("2019-01-01T08:08:08Z") }
{ "book" : "Python涅槃", "date" : 1564820539435 }

1.4 null类型

值：null

含义：空

表示某个域的值为空

> db.class1.insertOne({book:"python web",price:null})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5d454529ac70897becf59e7f")
}
> db.class1.find({},{_id:0})
{ "book" : "python web", "price" : null }

在查找的时候，若是用price域查找，没有price域的也会被查找出来

# 查找到price域为null或者没有该域的
> db.class1.find({price:null},{_id:0})
{ "name" : "python入门", "date" : ISODate("2019-08-03T08:05:20.409Z") }
{ "name" : "python精通", "date" : ISODate("2019-08-03T08:13:59.146Z") }
{ "name" : "python从入门到精通", "date" : ISODate("2019-08-03T08:17:31.467Z") }
{ "name" : "疯狂的python", "date" : ISODate("2019-01-01T08:08:08Z") }
{ "book" : "Python涅槃", "date" : 1564820539435 }
{ "book" : "python web", "price" : null }

1.5 内部文档

也称Object类型

> db.calss3.insertOne({"book":"xi you ji ",intro:{author:"wu cheng en",price:38.6,publication:"China"}})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5d45476cac70897becf59e80")
}
> db.calss3.insertOne({"book":"san guo yan yi",intro:{author:"luo guan zhong",price:42.6,publication:"China"}})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5d45478aac70897becf59e81")
}
> db.calss3.insertOne({"book":"shui hu zhuan",intro:{author:"shi nai an",price:48,publication:"China"}})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5d4547a3ac70897becf59e82")
}
> db.calss3.find({},{_id:0})
{ "book" : "xi you ji ", "intro" : { "author" : "wu cheng en", "price" : 38.6, "publication" : "China" } }
{ "book" : "san guo yan yi", "intro" : { "author" : "luo guan zhong", "price" : 42.6, "publication" : "China" } }
{ "book" : "shui hu zhuan", "intro" : { "author" : "shi nai an", "price" : 48, "publication" : "China" } }

定义：文档中某个域的值为内部文档，则该值为Object类型数据

使用方法：当使用内部文档某个域的值时，须要采用"外部域.内部域"的方法，此时，该格式须要用引号表示为字符串

# 内部文档查找
> db.calss3.find({"intro.author":"wu cheng en"},{_id:0})
{ "book" : "xi you ji ", "intro" : { "author" : "wu cheng en", "price" : 38.6, "publication" : "China" } }
> db.calss3.find({"intro.publication":"China"},{_id:0})
{ "book" : "xi you ji ", "intro" : { "author" : "wu cheng en", "price" : 38.6, "publication" : "China" } }
{ "book" : "san guo yan yi", "intro" : { "author" : "luo guan zhong", "price" : 42.6, "publication" : "China" } }
{ "book" : "shui hu zhuan", "intro" : { "author" : "shi nai an", "price" : 48, "publication" : "China" } }

# 内部文档修改
> db.calss.updateOne({book:"xi you ji "},{$set:{"intro.price":42}})
{ "acknowledged" : true, "matchedCount" : 0, "modifiedCount" : 0 }
> db.calss3.find({},{_id:0})
{ "book" : "xi you ji ", "intro" : { "author" : "wu cheng en", "price" : 38.6, "publication" : "China" } }
{ "book" : "san guo yan yi", "intro" : { "author" : "luo guan zhong", "price" : 42.6, "publication" : "China" } }
{ "book" : "shui hu zhuan", "intro" : { "author" : "shi nai an", "price" : 48, "publication" : "China" } }

1.6 练习

将小红爱好的第二项变为唱歌

db.class.updateOne({name:"xiao hong"},{$set:{'hobby.1':"sing"}})
给小王增长一个域

备注：{民族：“回族”，习俗：“注意饮食禁忌”}

db.class.updateOne({name:"xiao hong"},{$set:{'备注':{"民族":"回族","习俗":"注意饮食禁忌"}}})
修改小王的备注域，增长一项

宗教：“伊斯兰”

db.class.updateOne({name:"小王"},{$set:{"备注.宗教":"伊斯兰"}})

10、索引

1.概述

1.1 定义

创建文档所在位置的查找清单，使用索引能够方便的快速查找，减小遍历次数，提升查找效率

1.2 索引约束

数据量很小的时候不须要建立索引
建立索引会增长磁盘的使用空间
对数据库操做大可能是写操做而不是读操做的时候不宜建立索引

2.建立索引

2.1 createIndex

db.collection.createIndex()

功能：建立索引

参数：索引域和索引选项

#为name建立索引 
> db.class0.createIndex({name:1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}

# 指定索引名称建立
> db.class0.createIndex({age:1},{name:"ageIndex"})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "ok" : 1
}

参数说明：1为正向索引，-1为反向索引

2.2 ensureIndex

db.collection.ensureIndex()不经常使用

2.3 createIndexes

createIndexes([{},{},{},...])不经常使用

同时建立多个索引

3.查看索引

db.collection.getIndexes()

功能：查看索引

# 查看索引
> db.class0.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "stu.class0"
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1
                },
                "name" : "name_1",
                "ns" : "stu.class0"
        },
                },
        {
                "v" : 2,
                "key" : {
                        "age" : 1
                },
                "name" : "ageIndex",
                "ns" : "stu.class0"
        }
]

在建立文档的时候，系统会自动为_id建立索引，因此这里出现两个索引

4.删除索引

4.1 dropIndex

db.collection.dropIndex(index or name)

功能：删除一个索引

参数：索引名称或者索引键值对

# 经过索引键值对删除
> db.class0.dropIndex({age:1})
{ "nIndexesWas" : 3, "ok" : 1 }
> db.class0.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "stu.class0"
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1
                },
                "name" : "name_1",
                "ns" : "stu.class0"
        }
]

# 经过索引名删除
> db.class0.dropIndex("name_1") # 注意没有{}
{ "nIndexesWas" : 2, "ok" : 1 }
> db.class0.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "stu.class0"
        }
]

注意这里使用键值对时用{},使用索引名时用()

4.2 dropIndexes

db.collection.dropIndexes

删除全部索引

> db.class0.dropIndexes()
{
        "nIndexesWas" : 2,
        "msg" : "non-_id indexes dropped for collection",
        "ok" : 1
}
> db.class0.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "stu.class0"
        }
]

该操做不会删除_id_索引

5. 其余索引

5.1 复合索引

根据多个域建立索引

> db.class0.createIndex({name:1,age:-1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
}
> db.class0.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "stu.class0"
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1,
                        "age" : -1
                },
                "name" : "name_1_age_-1",
                "ns" : "stu.class0"
        }
]

只须要填入多个键值对便可

5.2 Object/数组索引

若是对object域或者数组域建立索引则针对object或者数组中的某一个元素的查询也是索引查询

# 若是岁intro建立了索引，则该查找也是索引查找
db.class3.find({"intro.author":"曹雪芹"})

5.3 惟一索引

要求建立索引的域不能有重复值

# 已经存在的索引则不会再建立
> db.class0.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "stu.class0"
        }
]

5.4 稀疏索引

若是建立的稀疏索引则会对没有索引域的文档忽略

>db.calss0.createIndex({name:1},{sparse:true,name:"Age"})

11、聚合操做

对文档进行数据整理统计，获得统计结果

1.聚合函数

1.1 aggregate

db.collection.aggregate(aggr)

功能：执行聚合操做

参数：聚合条件，配合聚合操做符使用

1.2 聚合操做符

1.2.1 分组聚合

$group 须要配合统计操做符

统计求和 $sum传的能够是整数、文档

# 统计男生、女生的年龄之和
> db.class0.aggregate({$group:{_id:'$gender',num:{$sum:1}}})
{ "_id" : "男", "num" : 9 }
{ "_id" : "女", "num" : 2 }

#按性别分组，求男生女生的平均年龄
> db.class0.aggregate({$group:{_id:"$gender",num:{$avg:"$age"}}})
{ "_id" : "男", "num" : 17.444444444444443 }
{ "_id" : "女", "num" : 17 }

求最大最小值

$max / $min

#按照性别分组，求每组的最大值、最小值
> db.class0.aggregate({$group:{_id:"$gender",num:{$max:"$age"}}})
{ "_id" : "男", "num" : 21 }
{ "_id" : "女", "num" : 17 }
> db.class0.aggregate({$group:{_id:"$gender",num:{$min:"$age"}}})
{ "_id" : "男", "num" : 13 }
{ "_id" : "女", "num" : 17 }

求第一个值或最后一个值

$first / $last

# 按照性别分组，求每组的第一个、最后一个值
> db.class0.aggregate({$group:{_id:"$gender",num:{$first:"age"}}})
{ "_id" : "男", "num" : "age" }
{ "_id" : "女", "num" : "age" }
> db.class0.aggregate({$group:{_id:"$gender",num:{$last:"age"}}})
{ "_id" : "男", "num" : "age" }
{ "_id" : "女", "num" : "age" }

1.2.2 数据筛选

$match

match的基本操做同query

# 筛选年龄为18 的文档
> db.class0.aggregate({$match:{age:18}})
{ "_id" : ObjectId("5d42a1621bc9a3414430193b"), "name" : "Alex", "age" : 18, "gender" : "男" }
{ "_id" : ObjectId("5d43edc8a5755f70bb10b692"), "name" : "小小", "age" : 18, "gender" : "男" }
{ "_id" : ObjectId("5d43ef0f4f5000004c0054f3"), "name" : "Mary", "age" : 18, "gender" : "男" }
{ "_id" : ObjectId("5d43fb43e7bb29c632f30c02"), "name" : "Davil", "age" : 18, "gender" : "m" }

# 筛选年龄大于18的文档
> db.class0.aggregate({$match:{age:{$gt:18}}})
{ "_id" : ObjectId("5d428df01bc9a3414430192e"), "name" : "Lucy", "age" : 20 }
{ "_id" : 1, "name" : "素心", "age" : 20, "gender" : "男" }
{ "_id" : ObjectId("5d42a08d1bc9a3414430193a"), "name" : "Abby", "age" : 21, "gender" : "男" }
{ "_id" : ObjectId("5d43eef44f5000004c0054f2"), "name" : "waller", "age" : 19, "gender" : "男" }
{ "_id" : ObjectId("5d43f65ea5755f70bb10b693"), "name" : "xx", "age" : 35 }

$limit

获取集合中前几条文档

# 获取前三条文档
> db.class0.aggregate({$limit:3})
{ "_id" : ObjectId("5d42519a1ae0b26ac7985b89"), "name" : "ame", "age" : 17, "gender" : "女" }
{ "_id" : ObjectId("5d428df01bc9a3414430192e"), "name" : "Lucy", "age" : 20 }
{ "_id" : ObjectId("5d428ee01bc9a3414430192f"), "name" : "Chancey", "age" : 17, "gender" : "女" }

$skip 跳过前几个文档

# 对查找结果跳过前10条
> db.class0.aggregate({$skip:10})
{ "_id" : ObjectId("5d43eef44f5000004c0054f2"), "name" : "waller", "age" : 19, "gender" : "男" }
{ "_id" : ObjectId("5d43ef0f4f5000004c0054f3"), "name" : "Mary", "age" : 18, "gender" : "男" }
{ "_id" : ObjectId("5d43f0bee7bb29c632f30ab6"), "name" : "Jack", "age" : 16 }
{ "_id" : ObjectId("5d43f65ea5755f70bb10b693"), "name" : "xx", "age" : 35 }
{ "_id" : ObjectId("5d43fb43e7bb29c632f30c02"), "name" : "Davil", "age" : 18, "gender" : "m" }

$sort 对文档排序

> db.class0.aggregate({$sort:{age:1}})
{ "_id" : ObjectId("5d42a06d1bc9a34144301938"), "name" : "Emmm", "age" : 13, "gender" : "男" }
{ "_id" : ObjectId("5d42a08d1bc9a34144301939"), "name" : "Emmm", "age" : 13, "gender" : "男" }
{ "_id" : ObjectId("5d43f0bee7bb29c632f30ab6"), "name" : "Jack", "age" : 16 }
{ "_id" : ObjectId("5d42519a1ae0b26ac7985b89"), "name" : "ame", "age" : 17, "gender" : "女" }
{ "_id" : ObjectId("5d428ee01bc9a3414430192f"), "name" : "Chancey", "age" : 17, "gender" : "女" }
{ "_id" : ObjectId("5d42a3bb1bc9a3414430193c"), "name" : "Alex", "age" : 17, "gender" : "男" }
{ "_id" : ObjectId("5d42a1621bc9a3414430193b"), "name" : "Alex", "age" : 18, "gender" : "男" }

2.聚合管道

db.class0.aggregate([{},{},{},...])

将前一个聚合产生的结果交给最后一个聚合继续操做，直到最后结果

# 将sort出来的结果给limit操做
> db.class0.aggregate([{$sort:{age:-1}},{$limit:3}])
{ "_id" : ObjectId("5d43f65ea5755f70bb10b693"), "name" : "xx", "age" : 35 }
{ "_id" : ObjectId("5d42a08d1bc9a3414430193a"), "name" : "Abby", "age" : 21, "gender" : "男" }
{ "_id" : 1, "name" : "素心", "age" : 20, "gender" : "男" }

聚合管道能够有多个聚合函数共同操做

# 查看名字重复的次数
> db.class0.aggregate([{$group:{_id:"$name",num:{$sum:1}}},{$match:{num:{$gt:1}}}])
{ "_id" : "Emmm", "num" : 2 }
{ "_id" : "Alex", "num" : 2 }

3.聚合操做符

$project

选择显示的域（值的写法同field参数）

# 筛选结果不显示_id，仅仅显示name和age
> db.class0.aggregate([{$match:{}},{$project:{_id:0,name:1,age:1}}])
{ "name" : "素心", "age" : 20 }
{ "name" : "ame", "age" : 17 }
{ "name" : "Lucy", "age" : 20 }
{ "name" : "Chancey", "age" : 17 }

4. 练习

将全部男生按照年龄升序排序，结果不显示_id

db.class0.aggregate([$match:{gender:"男"},{$sort:{age:1}},{$project:{_id:0}}])
将全部喜欢画画的女生按照年龄排序，取年龄最后的三个，只显示姓名、年龄、爱好

db.class0.aggregate([{$match:{hobby:"graw",sex:"女"}},{$sort:{age:1}},{$limit:3},{$project:{_id:0,name:1,hobby:1}}])

12、固定集合

指的是MongoDB中建立固定大小的集合，称之为固定集合

特色：

若是在固定集合中强行插入数据，早期的数据将会被淘汰，从而插入新的数据

能够控制集合大小

数据插入、查找速度快

使用：日志处理，临时缓存

1. 建立

db.createCollection(collection,{capped:true,size:10000,max:20})

capped:reuw 表示建立一个固定集合

size:10000 表示固定集合的大小

max 表示固定集合可存放的文档数量

# 建立固定集合log，最多存放三条文档
> db.createCollection("log",{capped:true,size:1000,max:3})
{ "ok" : 1 }
> show collections
log

2. 插入数据

# 已经插入了三条数据
> db.log.find({},{_id:0,date:0})
{ "status" : "400", "address" : "192.168.1.5" }
{ "status" : "500", "address" : "192.168.1.5" }
{ "status" : "501", "address" : "192.168.1.5" }

# 再次尝试添加数据，返回true
> db.log.insertOne({status:"502",address:"192.168.1.5",date:Date})
{
    "acknowledged" : true,
    "insertedId" : ObjectId("5d4791418615e4157d3980b6")
}

# 查看时，前边的400不见了，多出来了502
> db.log.find({},{_id:0,date:0})
{ "status" : "500", "address" : "192.168.1.5" }
{ "status" : "501", "address" : "192.168.1.5" }
{ "status" : "502", "address" : "192.168.1.5" }

十3、文件存储

MongoDB提供了一些存储文件的方式

1. 存储文件路径

将本地的文件所在的路径以字符串存入到数据库里

优势：操做简单，节省空间

缺点：当数据库或者文件发生变化的时候须要球盖数据库

2. 存储文件自己

将文件转换为二进制存储到数据库里

优势：文件绑定数据库，不易丢失

缺点：占用数据库空间大，文件存取效率低

1.2 大文件存储

GridFS文件存储方案

目的：更加方便的存取MongoDB中的大文件(>16M)

说明：

1. MongoDB数据库中建立两个集合共同存储文件
2. fs.files集合中为每一个文件创建一个信息文档，存储文件的基本信息
3. fs.chunks集合中每一个文档创建与fs.files的关系，并将文件分块存储

方法：

(1) 存储

mongofiles -d dbname put file

# 将demo.mp4 存储到数据库中
[root@localhost files]# mongofiles -d grid put demo.mp4 
2019-08-05T10:35:35.908+0800    connected to: localhost
added file: demo.mp4

db.fs.files.find() #查看文件信息

db.fs.chunks.find()

files和chunks的files_id域的值是同样的，以此来肯定两个集合之间的关联

(2) 提取

mongofiles -d dbname get file

[root@localhost files]# ls
[root@localhost files]# mongofiles -d grid get demo.mp4 # 从数据库中获取demo.mp4 文件
2019-08-05T10:52:06.082+0800    connected to: localhost
finished writing to demo.mp4
[root@localhost files]# ls
demo.mp4

对大文件的存储提取方便，可是读写效率仍然比较低，不建议用来存储小文件

1.3 小文件存储

pass

十4、mongo shell

对JavaScript支持，mongo shell就是用JavaScript编写的，因此可使用基本的js代码

mongo shell 界面中支持基本的js代码
经过js处理mongo的一些数据逻辑

十5、python操做MongoDB

使用第三库pymongo，安装方法再也不赘述

1.步骤

导入pymongo

1.1 链接

from pymongo import MongoClient
conn = MongoClient("IP",27017) # 实现链接

1.2 选择数据库

db = conn.stu #选择数据库
myset = db.class0 # 选择集合

1.3 操做

经过集合对象调用接口完成数据操做

文档 --> 字典

数字 --> 列表

布尔 --> python

null --> Mome

操做符 --> 字符串形式原样书写

$lt "$lt"

from pymongo import MongoClient

# 建立数据库链接
conn = MongoClient('127.0.0.1',27017)

# 床架数据库对象和集合对象
db = conn.stu
myset = db.class4 # 若是不存在该文档，则建立

1.3.1 插入操做

insert_one()插入一条文档

insert_many() 插入多条文档

insert() 插入一条或者多条

save() 插入文档，若是_id重复就会覆盖

myset.insert_one({"name":"杨幂","King":"Chancey"})
myset.insert_many([{"name":"刘诗诗","King":"吴奇隆"},{"name":"杨紫","King":"张一山"}])
myset.insert({"name":"乔碧萝","King":"菜虚鲲"})
myset.insert([{"name":"林志玲","King":"黑泽良平"},{"name":"柳岩","King":"小岳岳"}])

myset.save({"_id":1,"name":"郑爽","King":"张翰"})
myset.save({"_id":1,"name":"郑爽","King":"慕容云海"})
# 返回结果查看，张翰被替换成了慕容云海

1.3.2 查找操做

find

find()查找全部

功能：查找全部文档

参数：形式同mongo中的 find

返回值：查找结果的游标对象

cursor游标对象属性

经过迭代获取每一个查找的文档结果

经过调用属性方法对结果进一步操做

next()

limit()

skip()

count()

sort() 书写方法不同，相似于sort([("age",1),("name",1)])

要获得具体的文档内容，须要遍历cursor
cursor = myset.find({},{'_id':0})
# 循环遍历，获得每个结果都是文档字典
for i in cursor:
    print(i["name"],'------',i["King"])

# 全部的特殊操做符均加引号执行
cursor = myset.find({},{'_id':0})

# 循环遍历，获得每个结果都是文档字典
for i in cursor:
    print(i["name"],'------',i["King"])

print(cursor.next()) #获取游标的下一个结果

# 调用skip、limit以后获得的仍然是游标对象，必须保证该游标对象没有遍历过
for i in cursor.skip(1).limit(3):
    print(i)

# 按照king排序
for i in cursor.sort([("King",1)]):
    print(i)

注意：

调用limit、skip、sort时游标必须没有遍历过

sort写法不一样

{age:1,name:1} --> [('age',1),('name',1)]

find_one

find_one()查找一个文档

功能：查找一个文档

参数：同find

返回值：文档字典

r = myset.find_one({"King":"菜虚鲲"},{"_id":0})
print(r)

1.3.3 修改文档

update_one()修改一个文档

update_many()修改多个文档

update()修改一个或多个文档

#***************   find   ***************
myset.update_one({"King":"刘恺威"},{"$set":{"king_name":"chancey"}})
myset.update_many({"King":"菜虚鲲"},{"$set":{"king_name":"蔡徐坤"}})
myset.update({"King":"张一山"},{"$set":{"king_name":"张两山"}})
myset.update({"king_name":"张两山"},{"$set":{"king_name":"张三山"}},multi=True)
myset.update({"king_name":"张两山"},{"$set":{"king_name":"张三山"}},upsert=True)

1.3.3删除操做

delete_one删除一个文档

delete_many删除多个文档

remove

#***************   delete   ***************
myset.delete_one({"name":"杨幂"})
myset.delete_many({"king_name":None}) # 删除没有king_name域
myset.remove({"King":"菜虚鲲"},multi=False)

1.3.4复合操做

find_one_and_delete()

myset.find_one_and_delete({"King":"张一山"})

1.3.5 索引操做

vreate_index(index)

功能：建立索引

参数：{name:1} --> [('name'),1] kwargs为索引选项

返回值：索引名称

index1 = myset.create_index("name")
index2 = myset.create_index([("name",-1)],name="NAME")
print("1", index1)
print("2", index2)

list_indees()

dro_index()

drop_indexes

myset.drop_index("NAME")
myset.drop_index([('name',1)])
myset.drop_indexes()

1.3.6 聚合操做

aggregate([{},{},...])

功能：完成聚合操做

参数：聚合管道，同MongoDB shell

返回值：数据结果游标

myset = db.class0
pipe = [{"$match":{"gender":{"$exists":True}}},
        {"$sort":{"age":1}},
        {"$project":{"_id":0}}
        ]

cursor = myset.aggregate(pipe)

for i in cursor:
    print()

1.3.7 文件存储

import bson

将文件内容转换为bson二进制格式存储

content = bson.binary.Binary(bytes)

功能：将python字节串转换为bson

参数：要转换的字符串

返回值：bson

##################存储图片##################
from pymongo import MongoClient
import bson.binary

conn = MongoClient('127.0.0.1',27017)
db = conn.images
myset = db.girl


with open("./demo.jpg","rb") as f:
    data = f.read()

# 将data转换为bson
content = bson.binary.Binary(data)

# 插入到集合
dic = {"filename":"girl.jpg",'data':content}
myset.insert_one(dic)
f.close()
conn.close()

##################提取图片##################
from pymongo import MongoClient
import bson.binary

conn = MongoClient('127.0.0.1',27017)
db = conn.image
myset = db.girl

# 提取文件
img = myset.find_one({"filename":"demo.jpg"})

with open('mm.jpg','wb') as f :
    f.write(img['data'])

conn.close()

1.4 关闭链接

conn.clse()

MongoDB

MongoDB

1、概述

1.数据

2. 数据结构

3. 数据库

4.数据库管理系统

5.数据库系统

2、 关系与非关系

1. 关系型数据库

2. 非关系型数据库

3、MongoDB

1. 特色

2. 安装

3. 基础命令

4、数据结构

5、数据库操做

1. 数据库操做

2. 备份恢复

3. 运行监控

3.1 运行状态

3.2 读写时长

6、集合操做

7、文档操做

1. 概述

2. 数据类型

2.1 整型

2.2 浮点型

2.3 布尔

2.4 字符串

2.5 ObjectID

3.集合文档设计

8、数据操做

1. 插入文档

2. 查询文档

2.1 find

2.1.1 query

2.1.2 field

2.2 findOne

2.3 query操做符

2.3.1 比较操做符

2.3.2 逻辑操做符

2.3.3 混合查询

2.3.4 数组操做符

查找数组中包含元素

查找数组中同时包含多项

根据数组的元素个数查找

切片操做

经过索引查找

2.3.5 其余操做符

2.4. 数据操做函数

2.4.1 范围值

2.4.2 格式化显示

2.4.3 限制显示

2.4.4 跳页显示

2.4.5 统计数量

2.4.6 排序

2.4.7 函数连续调用

2.4.8 序列号

4. 修改文档

4.1 修改函数

4.1.2 updateOne

4.1.3 updateMany

4.1.4 update

4.1.5 findOneAndUpdate

4.1.6 findOneAndReplace

4.2 修改器

4.2.1 set

4.2.2 unset

4.2.3 rename

4.2.4 setOneInsert

4.2.5 inc

4.2.6 mul

4.2.7 max

4.2.7 min

4.2.8 数组修改器

(1) push

(2) pushAll

(3) pull

(4)pullAll

2、关系与非关系

10、索引

11、聚合操做