MongoDB安装

一、安装

redis:端口6379
MongoDB：端口27017
MYsql：
1    金老板    18    15512351234
2    小哪吒    20    15312341234
3    Alex    73    15512341234

MongoDB：
{
    {
        id : 1,
        name:金老板,
        age : 18,
        phone:15512351234
    },
    {
        ids : 1,
        names:金老板,
        ages : 18,
        phones:15512351234
    }
}

1.MongoDB的启动 CMD ：
mongod --dbpath="D:/data/db/"
客户端 : mongo

2.指令
show databases - 显示数据库（在磁盘中存储的数据库）
db - 显示当前使用的数据库
use dbname - 切换使用中的数据库
-如果数据库不存在，在内存中创建一个数据库空间大小是0
db.user - 在当前数据库的内存中创建一个数据表空间 大小是0
show tables - 显示当前数据库中的数据表 (存放在磁盘中的)

在MongoDB - 使用了不存在的对象，即创建该对象

3.MongoDB的增删改查：
增加数据： 不推荐写法
db.user_info.insert({
    "name":"alexdsb",
    "age":73
}) 
多条增加： 不推荐写法
db.user_info.insert([{"name":1},{"name":3},{"name":2}])

官方推荐写法：
db.user_info.insertOne({})
db.user_info.insertMany([{},{}])

查找数据：
db.user_info.find({})
db.user_info.find({"age":73})
db.user_info.findOne({"age":73})

修改数据: 官方不推荐 // 修改器：$set 
db.user_info.update({"age":73}, {$set:{"name":"JWB"}})

官方推荐
db.user_info.updateOne({"age":73}, {$set:{"name":"JWB"}})
db.user_info.updateMany({"age":73}, {$set:{"name":"JWB"}})


删除数据:官方不推荐
db.user_info.remove({name:111})
官方推荐
db.user_info.deleteOne({name:1})
db.user_info.deleteMany({name:1})


_id = ObjectID 关系型数据库中的 自增ID 以数据库为核心的自增
表为核心的自增ID
user - book
1        1
2        2
3        3

数据库为核心的自增ID ObjectID宇宙唯一的
user - book - auth
1        4        7
2        5        8
3        6        9
10        11        12
13        14        15


4.数据类型：
ObjectID 自动创建的 一个字符串 Documents 自生成的 _id
String 字符串类型 不需要限定长度的
Boolean：布尔值，true 或者false
Double:浮点数 (没有float类型,所有小数都是Double) !float是不存在的
Integer:整型 数据类型
Arrays：[] 数组类型  在python中就是个列表 
Object：{} 对象类型     在python中就是个字典     在其他语言中叫 Object 
Null == None 
时间数据类型 - Timestamp - Date

5.MongoDB与关系型数据库概念的变差：
关系型数据库        MongoDB
database            database
table                Collections
row                    Documents
Colunm数据列        Field


6.MongoDB修改器 
1.$set 强制修改 {$set:{"name":1}} == (dict["key"] = value)
1.5. $unset 删除Key 删除Field  （del dict["key"]）
db.school.updateOne({"school_name":"OldBoy"},{$unset:{"student_list":1}})

2.$inc 引用增加 db.user_info.updateMany({},{$inc:{"age":1}})

# 针对Array的操作
3.$push 在Array中增加一条数据
db.school.updateOne({"class_name":"S16"},{$push: {student_list:{"name":"JSJ","age":25,"gender":"Null"}}})
$pushAll 在Array中添加多条数据 db.school.updateOne({"type":"list"},{$pushAll:{"num_list":["a","b","c"]}})

4.$pull [].remove 在Array中删除符合条件的元素 
db.school.updateOne({"type":"list"},{$pull:{"num_list":2}})
db.school.updateOne({"school_name":"OldBoy"},{$pull:{"student_list":{"name":"JSJ"}}})
$pullAll 在Array中删除所有符合条件的元素
db.school.updateOne({"type":"list"},{$pullAll:{"num_list":[1,2,3]}})

5.$pop [].pop() 删除Array中的第一条或最后一条
db.school.updateOne({"student_list.name":"JSJ"},{$pop: {"student_list":-1}}) -1:第一个
db.school.updateOne({"student_list.name":"JSJ"},{$pop: {"student_list":1}}) 1: 最后一个


7.$ 字符 
存储符合条件Array中元素的下标索引


8.针对Object的更新操作
db.school.updateOne({"school_name":"OldBoy"},{$set:{"student.age":84}})
db.school.updateOne({"school_name":"OldBoy"},{$inc:{"student.age":1}})

