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、聚合操做