芒果数据库
芒果数据库是NOSQL的一种，是一种面向文档的数据库，介于结构化数据库和非结构数据库的一种，它的数据结构非常松散，也非常灵活
优点
-
面向文档存储(类JSON数据模式简单而强大)
-
动态查询
-
全索引支持,扩展到内部对象和内嵌数组
-
查询记录分析
-
快速,就地更新
-
高效存储二进制大对象 (比如照片和视频)
-
复制和故障切换支持
-
Auto- Sharding自动分片支持云级扩展性
-
MapReduce 支持复杂聚合
-
商业支持,培训和咨询
缺点
-
不支持事务（进行开发时需要注意，哪些功能需要使用数据库提供的事务支持）
-
MongoDB占用空间过大 （不过这个确定对于目前快速下跌的硬盘价格来说，也不算什么缺点了）
-
MongoDB没有如MySQL那样成熟的维护工具，这对于开发和IT运营都是个值得注意的地方
-
在32位系统上，不支持大于2.5G的数据(很多操作系统都已经抛弃了32位版本，所以这个也算不上什么缺点了，3.4版本已经放弃支持32 位 x86平台)
数据存储阶段
文件管理阶段（.txt .doc .xls）
优点 ： 使用简单方便 数据能够长期保存 可以存储大量数据
缺点 ： 数据一致性差 数据的查找修改不方便 数据冗余
数据库管理阶段
优点 ： 数据组织结构化，降低冗余 提高增删改查效率 方便扩展 方便程序调用，做自动化的处理 缺点 ： 数据库使用特定的语句操作，相对复杂
mysql 和 mongodb 概念比价
mysql mongodb 含义
database database 数据库
table collection 表/集合
column field 字段/域
row document 记录/文档
index index 索引
操作
启动
双击mongo.exe
查看当前系统中的数据库
show dbs
系统数据库： admin：存放用户及其权限 local： 存储本地数据 config：存储分片信息
使用指定数据库
use 库名
创建库
use str
刚创建不会成功，只有使用，才会成功
db.createCollection("class1")
删除库
db.dropDatabase()
删除db代表的数据库
创建集合
db.createCollection(collection_name)
创建一个class1的集合
例： db.createCollection("class1")
当向一个集合中插入数据的时候，如果这个集合不存在则会自动创建
例： db.class2.insert({"name":'Tom','age':17,'sex':'m'})
查看数据库中的集合
方式一：show collections
方式二：show tables
删除集合
db.collectionName.drop()
列： db.class1.drop()
集合的重命名
db.collectionName.renameCollection("new_name")
列：db.class2.renameCollection("class1")
文档
mongodb中数据的组织形式--》文档
芒果db文档：以键值对形式组成的类似字典的数据结构
键：即文档的域
键的命名规则： \1. utf-8字符串 \2. 不含有'\0' 通常不用 . $ \3. 一个文档中的键不能重复
* 文档中的键值对是有序的 * mongodb中数据严格区分大小写
值：即文档存储的数据，支持bson数据
JavaScript ---》 json ---》bson
类型 值
整型 整数 布尔类型 true false 浮点型 小数 Array 数组 Timestamp 时间戳 Date 时间日期 Object 内部文档 Null 空值 null String 字符串 Symbol 特殊字符串 Binary data 二进制字串 code 代码 regex 正则表达式 ObjectId ObjectId字串
"_id" : ObjectId("5b503b7f38d0e992e1270560")
_id : 当在mongo代表中插入文档时，如果不指定id则会自动添加这个域，作为主键。
ObjectId() 值是系统自动生成的不重复字串标识
24位 8位 文档创建时间 6位 机器ID 4位 进程ID 6位 计数器
集合中的文档：
集合中的文档： \1. 集合中的文档不一定有相同的域 \2. 集合中的文档多少不一定相同 \3. 集合中的文档，值的类型不一定相同
集合设计 \1. 集合中的文档尽可能描述同一类数据 \2. 同一类数据不要过多分散在多个集合中存放 \3. 集合中文档的结构层次不宜过多
插入文档
插入单个文档
db.collectionName.insert()
例：db.class0.insert({name:"HanMei",age:17,sex:'w'})
查看插入结果
db.class0.find()
* 插入数据时域名可以不加引号 * 查看插入结果 db.class.find() * id 为系统自动添加主键，如果自己写id则为自己设定的值，但是仍然不可重复 * 一个集合中的文档是有序的
插入多个文档
db.collectionName.insert([{},{},{}])
例：db.class2.insert([{name:'阿宝',age:32},{name:'阿哲',age:31},{name:'阿蓉',age:26}])
查看插入结果
db.class2.find()
save() 插入文档 save() 也可以用来插入多条数据 如果正常插入与insert相同 当插入指定_id值重复的数据时save()可以对原数据进行修改，但是insert()会报错
使用save插入
db.collectionName.save()
例：db.class1.save({name:'Lily',age:13,sex:'w'})
查看插入结果
db.class1.find()
* 如果不加id域时用法同insert() * 如果加id，此_id值存在则save表示修改该文档。
MongoDB 文档型数据库总结
创建数据库： use database 删除数据库： db.dropDatabase()
创建集合： db.createCollection() db.collection.insert() 删除集合： db.collection.drop() 重命名 ： db.collection.renameCollection()
查看数据库
查看数据库： show dbs
查看集合
查看集合： show collections show tables
文档
www.mongodb.com --> docs 查找文档帮助
插入文档 ： insert() save()
获取集合对象
db.getCollection('class1') ===》 db.class1
插入数据
db.getCollection('class1').insert({name:'Marry',age:16,sex:'w'})
查找操作
mysql ： select ... from table where ....
mongo : db.collection.find(query,field)
查找所有内容 db.collection.find() ----> select * from table
find(query,field) 功能 ： 查找数据 参数 ： query： 筛选条件，相当于where子句 field： 选定要展示的域 返回值 ： 返回查找到的文档
query : 以键值对形式给出筛选条件 {name:'Lily'}
查找所有内容
db.collection.find(query,field)
查找所有
例： db.class1.find()
按条件查找
例：db.class1.find({name:'Lily'})
field : 以键值对的形式给出要展示（不展示）的域，域名为键，值为1表示展示，0表示不展示
* 如果某个域设置为0则表示不展示该域其他的均展示 * 如果某个域设置为1则表示展示该域其他的均不展示 * id必须设置为0才不会显示 * 除了id其余设置的值必须相同
以键值对形式展示
db.class1.find({name:'Lily'},{_id:0,name:1,age:1})
db.class1.find({name:'Lily'},{_id:0,name:1})
db.class1.find({name:'Lily'},{_id:0})
0是该域不展示，其他均展示
1是该域展示，其他不展示
只查找第一条符合条件的文档
findOne(query,field)
参数返回值同find()
例： db.class1.findOne({sex:'w'},{_id:0})
query 更多筛选功能
操作符：使用$符号标注的一个有特殊意义的字符串。用以表达一定的含义。比如 $lt 表示小于
比较操作符
$eq 等于 =
例：db.class1.find({age:{$eq:13}},{_id:0})
db.class1.find({age:13},{_id:0})
$lt 小于 <
例：db.class1.find({age:{$lt:15}},{_id:0})
* 字符串也可以比较大小
$lte 小于等于 <=
小于等于15
例：db.class1.find({age:{$lte:15}},{_id:0})
$gt 大于 >
大于15 db.class1.find({age:{$gt:15}},{_id:0})
$gte 大于等于 >=
大于等于15 db.class1.find({age:{$gte:15}},{_id:0})
$ne 不等于 !=
不等于13 db.class1.find({age:{$ne:13}},{_id:0})
* 如果某个文档不存在查找的域，则不等于可以匹配到该文档
$in 包含
年龄包含 在11，12，13，14的
db.class1.find({age:{$in:[11,12,13,14]}},{_id:0})
$nin 不包含
年龄不是13，14 db.class1.find({age:{$nin:[13,14]}},{_id:0})
逻辑操作符
query 逗号分隔的条件即为与关系
，表示关系
年龄大于13 小于16
db.class1.find({age:{$gt:13,$lt:16}},{_id:0})
年龄大于13且性别为女
db.class1.find({age:{$gt:13},sex:'w'},{_id:0})
$and 逻辑与
年龄大于13 并且姓名大于Lily
db.class1.find({$and:[{age:{$gt:13}},{name:{$lt:'Lily'}}]},{_id:0})
$or 逻辑或
年龄大于15或者为男生
$not 逻辑非
年龄不大于15
db.class1.find({age:{$not:{$gt:15}}},{_id:0})
$nor 既不也不
既不大于16 也不是女生
db.class1.find({$nor:[{age:{$gt:16}},{sex:'w'}]},{_id:0})
条件混合
年龄大于16并且为男生 或者 年龄小于14
db.class1.find({$or:[{age:{$gt:16},sex:'m'},{age:{$lt:14}}]},{_id:0})
年龄大于16或者为女生 并且 姓名大于 Jame
db.class1.find({name:{$gt:'Jame'},$or:[{age:{$gt:16}},{sex:'w'}]},{_id:0})
数组
[1,2,3,4]
数组查找
查看数据中是否包含某一项
如果score数组中包含67即可
db.class3.find({score:67},{id:0}) db.class3.find({score:{$gt:90}},{id:0})
$all
查看数据中同时包含多项
同时包含64 75
db.class3.find({score:{$all:[64,75]}},{_id:0})
$size
通过数组元素个数查找
db.class3.find({score:{$size:3}},{_id:0})
$slice
取出数组的部分进行显示 放在field中
显示数组中前两项 db.class3.find({},{id:0,score:{$slice:2}})
跳过第一项显示后面一项 db.class3.find({},{id:0,score:{$slice:[1,1]}})
其他查找方法
$exists
判断一个域是否存在
查找存在age域的文档
db.class1.find({age:{$exists:true}},{_id:0} )
true 表示有这个域 false表示筛选无这个域
$mod
余数查找
查找除以2余数为1的 db.class1.find({age:{$mod:[2,1]}},{_id:0} )
$type
找出值为指定类型的文档
查找age数据类型为1的文档 db.class1.find({age:{$type:1}},{_id:0} )
具体数字和类型的匹配 Type Number Double 1 String 2 Object 3 Array 4 Binary data 5 ObjectId 7 Boolean 8 Date 9 Null 10 RE 11 Symbol 14 32-bit integer 16 Timestamp 17 64-bit integer 18
查找结果相关函数
distinct()
功能：查看集合某个域的取值范围
查看集合中age域值的范围 db.class1.distinct("age")
pretty()
功能： 格式化显示查找结果
db.class1.find().pretty()
limit(n)
功能： 显示查找结果的前n条
显示查找结果的前三条 db.class1.find({},{_id:0}).limit(3)
skip(n)
功能 ： 跳过前n条显示
跳过前三条显示后边的内容 db.class1.find({},{_id:0}).skip(3)
count()
功能 ： 计数统计
统计男生数量 db.class1.find({sex:'m'},{_id:0}).count()
sort({域：1/-1})
功能 ： 对查找结果排序 参数 ： 以键值对的形式给出 1 表示按照升序排序， -1表示降序排序
按照年龄升序 db.class1.find({},{_id:0}).sort({age:1})
复合排序：当第一排序项相同时比较第二排序项
db.class0.find({},{_id:0}).sort({age:1,name:1})
函数的连续调用 当函数返回文档集合时还可以继续调用函数
查找班级年龄最大的三个 db.class1.find({},{_id:0}).sort({age:-1}).limit(3)
文档的删除操作
delete from table where ...
db.collection.remove(query,justOne) 功能 ： 删除文档 参数 ： query 筛选要删除的文档 相当于where 用法同查找 justOne ： 布尔值，默认为false 表示删除所有。如果设置为true 只删除第一条符合条件的文档。
例子：db.class2.remove({name:"阿蓉"})
justOne为true则只删除第一条符合条件的
例：db.class0.remove({age:17},true)
删除集合中所有文档
删除class2中所有文档 db.class2.remove({})
练习 ：
\1. 创建数据库 名字 grade use grade \2. 数据库中创建集合 class \3. 集合中插入文档，格式如下 {name:'zhang',age:10,sex:'m',hobby:['a','b']} age范围 4-15 hobby 范围 [draw dance sing pingpong basketball football running computer]
\4. 查找练习 查看班级所有人信息 db.class.find({},{_id:0})
查看班级年龄8岁的同学信息 db.class.find({age:8},{id:0}) 查看年龄大于10岁的学生信息 db.class.find({age:{$gt:10}},{id:0}) 查看年龄在8-11岁之间的学生信息 db.class.find({$and:[{age:{$gt:8}},{age:{$lt:11}}]},{_id:0})
查看年龄为9岁且为男生的学生 db.class.find({age:9,sex:'m'},{_id:0})
找到年龄小于7岁或大于12岁的学生 db.class.find({$or:[{age:{$lt:7}},age:{$gt:12}],{id:0}) 找到年龄为8岁或者11岁的学生 db.class.find({$or:[{age:8},{age:11}]},{id:0}) db.class.find({age:{$in:[8,11]}})
找到有两项兴趣爱好的学生 db.class.find({hebby:{$size:2}},{_id:0})
找到兴趣中有draw的学生 db.class.find({hebby:draw},{_id:0})
找喜欢画画又喜欢跳舞的学生 db.class.find({hebby:{$all:['draw','dance']}})
统计兴趣有三项的学生人数 db.class.find({hebby:{%size:3}}).count
找到本班年龄第二大的同学 db.class.sort({age:-1}).skip(1).limit(1)
查看本班学生兴趣爱好涵盖哪些方面 db.class.distinct('hebby')
找到年龄最大的三个同学 db.class.sort({age:-1}).limit(3)
\5. 删除所有年龄大于12或者小于7岁的同学除非他的爱好有三项以上 db.class.remove({$and:[{$or:[{age:{$gt:12}},{age:{$lt:7}}]},{hebby:{$size:{$lt:3}}}]}
修改操作
update table set ... where ...
db.collection.update(query,update,upsert,multi) 功能 ： 修改文档 参数 ： query ： 筛选需要修改的文档，相当where 用法同查找 update： 要修改什么内容 相当set。往往需要配合修改操作符 upsert：bool值 默认false 如果query的文档不存在则不做操作 设置为true 则如果文档不存在根据query和update内容插入新文档 multi： bool值 默认false 如果筛选到多条文档则只修改第一条。 设置为true则表示修改所有筛选到的文档
e.g. 年龄修改为18 db.class0.update({name:'HanMei'},{$set:{age:18}})
e.g. 如果筛选内容不存在则插入 db.class0.update({name:'Jame'},{$set:{age:18}},true)
e.g. 如果匹配到多条，则修改所有 db.class0.update({sex:'w'},{$set:{name:'小芳'}},false,true)
第三天
复习 ：
\1. 查找操作 find(query,field) findOne()
操作符 ： 比较 $lt $lte $gt $gte $ne $eq $in $nin 逻辑 $and $or $not $nor
数组 $all $size
其他 $exists $mod $type
\2. 函数 ： pretty() limit() skip() sort() count() 其他函数： distinct() getCollection()
\3. 删除文档 remove(query,justOne) remove({})
\4. 修改操作 update(query,update,upsert,multi)
==================================================
修改操作符
$set 修改一个域的值，或者增加一个域
e.g. 修改功能 如果该域不存在则增加这个域 db.class0.update({age:20},{$set:{name:'小薇'}})
$unset 删除一个域
e.g. sex后面为空表示删除一个域 db.class0.update({name:'Jame'},{$unset:{sex:''}})
$rename 修改一个域的名称
e.g. 将sex域名修改为gender db.class0.update({},{$rename:{sex:'gender'}},false,true)
$setOnInsert 如果update执行了插入文档操作，表示补充插入内容
e.g. 如果执行插入操作则将setOnInsert中内容也插入 db.class0.update({name:'Tom'},{$set:{age:17},$setOnInsert:{gender:'m',tel:'12345'}},true) 00 * 在update参数中可以同时写多个修改器
$inc
加减修改器
e.g. 所有人年龄增加1 db.class0.update({},{$inc:{age:1}},false,true)
* $inc值可以是正数负数整数小数
$mul
乘法修改器
e.g. Tom年龄 乘以2 db.class0.update({name:'Tom'},{$mul:{age:2}})
* $mul值可以是正数负数整数小数
$max
指定了某个域值的下限，如果小于指定值则修改为指定值
e.g. 将年龄不到20的修改为20 db.class0.update({},{$max:{age:20}},false,true)
$min
指定了某个域值的上限，如果大于指定值则修改为指定值
e.g. 年龄大于25的修改为25 db.class0.update({},{$min:{age:25}},false,true)
数组修改器
$push 向数组中添加一项
e.g. db.class3.update({name:'小明'},{$push:{score:5}})
$pushAll 向数组中添加多项
e.g. db.class3.update({name:'小红'},{$pushAll:{score:[5,10]}})
$pull 从数组中删除一项
e.g. db.class3.update({name:'小红'},{$pull:{score:10}})
*数组可以有重复值，如果删除则会把所有指定的值都删除
$pullAll 删除数组中多项
e.g. db.class3.update({name:'小明'},{$pullAll:{score:[67,5]}})
$each 对多个值逐一操作
e.g. db.class3.update({name:'小明'},{$push:{score:{$each:[5,10]}}})
$position 指定插入位置
e.g. 需要搭配$each使用，将数据从1号位置插入 db.class3.update({name:'小红'},{$push:{score:{$each:[10],$position:1}}})
$sort 对数组进行排序
e.g. 和each一起使用，对数组score进行排序 db.class3.update({name:'小红'},{$push:{score:{$each:[],$sort:1}}})
$pop 弹出一项
e.g. 1表示弹出最后一项 -1表示删除第一项 db.class3.update({name:'小红'},{$pop:{score:-1}})
$addToSet 向数组中添加一项，不能和已有的内容重复
e.g. 添加87，不能和已有数据重复 db.class3.update({name:'小红'},{$addToSet:{score:87}})
时间类型
mongodb中存储时间格式 ： ISODate()
方法1 ： new Date() 自动生成当前时间
e.g. db.class2.insert({title:'Python入门',date:new Date()})
方法2 ： ISODate() 生成当前时间
e.g. db.class2.insert({title:'Python精通',date:ISODate()})
方法3 Date() 将生成的当前时间变为字符串存储
e.g. db.class2.insert({title:'Python疯狂',date:Date()})
ISODate()
功能 ： 生成时间类型存储 参数 ： 参数指定时间 "2018-07-01 12:10:56" "20180701 12:10:56" "20180701"
e.g. db.class2.insert({title:'Python崩溃',date:ISODate("2018-07-01 01:12:12")})
时间戳
valueOf() 将时间转换为时间戳
e.g. db.class2.insert({title:'Python放生',date:ISODate().valueOf()})
Null ----》 null
\1. 如果某个域存在却没有值，可以设置为null
e.g. db.class2.insert({title:'Python涅槃',price:null})
\2. 如果某个域不存在可以使用null匹配
e.g. 找到date域不存在的文档 db.class2.find({date:null},{_id:0})
Object 内部文档
文档内某个域的值还是一个文档，则这个文档为内部文档
* 当需要使用内部文档某个域的时候，可以使用外部文档 . 的方法引用内部文档。但是注意此时需要加引号
e.g. db.class4.find({'book2.title':'python Web'},{_id:0})
e.g. db.class4.update({'book1.title':'python爬虫'},{$set:{'book1.price':48.8}})
数组的下标引用
* 使用数组时，可以使用数组域 . 数组序列下标的方式引用数组的具体某一项
e.g. db.class3.find({'score.0':98},{_id:0})
e.g. db.class3.update({name:'小明'},{$set:{'score.0':100}})
查找结果的有序性
即可以对find的查找结果使用[]的方式引用具体某一条
e.g. db.class1.find({},{_id:0})[1]
练习 ： 使用之前的grade数据库
\1. 将小红年龄修改为8岁，兴趣爱好变为跳舞画画 ｛$set:{age:8,hobby:[‘draw’,'dance']}｝
\2. 追加小明兴趣爱好 唱歌 {$push:{hobby:'sing'}}
\3. 追加小王兴趣爱好，吹牛，打篮球 {$pushAll:{hobby:['chuiniu','basketball']}}
\4. 小李兴趣多了跑步唱歌，但是要确保和之前的不重复 {$addToSet:{hobby:{$each:['running','sing']}}}
\5. 班级所有人年龄加1 {$inc:{age:1}},false,true
\6. 删除小明的sex属性 {$unset:{sex:''}}
\7. 删除小李的第一个爱好 {$pop:{hobby:-1}}
\8. 删除小红的兴趣画画和唱歌 {$pullAll:{hobby:['draw','sing']}}
索引
指建立指定键值对及所在文档中存储位置的对照清单。使用索引可以方便我们快速查找，减少遍历次数，提高查找效率。
mongodb创建索引
ensureIndex()
功能 ： 创建索引 参数 ： 索引域，索引类别和选项
e.g. 根据name 创建索引 db.class1.ensureIndex({name:1})
* 1表示正序 -1逆序
查看一个集合中的索引
db.class1.getIndexes()
* _id是系统自动创建的索引
自定义索引名称
db.class1.ensureIndex({name:1},{name:'name_index'})
删除索引
dropIndex()
功能 ： 删除索引 参数 ： 要删除的索引，可以是索引名称或者索引键值对
e.g. db.class1.dropIndex('age_index') e.g. db.class1.dropIndex({name:-1})
dropIndexes() 删除所有索引 除了_id
e.g. db.class1.dropIndexes()
索引类型
复合索引 根据多个域创建一个索引
e.g. db.class1.ensureIndex({name:1,age:-1})
数组和子文档索引
如果对某个域创建索引，值为数组或者子文档，则通过数组或子文档进行查找时也是索引查找
覆盖索引
查找返回的内容，仅仅是索引表存储的内容，不需要再去原数据库查找
唯一索引
创建索引时希望集合中创建索引的域的值均不重复
e.g. db.class1.ensureIndex({name:1},{unique:true})
* 创建唯一索引的域的值不可以重复
稀疏索引（间隙索引）
只针对有指定域的文档创建索引表，如果某个文档没有该域则不做索引处理
e.g. 创建age域的稀疏索引 db.class1.ensureIndex({age:1},{sparse:true})
索引约束 \1. 当数据发生更新 ，索引也要随之更新。影响插入，修改，删除操作的效率 \2. 索引表也需要占有一定的磁盘空间
综上 ：当数据量比较小，或者需要频繁的进行数据修改操作而不是查找操作的时候，不适合创建索引
聚合操作
对文档的更高级的筛选整理统计
db.collection.aggregate() 功能 ： 聚合函数，完成聚合操作 参数 ： 聚合条件 ---》 聚合操作符
聚合操作符
$group 分组聚合 需要配合分组统计操作符使用 $sum ： 求和 e.g. db.class1.aggregate({$group:{_id:'$sex', 分组 按sex内容分组 num: {$sum:1}}}) 自定义统计域 统计什么
e.g. 统计所有男生和女生的年龄之和 db.class1.aggregate({$group:{_id:'$sex',num:{$sum:'$age'}}})
$avg 求平均 e.g. 求每个性别的平均年龄 db.class1.aggregate({$group:{_id:'$sex',num:{$avg:'$age'}}})
$max 求最大值 e.g. 求每组年龄的最大值 db.class1.aggregate({$group:{_id:'$sex',max:{$max:'$age'}}})
$min 求最小值
e.g. 求每组年龄的最小值 db.class1.aggregate({$group:{_id:'$sex',min:{$min:'$age'}}})
$project 用于修改文档的显示效果
e.g. db.class1.aggregate({$project:{_id:0,sex:0}})
e.g. 指定显示域名 db.class1.aggregate({$project:{_id:0,Name:'$name',Age:'$age'}})
$match 过滤数据
e.g. 过滤年龄大于16的 db.class1.aggregate({$match:{age:{$gt:16}}})
作业 ： 熟练mongodb增删改查操作 熟练 索引操作
第四天
复习：
\1. 数据的修改 update(query,update,upsert,multi)
修改器 ： $set $unset $rename $setOnInsert $inc $mul $max $min $push $pushAll $pull $pullAll $each $position $sort $addToSet $pop
时间类型 ： new Date() ISODate() Date() valueOf()
null : 作为一个域的值，或者表示一个域不存在
内部文档 ：通过 . 获取内部文档某个域的值
索引操作： ensureIndex（{},{}） dropIndex() dropIndexes() getIndexes()
聚合操作
aggregate（）
聚合操作 $group $project $match $sum $avg $max $min **************
聚合操作
$limit 显示前几条文档
e.g. 获取数据的前两个文档 db.class1.aggregate({$limit:2})
$skip 跳过几条文档
e.g. 跳过前两条文档显示后面内容 db.class1.aggregate({$skip:2})
$sort 排序
e.g. 按年龄升序排序 db.class1.aggregate({$sort:{age:1}})
聚合管道 ： 将前一个聚合操作得到的结果，给后一个聚合操作继续使用
db.collection.aggregate([聚合1，聚合2....])
e.g. $match ---> $project ---> $sort db.class1.aggregate([{$match:{sex:'m'}},{$project:{_id:0}},{$sort:{age:1}}])
e.g. $group ---> $match db.class1.aggregate([{$group:{_id:'$name',num:{$sum:1}}},{$match:{num:{$gt:1}}}])
练习： 增加分数域 score:{chinese:88,math:76,english:76}
1.学生按照性别分组，统计每组人数 aggregate({$group:{_id:'$sex',num:{$sum:1}}})
\2. 统计每名男生的语文分数 aggregate([{$match:{sex:'m'}},{$project:{_id:0,name:1,'score.chinese':1}}])
\3. 将所有女生按照英语成绩降序排序 aggregate([{$match:{sex:'w'}},{$sort:{'score.englisth':-1}}])
固定集合
mongodb中可以创建大小固定的集合，称之为固定集合
特点 ： 插入速度快，顺序查找速度快 能够淘汰早期数据 可以控制集合大小
使用 ： 临时缓存 日志处理
db.createCollection(collection,{capped:true,size:10000,max:1000})
capped：true 表示创建固定集合 size ： 表示集合的大小 bytes 4.0最小 4096 max ： 表示最多存放多少文档
e.g. db.createCollection('log',{capped:true,size:10,max:3})
文件存储
文件存储到数据库方式
\1. 存储路径 将文件在本地的路径以字符串形式存储到数据库
优点 ： 节省数据库空间 缺点 ： 当数据库或者文件位置发生变化时文件丢失。
\2. 存储文件本身 以二进制方式将文件存储到数据库 优点：数据库和文件绑定存在 缺点 ： 占用空间大，结构化麻烦
mongodb存储二进制文件
* GridFS方法存储大文件 >16M为大文件 * 将文件转化为二进制，进行插入 Binary data
GridFS方案解释
\1. 在mongodb中一个数据库创建两个集合共同完成对文件的存储 \2. fs.files 用来存储文件的相关信息，为每一个文件创建一个文档，存储文件名、文件类型等信息 \3. fs.chunks 用来分块存储文件的实际内容
如何存储 mongofiles -d dbname put file 数据库 要存储的文件
* 如果数据库不存在自动创建
fs.files { "_id" : ObjectId("5b569b8969d72e103282f608"), "chunkSize" : 261120, "uploadDate" : ISODate("2018-07-24T03:22:54.259Z"), "length" : 247759369, "md5" : "a94853f4f64b3e87bf98aea770855615", "filename" : "abc.mp4" }
fs.chunks { "_id" : ObjectId("5b569b8969d72e103282f61d"), "files_id" : ObjectId("5b569b8969d72e103282f608"), "n" : 20, "data" : BinData(0,"7Pa7M7M9nZt2bezsz272vbdm/7fhu672fwAAbZKbmR2S7Ndv/.....")}
* 对于同一个文件 fs.files中的_id值等于 fs.chunks中的files_id值
文件提取方法
mongofiles -d dbname get file
Grid的优缺点 优点 ： 存储方便，提供较好的命令支持 缺点 ： 读写效率低
游标
通过一定的操作获取返回结果的对象
var cursor = db.class1.find() cursor.hasNext() 判断是否有next cursor.next() 获取下一条数据
python操作mongodb
pymongo模块 第三方模块
安装 sudo pip3 install pymongo
操作步骤 \1. 创建mongodb数据库连接对象
conn = pymongo.MongoClient('localhost',27017)
\2. 得到数据库对象
db = conn.stu
\3. 获取集合对象
myset = db.class1
\4. 增删改查，索引 ，聚合
调用各种myset的属性函数
\5. 关闭数据库连接 conn.close()
插入操作
insert() insert_many() insert_one() save()
查找操作
cursor = find() 返回一个结果游标
* 在pymongo中使用操作符的方法与mongo shell中相同，只需要转变为字符串格式加上引号即可
cursor 的属性函数
next() limit() skip() sort([('name',1),('age',-1)]) count()
* 使用了next或者for取游标后就不能使用limit sort操作了
find_one() 返回一个字典
更新操作
update(query,updata,upsert=False,multi=False) update_many() update_one()
删除操作 remove(query,multi = True)
multi默认为True表示删除所有筛选内容 如果设置为False则表示删除一条
复合功能函数 find_one_and_delete()
索引操作 ensure_index() 创建索引 list_indexes() 查看索引 drop_index() 删除索引 drop_indexes() 删除所有索引
聚合操作 aggregate([]) 参数写法和mongo shell中聚合相同 返回值 ： 返回一个迭代游标 同find()
GridFS 程序提取
import gridfs
gridfs.GridFS(db)
插入二进制格式数据
import bson.binary
常用命令
> show dbs -- 查看数据库列表
> use admin --创建admin数据库，如果存在admin数据库则使用admin数据库
> db ---显示当前使用的数据库名称
> db.getName() ---显示当前使用的数据库名称
> db.dropDatabase() --删当前使用的数据库
> db.repairDatabase() --修复当前数据库
> db.version() --当前数据库版本
> db.getMongo() --查看当前数据库的链接机器地址
> db.stats() 显示当前数据库状态，包含数据库名称，集合个数，当前数据库大小 ...
> db.getCollectionNames() --查看数据库中有那些个集合（表）
> show collections --查看数据库中有那些个集合（表）
> db.person.drop() --删除当前集合（表）person
MongoDB预热，简单的增删改
首先我先介绍一点MongoDB的基本概念
1、MongoDB是NoSQL中面向文档的数据库，他是介于关系型数据库与非数据库之间的数据库产品。
2、MongoDB的文档，相当于关系数据库中的一行数据。
3、多个文档组成一个集合（collection），集合相当于关系数据库中的表
4、多个集合，组合在一起，就是一个数据库
5、一个运行的MongoDB Server支持多个数据库。
MongoDB中的插入Insert
首先打开cmd，输入Mongo进入shell界面
输入show dbs ，查看当前数据库为local。然后创建数据库，库名为fristdb，输入 use fristdb ，这样就相当于创建啦数据库。
note：
> db.people.insert({"name":"张龙豪","age",18}) 这一句由于{}里面的内容不是json结构的数据，不能插入数据库表（集合）people中。
> db.people.insert({"name":"张龙豪","age":18}) 这样文档格式没有错误，就插入成功，意思是在fristdb库中插入people集合（表），文档（行数据）为 {"name":"张龙豪","age":18}
> db.room.insert({"cmp":50,"tree":20}) 这一句又创建啦一个集合（表）插入文档（行数据）为{"cmp":50,"tree":20}
MongoDB中的查看select---find
note：首先我在peple集合中插入啦2条数据，一条是18岁，一条是20岁。
> db.peple.find() 查出peple集合中的所有的文档
> db.peple.find({"age":18}) 查出peple集合中年龄为18的一条文档。
MongoDB中的修改update
Note：这个看图，我就不罗嗦啦，update({},{}),前面一个是查询条件，后面是修改后的数据文档
MongoDB中的删除delete--remove
Note：删除后剩下一条张龙豪20的数据
前言
前几篇，老玩家绕道即可，新手晚上闲着也是蛋疼，不如把命令敲一边，这样你就会对MongoDB有一定的掌握啦。如果没有安装MongoDB去看我的上一篇博客 MongoDB下载安装与简单增删改查
前奏：启动mongdb数据库服务，并进入shell界面
> cmd
> cd C:\Program Files\MongoDB\bin --进入mongdb安装文件的bin目录下。
> net start mongoDB; --开启mongoDB数据库服务
> mongo --进入shell界面
首先我先介绍一点MongoDB的基本概念
1、MongoDB是NoSQL中面向文档的数据库，他是介于关系型数据库与非数据库之间的数据库产品。
2、MongoDB的文档，相当于关系数据库中的一行数据。
3、多个文档组成一个集合（collection），集合相当于关系数据库中的表
4、多个集合，组合在一起，就是一个数据库
5、一个运行的MongoDB Server支持多个数据库。
常用命令
> show dbs -- 查看数据库列表
> use admin --创建admin数据库，如果存在admin数据库则使用admin数据库
> db ---显示当前使用的数据库名称
> db.getName() ---显示当前使用的数据库名称
> db.dropDatabase() --删当前使用的数据库
> db.repairDatabase() --修复当前数据库
> db.version() --当前数据库版本
> db.getMongo() --查看当前数据库的链接机器地址
> db.stats() 显示当前数据库状态，包含数据库名称，集合个数，当前数据库大小 ...
> db.getCollectionNames() --查看数据库中有那些个集合（表）
> show collections --查看数据库中有那些个集合（表）
> db.person.drop() --删除当前集合（表）person
MongoDB接入Javascrip风格语法，for，while，next，hasNext，forEach，toArray，findOne，limit
Note:
1、p={name:"张龙豪"，age:18} 这个不是规范的json格式，使用这种类似javascript语法，对象会自动补全为规范的json格式{"name":"张龙豪","age":18}.
2、我在这里插入2条数据，一条是insert语法，一条是save语法，这里的insert与save是一样的功能。
Note:这里我主要用啦一个for语法，循环插入啦4条数据，是不是有点小激动。哈哈，mongodb就是这么任性。
Note：这里是吧查询出来的
1、while：作为程序员应该都不陌生他是个循环。
2、hasNext： cursor集合遍历，是否还有数据。
3、printjson：输出集合中的文档
4、next：当前文档，并向下遍历。
Note：forEach循环输入，必须定义一个函数供每个游标元素调用。
Note：游标也可以当作数组来用。
Note：游标转换为真实的数组类型，使用。
Note：findOne，返回结果集中的第一条数据。limit(3)，返回结果集中的前三条数据。
MongoDB中的高级查询
面向文档的NoSql数据库重要解决的问题不是高性能的并发读写问题，而是保证海量数据存储的同时，具有比一般数据库更加良好的查询性能。
Note:条件操作符号： > 、 < 、 >= 、<=
1、 $gt //大于 > ，$lt //小于 < ，$gte //大于等于 >= ,$lte //小于等于
2、{"filed":{$op,value}} //filed字段 ，$op条件操作符号，value值。
3、{"age":{$gt:1}} : person集合中年龄大于1的所有数据文档
Note:$all匹配所有，类似t-sql中的in，但是t-sql中的in是满足括号里面的任何一个都能出数据，而mongodb中的$all则必须满足[]中的所有值。
1、{age:{$all:[7,9]}}:age数组中只要有7和9就满足条件。如果只有7，没有9则不符合条件。
Note:$exists判断字段是否存在，（true/false）
1、{city:{$exists:true}}: 集合中存在city这个字段的数据
Note：$mod取模运算。
1、{age:{$mod:[7,6]}}:集合中模7余6的数据
Note：$ne不等于
Note:$in包含，$nin不包含。跟t-sql中的in，not in一样。
1、{age:{$in:[10,11]}}:如果age是数组的话，只要数组包含in中条件的任何一条数据，都能被检索出来。不是数组，则只要满足in中的任何一个条件数据，也可以被检索出来。
Note：数组元素个数。
1、{age:{$size:4}}:age数组元素个数为4的数据结果集。
Note:$not正则匹配，不包含以张开头的数据。
Note:skip,limit,sort,count
1、skip（2）:从数据集的第二条开始查询
2、limit(2) : 依次查出2条数据。
3、sort({age:1}) : 1.正序查询，-1倒叙查询。
4、count():结果集总数。
分类: MongoDB
参考网站
芒果数据库基本操作a1264716408的博客-CSDN博客芒果db查询
MongoDB下载安装与简单增删改查 - 张龙豪 - 博客园 (cnblogs.com)
MongoDB高级查询详细 - 张龙豪 - 博客园 (cnblogs.com)
MongoDB和java代码结合
package com.liujinghe.demo.mongodb;
import java.net.UnknownHostException;
import java.util.Date;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.MongoClient;
import com.mongodb.MongoException;
public class Demo {
public static void main(String[] args) {
try {
/**** Connect to MongoDB ****/
// Since 2.10.0, uses MongoClient
//（MongoClient类的实例）一个带有内部连接池的MongoDB客户端
MongoClient mongo = new MongoClient("localhost", 27017);
/**** Get database ****/
// if database doesn't exists, MongoDB will create it for you
//创建名为yihaomen的数据库
DB db = mongo.getDB("yihaomen");
/**** Get collection / table from 'yihaomen' ****/
// if collection doesn't exists, MongoDB will create it for you
//创建集合（表）
DBCollection table = db.getCollection("crudCollection");
/**** Insert ****/
// create a document to store key and value
//创建BasicDBObject对象，将代码对象转换为json数据
BasicDBObject document = new BasicDBObject();
document.put("name", "yihaomen");
document.put("age", 30);
document.put("createdDate", new Date());
//向芒果db中插入数据
table.insert(document);
/**** Find and display ****/
//创建BasicDBObject对象，将代码对象转换为json数据
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", "yihaomen");
//从芒果db中查询数据，返回结果放入DBCursor
DBCursor cursor = table.find(searchQuery);
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
/**** Update ****/
// search document where name="yihaomen" and update it with new values
//创建BasicDBObject对象，将代码对象转换为json数据
//要修改的对象
BasicDBObject query = new BasicDBObject();
query.put("name", "yihaomen");
//修改后的对象
BasicDBObject newDocument = new BasicDBObject();
newDocument.put("name", "yihaomen-updated");
//修改条件
BasicDBObject updateObj = new BasicDBObject();
updateObj.put("$set", newDocument);
//芒果db修改操作
table.update(query, updateObj);
/**** Find and display ****/
BasicDBObject searchQuery2
= new BasicDBObject().append("name", "yihaomen-updated");
DBCursor cursor2 = table.find(searchQuery2);
while (cursor2.hasNext()) {
System.out.println(cursor2.next());
}
/**** Remove test ****/
//删除操作
//BasicDBObject delDocument = new BasicDBObject();
//newDocument.put("name", "yihaomen-updated");
//table.remove(delDocument);
/**** Done ****/
System.out.println("Done");
}
// } catch (UnknownHostException e) {
// e.printStackTrace();
// }
catch (MongoException e) {
e.printStackTrace();
}
}
}
2540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