9.$数学比较符
$lt     <
$gt     >
$lte     <=
$gte     >=
$eq  :     == db.school.find({"age":{"$eq":3}})
$ne     != db.school.find({"age":{"$ne":3}})

10.条件分隔：
and ：db.school.find({"class_name":"S16","school_name":"OldBoy"}) 
db.school.find({$and: [{"school_name":"OldBoy"},{"class_name":"S16"}]})
or ：db.school.find({$or:[{"school_name":"OldBoy"},{"class_name":"S16"}]}) 不同字段的or
in : db.school.find({"school_name":{"$in":["OldBoy","OldBoySZ"]}}) 相同字段的or
all : db.school.find({"userlist":{$all:[4,3,2]}}) 子集查询

11.limit sort skip 
// limit 选取
db.school.find({}).limit(5)

// skip 跳过
db.school.find({}).skip(5)

// sort 排序
db.school.find({}).sort({ age:-1 })
db.school.find({}).sort({ age:1 })


// 跳过 选取
db.school.find({}).skip(5).limit(5)
db.school.find({}).limit(5).skip(5)

// 排序 跳过 选取
db.school.find({}).limit(5).skip(5).sort({ age:-1 })

// 分页 每页3条
// 第一页
db.school.find({}).limit(3).skip(0).sort({ _id:1 })  // (page - 1) * 3
// 第二页
db.school.find({}).limit(3).skip(3).sort({ _id:1 })  // (page - 1) * 3
// 第三页
db.school.find({}).limit(3).skip(6).sort({ _id:1 })  // (page - 1) * 3



12.pymongo - 使用python操作MongoDB

import pymongo

mongo_client = pymongo.MongoClient(host="127.0.0.1",port=27017)

DB = mongo_client["users"]

# 1.查询
# res = list(DB.school.find())
# res = DB.school.find_one({"class_name":"S16"},{"_id":0,"student":1})
# res = DB.school.find_one({"class_name":"S16"})
# res = DB.school.find_one({"student.name":"Alex"})
# res = DB.school.find_one({'$or':[{"class_name":"S16"},{"school_name":"OldBoy"}]})
# res = DB.school.find_one({"userlist":{"$all":[3,4,2]}})
# print(res)
# res["_id"] = str(res.get("_id"))
# import json
# a = json.dumps(res)
# print(a)

# 2.增加数据
# res = DB.school.insert_one({"name":1})
# print(res,res.inserted_id,type(res.inserted_id))
# res = DB.school.insert_many([{"name":3},{"name":4},{"name":5}])
# print(res,res.inserted_ids)
# 奇葩数据
# res = DB.oldboy.insert_one({"user_list":[{"hobby":["抽烟","喝酒"]},{"hobby":[{"name":"car","type":"SUV"},{"name":"motor","type":"BMW"}]}]})


# 3.修改数据
# $ 存储 array 符合条件元素的下标索引
# from bson import ObjectId
# res = DB.school.update_one({"_id":ObjectId("5c7e280ed0df65358812ccab")},{"$push":{"userlist":888}})
# res = DB.school.update_one({"userlist":888},{"$set":{"userlist.$":666}})
# res = DB.school.update_one({"userlist":666},{"$set":{"userlist.0":888}})
# print(res,res.modified_count)
"""
{
    "_id" : ObjectId("5c7e3fcbd3620e1130463178"),
    "user_list" : [
        {
        "hobby" : [
            "抽烟",
            "喝酒"
        ]
    },
        {
        "hobby" : [
            {
            "name" : "car",
            "type" : "SUV"
        },
            {
            "name" : "motor",
            "type" : "BMW"
        }
        ]
    }
    ]
}
"""
# res = DB.oldboy.find_one({})
# print(res)
# for index,item in enumerate(res.get("user_list")):
#     for hobby,hobby_item in enumerate(item.get("hobby")):
#         if type(hobby_item) == dict:
#             if hobby_item.get("name") == "motor":
#                 res["user_list"][index]["hobby"][hobby]["type"] = "Suzuki"
#
# DB.oldboy.update_one({"_id":res.get("_id")},{"$set":res})

# 4.删除
# from bson import ObjectId
# res = DB.oldboy.delete_one({'_id': ObjectId('5c7e3fcbd3620e1130463178')})
# print(res,dir(res),res.deleted_count)


# 选取 跳过 排序
# res = list(DB.school.find().limit(5).skip(5))
# print(res,len(res))

# 排序
# res = list(DB.school.find().limit(5).skip(5).sort("_id",pymongo.ASCENDING))
# res = list(DB.school.find().limit(5).skip(5).sort("_id",pymongo.DESCENDING))
# print(res,len(res))

MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。

MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。

它和我们使用的关系型数据库最大的区别就是约束性,可以说文件型数据库几乎不存在约束性,理论上没有主外键约束,没有存储的数据类型约束等等

关系型数据库中有一个 "表" 的概念,有 "字段" 的概念,有 "数据条目" 的概念

MongoDB中也同样有以上的概念,但是名称发生了一些变化,严格意义上来说,两者的概念即为相似,但又有些出入,不过无所谓,我们就当是以上概念就好啦

这是我们用关系型数据库做的一张很简单的User表

接下来我们再看一下MongoDB的数据结构:

MongoDB的每个表(Collection)中存储的每条数据(Documents)都是一个一个的Json,Json中的每一个字段(Key)我们称之为:Field

就此我们引出了三个关键字,Collection也就是关系型数据库中"表"的概念,Documents就是"数据条目",Field就是"字段"

MongoDB安装

安装完成之后,开始进入配置环节,首先我们要进入目录:

"C:\Program Files\MongoDB\Server\3.4\bin"

配置环境变量:

windows 7 在这里需要注意的是,Path路径移动到最后,输入:"  ;C:\Program Files\MongoDB\Server\3.4\bin  " 一定要带上 "  ; "

那我们来创建一个" C:\data\db\ "的目录吧

好了开启成功了

那么服务开启了,客户端怎么去连接呢,这时我们需要另一个cmd窗口开启mongo的客户端

千万别把这两个cmd窗口关了,不然你还得重新打开一次!!!!

二、增删改查

1.MongoDB操作 之 原生ORM,根本不存在SQL语句

创建数据库:这里和一般的关系型数据库一样,都要先建立一个自己的数据库空间

MongoDB设计的比较随意,没有就认为你是在创建,use LuffyCity_Com是不存在的,所以MongoDB就认为你是要创建并使用

这个概念一定要记清楚,MongoDB中如果你使用了不存在的对象,那么就等于你在创建这个对象

使用了不存在的对象,就代表创建对象,我们使用这一谬论创建一张表(Collection)试试

看来真的不是谬论,真的成功的创建了一个Oldboy的Collection

2.MongoDB 之 插入数据(insert insertOne insertMany) 之 Collection 点儿出一切操作 之 insert

insert:插入一条或者多条数据,需要带有允许插入多条的参数,这个方法目前官方已经不推荐喽

db.Oldboy.insert({"name":"DragonFire","age":20})

insertOne: 插入一条数据,官方推荐

我们可以看出来两种方法的返回值截然不同对吧

insertMany:插入多条数据,无需参数控制,官方推荐

这就是我们向LuffyCity_Com.Oldboy中插入了多条数据:

[{
  "name":"DragonFire",
  "age":20    
},

{
　"name":"WuSir",
　"age":19
}]

3.MongoDB之查询数据(find findOne) 之 这里没有findMany

这里不是select,如果你的第一反应是select 证明你关系型数据库没白学

find() 无条件查找:将该表(Collection)中所有的数据一次性返回

db.Oldboy.find({name:"WuSir2b"}) 条件查找:name等于WuSir2b的数据,这里会返回多条结果

说到这里,有的同学不禁要问一下:"_id":ObjectId("乱七八糟一道对看着毫无关系的一对字符串") 是什么,我们插入的时候并没有一个字段(Field)并没有_id这个,

对了这就是MongoDB自动给我们添加到系统唯一标识"_id" 是一个ObjectId 类型。

findOne()无条件查找一条数据,默认当前Collection中的第一条数据

findOne({age:19}) : 条件查找一条age等于19的数据,如有多条数据则返回更靠前的数据

查询数据的时候,发现了有些数据出现错误了,要修改怎么办呢?

4.MongoDB 之 修改数据(update updateOne updateMany) 之 跟insert一样,不推荐update的写法

update({"name":"DragonFire"},{$set:{"age":21}}):根据条件修改该条数据的内容

把name等于DragonFire中的age改为21,这里要注意的是({"条件"},{"关键字":{"修改内容"}}),其中如果条件为空,那么将会修改Collection中所有的数据

updateOne({"age":19},{$set:{"name":"WSSB"}}):根据条件修改一条数据的内容,如出现多条,只修改最高前的数据

把age等于19的所有数据中第一条数据的name改为WSSB

updateMany({"age":19},{$set:{"name":"pig_qi"}}):根据条件修改所有数据的内容,多条修改

把age等于19的所有数据中的name改为WSSB

$set:{"name":"WSSB"} $set 是update时的关键字,表示我要设置name属性的值为"WSSB"

那么我们之前说过MongoDB的灵活性,没有就代表我要创建,所以说如果该条Documents没有name属性,他就会自动创建一个name属性并且赋值为"WSSB"

5.MongoDB之删除数据(remove)

remove({}):无条件删除数据,这里要注意了,这是删除所有数据,清空Collection

 

remove({"name":"DragonFire"}) : 条件删除name等于"DragonFire"的所有Document

三、数据类型

Object  ID ：Documents 自生成的 _id

String： 字符串，最常用，必须是utf-8

Boolean：布尔值，true 或者false (Python中 True False 首字母大写)

Integer：整数(Int32 Int64 一般我们用Int32)

Double：浮点数(没有float类型,所有小数都是Double)

Arrays：数组或者列表，多个值存储到一个键(Python中的List)

Object：用于嵌入文档，即一个值为一个文档(Python中的字典)

Null：空数据类型 , 一个特殊的概念,None Null

Timestamp：时间戳

Date：存储当前日期或时间unix时间格式(我们一般不用这个Date类型,时间戳可以秒杀一切时间类型)

MongoDB 之 剖析MongoDB的数据类型

那么我们根据以上所说的数据类型展开说明:

1.Object ID :

"_id" : ObjectId("5b151f8536409809ab2e6b26")

#"5b151f85" 代指的是时间戳,这条数据的产生时间
#"364098" 代指某台机器的机器码,存储这条数据时的机器编号
#"09ab" 代指进程ID,多进程存储数据的时候,非常有用的
#"2e6b26" 代指计数器,这里要注意的是,计数器的数字可能会出现重复,不是唯一的
#以上四种标识符拼凑成世界上唯一的ObjectID
#只要是支持MongoDB的语言,都会有一个或多个方法,对ObjectID进行转换
#可以得到以上四种信息

#注意:这个类型是不可以被JSON序列化的

这是MongoDB生成的类似关系型DB表主键的唯一key，具体由24个字节组成：

0-8字节是时间戳,

9-14字节的机器标识符，表示MongoDB实例所在机器的不同；

15-18字节的进程id，表示相同机器的不同MongoDB进程。

19-24字节是计数器

2.String :

UTF-8字符串,记住是UTF-8字符串

3.Boolean :

true or false 这里首字母是小写的

4.Integer :

整数 (Int32 Int64 你们就知道有个Int就行了,一般我们用Int32)

5.Double :

浮点数 (MongoDB中没有float类型,所有小数都是Double)

6.Arrays :

{
    "_id" : ObjectId("5b163830993ddc4cd4918ead"),
    "name" : "LuffyCity",
    "teacher" : [
        "DragonFire",
        "WuSir2B",
        "Alex AGod"
    ]
}

数组或者列表，多个值存储到一个键 (list哦,大Python中的List哦

7.Object :

{
    "_id" : ObjectId("5b163915993ddc4cd4918eaf"),
    "name" : "LuffyCity",
    "course" : {
        "name" : "Python",
        "price" : 19800
    }
}

8.Null :

{
    "_id" : ObjectId("5b163a0e993ddc4cd4918eb0"),
    "name" : "LuffyCity",
    "course" : null
}

空数据类型 , 一个特殊的概念,None Null

9.Timestamp :时间戳

{
    "_id" : ObjectId("5b163bbf993ddc4cd4918eb3"),
    "name" : "LuffyCity",
    "date" : 1528183743111
}

10.Date :

{
    "_id" : ObjectId("5b163ba1993ddc4cd4918eb2"),
    "name" : "LuffyCity",
    "date" : ISODate("2018-06-05T15:28:33.705+08:00")
}

存储当前日期或时间格式 (我们一般很少使用这个Date类型,因为时间戳可以秒杀一切时间类型)

四、$关键字及$修改器 $set $inc $push $pull $pop

MongoDB中类似这样的关键字有很多, $lt $gt $lte $gte 等等,这里我们说说几个比较常见的

1、查询中常见的 等于 大于 小于 大于等于 小于等于

等于 : 在MongoDB中什么字段等于什么值其实就是 " : " 来搞定 比如 "name" : "路飞学城"

大于 : 在MongoDB中的 大于 > 号 我们用 : $gt  比如 :  "score" : { $gt : 80 } 就是 得到 "score" 大于 80 的数据

小于 : 在MongoDB中的 小于 < 号 我们用 : $lt  比如 :  "score" : { $lt : 80 } 就是 得到 "score" 小于 80 的数据

大于等于 : 在MongoDB中的 大于等于 >= 号 我们用 : $gte  比如 :  "score" : { $gte : 80 } 就是 得到 "score" 大于等于 80 的数据

小于等于 : 在MongoDB中的 小于等于 <= 号 我们用 : $lte  比如 :  "score" : { $lte : 80 } 就是 得到 "score" 小于等于 80 的数据

这就是MongoDB中的运算符,是不是很类似我们使用的ORM中的运算符啊,没错,最开始的时候我们就已经说了,MongoDB的操作就是很类似ORM的

2.MongoDB中的那些个update修改器: $inc $set $unset $push $pull

在此前的update中,我们用过$set,对数据进行过更新,其实在update中还存在很多的$关键字,我们把update中的这些关键字叫做 修改器

修改器很多,这里挑一些重要的来说一说:

1.$inc : Python中的  变量 += 1 , 将查询到的结果 加上某一个值 然后保存

还是刚才Collection数据,我们来试一下$inc , 让不及格的 "路飞学城2" 变成 60 分

成功了 , {$inc:{"score":1}}的意思是,"score"的原有数值上面 +1,那我们再来实验一次,把60改为20,这怎么操作呢,其实可以理解为在 60 上加一个 -40

{$inc:{"score":-20}} $inc 就是原有基础上在增加多少对吧

2.$set : 此前我们已经提到过 $set 的用法和特性(没有就自动添加一条)了

再做一个例子:把 "score" 为 100 分 的 "english_name" 赋值为 "LuffyCity"

再把 "score" 为 20 分的 "score" 赋值为 59 分

3.$unset : 用来删除Key(field)的

做一个小例子 : 刚才我们有一个新的"english_name" 这个field ,现在我们来删除它

成功了! {$unset:{"english_name" : 1}} 就是删除 "english_name" 这个 field 相当于 关系型数据库中删除了 字段

4. $push : 它是用来对Array (list)数据类型进行 增加 新元素的,相当于我们大Python中 list.append() 方法

做一个小例子 :首先我们要先对原有数据增加一个Array类型的field:

使用update $set 的方法只能为Document中的第一条添加

使用updateMany $set 的方法 可以为所有满足条件的 Document 添加 "test_list" , 注意我这里的条件为空 " {} " 就算是为空,也要写上"{}" 记住记住记住

接下来我们就要队列表进行添加了: 将 "score" 为 100 的Document 中"test_list" 添加一个 6

$push 是在 Array(list) 的尾端加入一个新的元素  {$push : {"test_list" : 6}}

5.$pull : 有了$push 对Array类型进行增加,就一定有办法对其内部进行删减,$pull 就是指定删除Array中的某一个元素

做一个例子: 把我们刚才$push进去的 6 删除掉

问题来了,如果 Array 数据类型中 如果有 多个 6 怎么办呢?

全部删掉了.....

得出了一个结论,只要满足条件,就会将Array中所有满足条件的数据全部清除掉

6. $pop : 指定删除Array中的第一个 或 最后一个 元素

做个小例子: 删除"score" 等于 100 分  test_list 的最后一个元素

怎么删除第一个呢?

{$pop:{"test_list" : -1}}  -1 代表最前面, 1 代表最后边 (这和Python正好相反) 记住

五、MongoDB 之 "$" 的奇妙用法

在MongoDB中有一个非常神奇的符号 "$"

"$" 在 update 中 加上关键字 就 变成了 修改器

其实 "$" 字符 独立出现也是有意义的 , 我起名叫做代指符

首先看个例子: 还是这个Collection

现在把 "score": 100 的 test_list 里面的 2 改为 9

{$set :{"test_list.0" : 9}} 这样就是对应 Array 中的下标进行修改了 "test_list.下标"

问题来了 如果 是 一个很长很长很长的 Array 你要查找其中一个值,把这个值修改一下怎么整呢?

神奇不神奇?

$ 字符 在语句中代表了什么呢? 下标,位置

解释一下: 首先我们查询一下db.Oldboy.findOne({"score":100,"test_list":3}) 返回 给我们满足条件的数据对吧

那么 如果 我们 使用 update的话, 满足条件的数据下标位置就会传递到 $ 字符中,在我们更新操作的时候就相当于 对这个位置 的元素进行操作

六、MongoDB 之 Array Object 的特殊操作

相比关系型数据库, Array [1,2,3,4,5] 和 Object { 'name':'DragonFire' } 是MongoDB 比较特殊的类型了

那我们先建立一条数据,包含 Array 和 Object 类型

db.Oldboy.insert({"name":"路飞学城-骑士计划","price":[19800,19500,19000,18800],"other":{"start":"2018年8月1日","start_time":"08:30","count":150}})

{
    "_id" : ObjectId("5b17d01a49bf137b585df891"),
    "name" : "路飞学城-骑士计划",
    "price" : [
        19800,
        19500,
        19000,
        18800
    ],
    "other" : {
        "start" : "2018年8月1日",
        "start_time" : "08:30",
        "count" : 150
    }
}

1、Array

1.把price 中 19000 改为 19300

db.Oldboy.update({"name":"路飞学城-骑士计划"},{$set:{"price.2":19300}})

我们用了引用下标的方法更改了数值 , "price.2"代指的是 Array 中第3个元素

2. 混合用法

如果 price.1 中小于19800 则加 200

db.Oldboy.update({"name":"路飞学城-骑士计划","price.1":{$lt:19800}},{$inc:{"price.1":200}})

复习一下:"price.1":{$lt:19800} 是查找 price.1 小于 19800

复习两下:{$inc:{"price.1":200}}是 price.1 拿出来 加上 200 之后 再存进去

混搭 $ 再做一个练习

我们把 price 小于 19500  的 自动补上 200

db.Oldboy.updateMany({"name":"路飞学城-骑士计划","price":{$lt:19500}},{$inc:{"price.$":200}})

细心的同学已经发现了,只改了第一个,是的 $ 这个只储存一个下标,批量更改的话,截至2017年1月1日,MongoDB没有这个功能

你只要把这个Array 拿出来,在程序里面改完,原方不动的放回去不就搞定了吗

2、Object

这里更像是 JavaScript 中的 Object 对象

1.把other中 count 改为 199

db.Oldboy.update({"name":"路飞学城-骑士计划"},{$set:{"other.count":199}})

对了就是在这个对象 打点儿 key 就可以更改数值了 , 要注意的是, 咱们用的 $set 进行修改的,那么就意味着,如果没有"other.count"这个field的话,他会自动创建.

2.混合用法

如果 count 小于 200 那么 加 10

3、Array + Object 的用法

首先,我们要先建立一条 Document

{
    "_id" : ObjectId("5b17de9d44280738145722b9"),
    "name" : "路飞学城-骑士计划",
    "price" : [
        {
            "start" : "2018年8月1日",
            "start_time" : "08:30",
            "count" : 150
        },
        {
            "start" : "2018年8月2日",
            "start_time" : "09:30",
            "count" : 160
        },
        {
            "start" : "2018年8月3日",
            "start_time" : "10:30",
            "count" : 170
        },
        {
            "start" : "2018年8月4日",
            "start_time" : "11:30",
            "count" : 180
        }
    ]
}

Document添加完成之后

1.把count 大于 175 的field  加 15

混搭完成:

db.Oldboy.update({"price.count":{$gt:175}},{$inc:{"price.$.count":15}})

分析一下我们的代码:

{"price.count":{$gt:175}}, price 明明是个 Array 啊 怎么就直接 打点儿 count 了呢 这里要知道price 打点儿 就是从内部的Object 中找到 count 小于 175 的结果

{$inc:{"price.$.count":15}} ,  这里就比较好理解了,price里面第 $ (大于175的第一个) 个元素中 count 增加 15

2. 把 count 大于 180 的 start 改为 "2018年8月10日"

七、MongoDB 之 Limit 选取 Skip 跳过 Sort 排序

在关系型数据库中的选取(limit),排序(sort) MongoDB中同样有,而且使用起来更是简单

首先我们看下添加几条Document进来

现在有四条Document：

1. Limit 选取 : 我要从这些 Document 中取出多少个

做个小例子 : 我只要 2 条 Document

limit(2) 就是选取两条Document, 从整个Collection的第一条 Document 开始选取两条

如果我们不想从第一条Document开始选取,怎么办呢?

2.Skip 跳过 : 我要跳过多少个Document

做个小例子 : 我要跳过前两个 Document 直接从第三个Document 开始

skip(2) 就是跳过两条Document, 从整个Collection 的第一条 Document 开始跳,往后跳两条

另一个例子 : 跳过第一条 直接从 第二条 开始

问题来了,我只想要第二条和第三条怎么处理呢?

3.Limit + Skip : 从这儿到那儿 的 选取

就是刚才的问题,一个小例子 : 我只想要第二条和第三条怎么处理呢

跳过第一条Document 从第二条开始选取两条 Document

另一种写法：

4. Sort 排序 : 将结果按照关键字排序

做个小例子 : 将find出来的Document 按照 price 进行 升序 | 降序 排列

按照 price 字段进行升序 , 1 为升序 , -1 为降序

5. Limit + Skip + Sort 混搭来一把

一个例子 : 选取第二条第三条 并 按照 price 进行 升序排列

问题出现了, 按道理不应该是 9800 然后 19800 吗?

知识点来喽

重点 : Sort + Skip + Limit 是有执行优先级的 他们的界别分别是 优先 Sort  其次 Skip 最后 Limt

Skip + Limit 的优先级 也是先 Skip 再 Limit

开启数据库服务

• MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。
• MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。
• 它和关系型数据库最大的区别就是约束性,可以说文件型数据库几乎不存在约束性,理论上没有主外键约束,没有存储的数据类型约束等等
• MongoDB的每个表(Collection)中存储的每条数据(Documents)都是一个一个的Json,Json中的每一个字段(Key)称之为:Field
• 安装完成之后,开始进入配置环节,首先要进入目录: "C:\Program Files\MongoDB\Server\3.4\bin" 其中mongo.exe是客户端，mongod.exe是服务端
• 配置环境变量
• 打开cmd窗口: mongod 开启数据库服务
• 没有发现Data的存放目录，需要手动建立一个" C:\data\db\ "的目录 mkdir C:\data\db 创建目录

MongoDB的增删改查

• MongoDB操作 之 原生ORM,根本不存在SQL语句
• 创建数据库:这里和一般的关系型数据库一样,都要先建立一个自己的数据库空间
• MongoDB设计的比较随意,没有就认为是在创建,use LuffyCity_Com是不存在的,所以MongoDB就认为是要创建并使用 MongoDB中如果使用了不存在的对象,那么就等于在创建这个对象

增

• MongoDB 之 插入数据(insert insertOne insertMany)
• insert:插入一条或者多条数据,需要带有允许插入多条的参数,这个方法目前官方已经不推荐喽
• insertOne: 插入一条数据,官方推荐
• insertMany:插入多条数据,无需参数控制,官方推荐

删

• MongoDB 之 删除数据(remove)
• remove({}):无条件删除数据,这里要注意了,这是删除所有数据,清空Collection
• remove({"name":"DragonFire"}) : 条件删除name等于"DragonFire"的所有Document

改

• MongoDB 之 修改数据(update updateOne updateMany) 之 跟insert一样,不推荐update的写法
• update({"name":"DragonFire"},{$set:{"age":21}}):根据条件修改该条数据的内容
• 把name等于DragonFire中的age改为21,这里要注意的是({"条件"},{"关键字":{"修改内容"}}),其中如果条件为空,那么将会修改Collection中所有的数据
• updateOne({"age":19},{$set:{"name":"WSSB"}}):根据条件修改一条数据的内容,如出现多条,只修改最高前的数据 把age等于19的所有数据中第一条数据的name改为WSSB
• updateMany({"age":19},{$set:{"name":"pig_qi"}}):根据条件修改所有数据的内容,多条修改 把age等于19的所有数据中的name改为WSSB
• $set:{"name":"WSSB"} $set 是update时的关键字,表示要设置name属性的值为"WSSB"
• MongoDB的灵活性,没有就代表要创建,所以说如果该条Documents没有name属性,他就会自动创建一个name属性并且赋值为"WSSB"

查

• MongoDB 之 查询数据(find findOne) 之 这里没有findMany
• find() 无条件查找:将该表(Collection)中所有的数据一次性返回
• db.Oldboy.find({name:"WuSir2b"}) 条件查找:name等于WuSir2b的数据,这里可能会返回多条结果
• MongoDB自动给我们添加到系统唯一标识"_id" 是一个ObjectId 类型
• findOne()无条件查找一条数据,默认当前Collection中的第一条数据
• findOne({age:19}) : 条件查找一条age等于19的数据,如有多条数据则返回更靠前的数据

mongoDB之数据类型

• Object ID ：Documents 自生成的 _id
• String： 字符串，必须是utf-8
• Boolean：布尔值，true 或者false (在Python中 True False 首字母大写)
• Integer：整数 (Int32 Int64 知道有个Int就行了,一般用Int32)
• Double：浮点数 (没有float类型,所有小数都是Double)
• Arrays：数组或者列表，多个值存储到一个键 (Python中的List)
• Object：(Python中的字典)
• Null：空数据类型 , 一个特殊的概念,None Null
• Timestamp：时间戳
• Date：存储当前日期或时间unix时间格式 (一般不用这个Date类型,时间戳可以秒杀一切时间类型)

这是MongoDB生成的类似关系型DB表主键的唯一key，具体由24个字节组成：
0-8字节是时间戳,
9-14字节的机器标识符，表示MongoDB实例所在机器的不同；
15-18字节的进程id，表示相同机器的不同MongoDB进程。
19-24字节是计数器

"_id" : ObjectId("5b151f8536409809ab2e6b26")
#"5b151f85" 代指的是时间戳,这条数据的产生时间
#"364098" 代指某台机器的机器码,存储这条数据时的机器编号
#"09ab" 代指进程ID,多进程存储数据的时候,非常有用的
#"2e6b26" 代指计数器,这里要注意的是,计数器的数字可能会出现重复,不是唯一的
#以上四种标识符拼凑成世界上唯一的ObjectID
#只要是支持MongoDB的语言,都会有一个或多个方法,对ObjectID进行转换
#可以得到以上四种信息

#注意:这个类型是不可以被JSON序列化的

MongoDB 之 $关键字 及 $修改器

• MongoDB中的运算符：$lt小于 $gt大于 $lte小于等于 $gte大于等于
• MongoDB中的那些个update修改器: $inc $set $unset $push $pull $pop
• 在此前的update中,我们用过$set,对数据进行过更新,其实在update中还存在很多的$关键字,我们把update中的这些关键字叫做修改器
• $inc : Python中的 变量 += 1 , 将查询到的结果 加上某一个值 然后保存
• {$inc:{"score":1}}的意思是,"score"的原有数值上面 +1,怎么把60改为20,其实可以理解为在 60 上加一个 -40
• $set : 此前我们已经提到过 $set 的用法和特性(没有就自动添加一条)了
• $unset : 用来删除Key(field)的， {$unset:{"english_name" : 1}} 就是删除 "english_name" 这个 field 相当于关系型数据库中删除了字段
• $push : 它是用来对Array (list)数据类型尾端进行增加新元素的,相当于Python中list.append()方法
• 使用update $set 的方法只能为Document中的第一条添加
• 使用updateMany $set 的方法 可以为所有满足条件的 Document 添加 "test_list" , 注意我这里的条件为空 " {} " 就算是为空,也要写上"{}"
• $pull : 有了$push 对Array类型进行增加,就一定有办法对其内部进行删减,$pull 就是指定删除Array中的某一个元素,只要满足条件,就会将Array中所有满足条件的数据全部清除掉
• $pop : 指定删除Array中的第一个 或 最后一个 元素,{$pop:{"test_list" : -1}} -1 代表最前面, 1 代表最后边 (这和Python正好相反)

MongoDB 之 "$" 的奇妙用法

• "$" 在 update 中 加上关键字 就 变成了 修改器
• 其实 "$" 字符 独立出现也是有意义的 , 起名叫做代指符
• {$set :{"test_list.0" : 9}} 这样就是对应 Array 中的下标进行修改了 "test_list.下标"
• $ 字符 在语句中代表了下标,位置,使用 update的话, 满足条件的数据下标位置就会传递到 $ 字符中,在更新操作的时候就相当于对这个位置的元素进行操作

MongoDB 之 Array Object 的特殊操作

• 把price 中 19000 改为 19300,db.Oldboy.update({"name":"路飞学城-骑士计划"},{$set:{"price.2":19300}})
• 把 price 小于 19500 的 自动补上 200,$ 这个只储存一个下标
• db.Oldboy.update({"name":"路飞学城-骑士计划"},{$set:{"other.count":199}}) 对了就是在这个对象 打点儿 key 就可以更改数值了 , 要注意的是, 咱们用的 $set 进行修改的,那么就意味着,如果没有"other.count"这个field的话,他会自动创建
• Array + Object 的用法

把count 大于 175 的field 加 15

• db.Oldboy.update({"price.count":{$gt:175}},{$inc:{"price.$.count":15}})
• 分析一下代码:
• {"price.count":{$gt:175}}, price 明明是个 Array 啊 怎么就直接 打点儿 count 了呢 这里要知道price 打点儿 就是从内部的Object 中找到 count 小于 175 的结果
• {$inc:{"price.$.count":15}} , 这里就比较好理解了,price里面第 $ (大于175的第一个) 个元素中 count 增加 15

把 count 大于 180 的 start 改为 "2018年8月10日"

MongoDB 之 Limit 选取 Skip 跳过 Sort 排序

• Limit 选取 : 从 Document 中取出多少个
• Skip 跳过 : 跳过多少个Document
• Limit + Skip : 从这儿到那儿 的 选取
• Sort 排序 : 将结果按照关键字排序,1 为升序 , -1 为降序
• Sort + Skip + Limit 是有执行优先级的 他们的界别分别是 优先 Sort 其次 Skip 最后 Limt Skip + Limit 的优先级 也是先 Skip 再 Limit