python 全棧開發，Day124(MongoDB初識,增刪改查操做,數據類型,$關鍵字以及$修改器,"$"的奇妙用法,Array Object 的特殊操做,選取跳過排序,客戶端操做)

時間 2019-11-13

標籤 python 開發 day124 day mongodb 增刪數據類型關鍵字以及修改奇妙用法 array object 特殊選取跳過排序客戶端欄目 Python 简体版

原文原文鏈接

1、MongoDB初識

什麼是MongoDB

MongoDB 是一個基於分佈式文件存儲的數據庫。由 C++ 語言編寫。旨在爲 WEB 應用提供可擴展的高性能數據存儲解決方案。javascript

MongoDB 是一個介於關係數據庫和非關係數據庫之間的產品，是非關係數據庫當中功能最豐富，最像關係數據庫的。html

官方給出了以上的解釋,那麼綜上所述,馬德 F U C K ! 有效信息太少了(徹底沒用)java

那麼讓我來用人類的語言講述一下MongoDB吧python

它和咱們使用的關係型數據庫最大的區別就是約束性,能夠說文件型數據庫幾乎不存在約束性,理論上沒有主外鍵約束,沒有存儲的數據類型約束等等程序員

關係型數據庫中有一個 "表" 的概念,有 "字段" 的概念,有 "數據條目" 的概念web

MongoDB中也一樣有以上的概念,可是名稱發生了一些變化,嚴格意義上來講,二者的概念即爲類似,但又有些出入,不過無所謂,咱們就當是以上概念就好啦redis

光說的話,仍是有點兒模糊,就讓咱們來作一個小例子,進行一個對比吧sql

下面咱們作一張表:mongodb

這是咱們用關係型數據庫作的一張很簡單的User表對吧數據庫

接下來咱們再看一下MongoDB的數據結構:

User = [{
    "name": "武大郎",
    "age": 18,
    "gender": "男"
}, {
    "name": "孫悟空",
    "age": 100000,
    "gender": "男"
}, {
    "name": "蔡文姬",
    "age": 16,
    "gender": "女"
}]

這......這特麼不就是個列表,裏面放着三個字典嗎?你說的對,若是你理解成了列表和字典,那麼證實了你只會Python,在其餘語言中它又是別的類型了,咱們把這種類型的玩意兒,叫作:Json

那麼你就該恍然大悟了吧,MongoDB的每一個表(Collection)中存儲的每條數據(Documents)都是一個一個的Json,Json中的每個字段(Key)咱們稱之爲:Field

就此咱們引出了三個關鍵字,Collection也就是關係型數據庫中"表"的概念,Documents就是"數據條目",Field就是"字段"

這麼說，可能還不太明白。看下面的表

MySQL	MongoDB
DB	DB
Table	Colletions
字段	Field
row	Documents

MongoDB安裝

mongodb(主程序)
連接：https://pan.baidu.com/s/139_BqPbh0IPcDMPmkWnS8w 密碼：fybs

你必須得先安裝上數據庫才能繼續裝X

關於MongoDB的安裝,真的沒有難度,真的真的沒有難度,來跟着DragonFire一步一步操做,帶你Legendary

首先分享給你一個MongoDB 3.4的msi安裝包點擊這裏能夠下載哦(若是不能下載證實我還沒搞定分享msi,本身下載一個吧)

選擇默認安裝/選擇安裝

選擇安裝

安裝完成以後,開始進入配置環節,首先咱們要進入目錄:

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

帶着你配置環境變量,讓X裝的更加天然更加美:

以後的操做,windows 7 與 windows 10 不太同樣,大同小異啦

windows 10 一路到底的"肯定"

windows 7 在這裏須要注意的是,Path路徑移動到最後,輸入:" ;C:\Program Files\MongoDB\Server\3.4\bin " 必定要帶上 " ; " 哦

由於沒有找到windows 7 操做系統的計算機,因此這裏只能給windows 7 的同窗說聲抱歉了

OK!到了這裏咱們基本已經完成了部分操做了

咱們來試一下成果吧

打開cmd窗口進行一次ZB的操做吧

那咱們來建立一個" C:\data\db\ "的目錄吧

好了目錄已經有了,再次ZB試一下

好了開啓成功了

那麼服務開啓了,客戶端怎麼去鏈接呢,這時咱們須要另外一個cmd窗口開啓mongo的客戶端

到此,咱們成功的完成了,服務端的部署開啓,還有客戶端的連接,若是你還想繼續往下學習的話,我給你一句金玉良言

千萬別把這兩個cmd窗口關了,否則你還得從新打開一次,哈哈哈哈哈哈哈哈!!!!

本文參考連接：

http://www.javashuo.com/article/p-bblzgvab-hu.html

2、增刪改查操做

本章咱們來學習一下關於 MongoDB的增刪改查

MongoDB根本不存在SQL語句，操做它，須要使用ORM語法

建立數據庫

這裏和通常的關係型數據庫同樣,都要先創建一個本身的數據庫空間

嗯嗯嗯嗯,我感覺到了你心裏的驚呼,瞅瞅大家這些沒見過世面的樣子

是的,MongoDB設計的比較隨意,沒有就認爲你是在建立,use LuffyCity_Com是不存在的,因此MongoDB就認爲你是要建立並使用

這個概念必定要記清楚哦,MongoDB中若是你使用了不存在的對象,那麼就等於你在建立這個對象哦

使用了不存在的對象,就表明建立對象,咱們使用這一謬論建立一張表(Collection)試試

看來真的不是謬論,真的成功的建立了一個Oldboy的Collection

那麼接下來就是在表(Collection)中添加一條數據了,怎麼添加呢?

插入數據

insert(不推薦)

插入一條或者多條數據,須要帶有容許插入多條的參數,這個方法目前官方已經不推薦嘍

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

效果以下：

> db.Oldboy.insert({"name":"DragonFire","age":20})
WriteResult({ "nInserted" : 1 })

insertOne

插入一條數據,官方推薦

db.Oldboy.insertOne({"name":"WuSir","age":20})

效果以下：

> db.Oldboy.insertOne({"name":"WuSir","age":20})
{
        "acknowledged" : true,
        "insertedId" : ObjectId("5b98d462430c27444ccdd644")
}

咱們能夠看出來兩種方法的返回值大相徑庭對吧

insertMany

插入多條數據,無需參數控制,官方推薦

db.Oldboy.insertMany([{"name":"WuSir2","age":20},{"name":"WuSir3","age":20}])

效果以下：

> db.Oldboy.insertMany([{"name":"WuSir2","age":20},{"name":"WuSir3","age":20}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5b98d51b430c27444ccdd645"),
                ObjectId("5b98d51b430c27444ccdd646")
        ]
}

這就是咱們向LuffyCity_Com.Oldboy中插入了2條數據

這裏留下一個數據類型的懸念

插入完成就要查詢

查詢數據

主要是 (find findOne) ，這裏沒有findMany

find

這裏不是select,若是你的第一反應是select 證實你關係型數據庫沒白學

find() 無條件查找:將該表(Collection)中全部的數據一次性返回

> db.Oldboy.find()
{ "_id" : ObjectId("5b98d45a430c27444ccdd643"), "name" : "DragonFire", "age" : 20 }
{ "_id" : ObjectId("5b98d462430c27444ccdd644"), "name" : "WuSir", "age" : 20 }
{ "_id" : ObjectId("5b98d51b430c27444ccdd645"), "name" : "WuSir2", "age" : 20 }
{ "_id" : ObjectId("5b98d51b430c27444ccdd646"), "name" : "WuSir3", "age" : 20 }
>

條件查找:age等於20的數據,這裏會返回多條結果

> db.Oldboy.find({"age":20})
{ "_id" : ObjectId("5b98d45a430c27444ccdd643"), "name" : "DragonFire", "age" : 20 }
{ "_id" : ObjectId("5b98d462430c27444ccdd644"), "name" : "WuSir", "age" : 20 }
{ "_id" : ObjectId("5b98d51b430c27444ccdd645"), "name" : "WuSir2", "age" : 20 }
{ "_id" : ObjectId("5b98d51b430c27444ccdd646"), "name" : "WuSir3", "age" : 20 }

說到這裏,有的同窗不由要問一下:"_id":ObjectId("亂七八糟一道對看着毫無關係的一對字符串") 是什麼,咱們插入的時候並無一個字段(Field)並無_id這個,

對了這就是MongoDB自動給咱們添加到系統惟一標識"_id" 是一個ObjectId 類型,咱們會在數據類型中第一個說到他(MongoDB 之數據類型最無聊! But 最有用! MongoDB - 3)

findOne

findOne()無條件查找一條數據,默認當前Collection中的第一條數據

> db.Oldboy.findOne()
{
        "_id" : ObjectId("5b98d45a430c27444ccdd643"),
        "name" : "DragonFire",
        "age" : 20
}

條件查找一條age等於19的數據,若有多條數據則返回更靠前的數據

> db.Oldboy.findOne({"age":20})
{
        "_id" : ObjectId("5b98d45a430c27444ccdd643"),
        "name" : "DragonFire",
        "age" : 20
}

查詢數據的時候,發現了有些數據出現錯誤了,要修改怎麼辦呢?

修改數據

主要用到，(update updateOne updateMany) 之跟insert同樣,不推薦update的寫法

update(不推薦)

根據條件修改該條數據的內容

> db.Oldboy.update({"name":"DragonFire"},{$set:{"age":21}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

把name等於DragonFire中的age改成21,這裏要注意的是({"條件"},{"關鍵字":{"修改內容"}}),其中若是條件爲空,那麼將會修改Collection中全部的數據

關於$set關鍵字的解釋就是,本節最後再說,留個懸念

updateOne(推薦)

根據條件修改一條數據的內容,如出現多條,只修改最高前的數據

舉例：把age等於20的全部數據中第一條數據的name改成hello kitty

> db.Oldboy.updateOne({"age":20},{$set:{"name":"hello kitty"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

updateMany(推薦)

根據條件修改全部數據的內容,多條修改

舉例：把age等於20的全部數據中的name改成Elizabeth

> db.Oldboy.updateMany({"age":20},{$set:{"name":"Elizabeth"}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }

上述中有一個$set的懸念,這個懸念呀,可能要留到再日後一些了

可是$set:{"name":"Elizabeth"}我仍是要解釋一下: $set 是update時的關鍵字,表示我要設置name屬性的值爲"Elizabeth"

那麼咱們以前說過MongoDB的靈活性,沒有就表明我要建立,因此說若是該條Documents沒有name屬性,他就會自動建立一個name屬性而且賦值爲"Elizabeth"

更改了半天,我以爲,這些數據我都不想要了,該怎麼辦呢?

刪除數據

MongoDB提供了三個用於刪除操做的API，分別是：

db.collection.remove()
db.collection.deleteOne()
db.collection.deleteMany()

這三個API都支持一個過濾條件參數，用於匹配到知足條件的Document，而後進行刪除操做。

remove(不推薦)

remove() 方法已通過時了，如今官方推薦使用 deleteOne() 和 deleteMany() 方法。

remove({}):無條件刪除數據,這裏要注意了,這是刪除全部數據,清空Collection

固然了，我如今還不會操做！

remove還支持條件刪除

舉例：刪除name等於"DragonFire"的全部Document

> db.Oldboy.remove({"name":"DragonFire"})
WriteResult({ "nRemoved" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b9b556e57f4ea3828d6c60b"), "name" : "WuSir", "age" : 20 }
{ "_id" : ObjectId("5b9b558257f4ea3828d6c60c"), "name" : "WuSir2", "age" : 20 }
{ "_id" : ObjectId("5b9b558257f4ea3828d6c60d"), "name" : "WuSir3", "age" : 20 }

deleteOne(推薦)

刪除匹配到的全部的Document中的第一個

> db.Oldboy.deleteOne({"age":20})
{ "acknowledged" : true, "deletedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b9b558257f4ea3828d6c60c"), "name" : "WuSir2", "age" : 20 }
{ "_id" : ObjectId("5b9b558257f4ea3828d6c60d"), "name" : "WuSir3", "age" : 20 }

deleteMany(推薦)

刪除全部匹配到的Document

> db.Oldboy.deleteMany({"age":20})
{ "acknowledged" : true, "deletedCount" : 2 }
> db.Oldboy.find()
>

發現數據已經被清空了！

那麼到這裏呢,增刪改查就已經完事兒了

以後咱們來講一下MongoDB的數據類型,跟大家透漏一下,MongoDB的數據類型,老(te)有(bie)意(wu)思(liao)了

本文參考連接：

http://www.javashuo.com/article/p-gweiuvvw-ge.html

3、數據類型

豐富多彩的數據類型世界

首先咱們要先了解一下MongoDB中有什麼樣的數據類型:

Object ID ：Documents 自生成的 _id

String：字符串，必須是utf-8

Boolean：布爾值，true 或者false (這裏有坑哦~在咱們大Python中 True False 首字母大寫)

Integer：整數 (Int32 Int64 大家就知道有個Int就好了,通常咱們用Int32)

Double：浮點數 (沒有float類型,全部小數都是Double)

Arrays：數組或者列表，多個值存儲到一個鍵 (list哦,大Python中的List哦)

Object：若是你學過Python的話,那麼這個概念特別好理解,就是Python中的字典,這個數據類型就是字典

Null：空數據類型 , 一個特殊的概念,None Null

Timestamp：時間戳

Date：存儲當前日期或時間unix時間格式 (咱們通常不用這個Date類型,時間戳能夠秒殺一切時間類型)

看着挺多的,可是真要是用的話,沒那麼複雜,很簡單的哦

剖析MongoDB的數據類型

那麼咱們根據以上所說的數據類型(撿重點說,別整沒用的)展開說明:

1. Object ID

> db.Oldboy.find()
{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Elizabeth", "age" : 20 }

解釋：

"_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

> db.Oldboy.find()
{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Elizabeth", "age" : 20 }

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

3. Boolean

{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Elizabeth", "display" : true }

true or false 這裏首字母是小寫的

4. Integer

{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Elizabeth", "age" : 20 }

整數 (Int32 Int64 大家就知道有個Int就好了,通常咱們用Int32)

5. Double

{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Apple", "Price" : 5.8 }

浮點數 (MongoDB中沒有float類型,全部小數都是Double)

6. Arrays

{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Apple", "place" : ["China","America","New Zealand"] }

數組或者列表，多個值存儲到一個鍵 (list哦,大Python中的List哦

7. Object

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

若是你學過Python的話,那麼這個概念特別好理解,就是Python中的字典,這個數據類型就是字典

8. Null

{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "atmosphere", "price" : null }

空數據類型 , 一個特殊的概念,None Null

9. Timestamp :時間戳

{ "_id" : ObjectId("5b151f8536409809ab2e6b26"), "name" : "Shanghai", "date" : 1528183743111 }

10. Date

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

存儲當前日期或時間格式 (咱們通常不多使用這個Date類型,由於時間戳能夠秒殺一切時間類型)

數據類型就介紹到這裏了,接下來咱們就要學習一下在數據進行增刪改查時,數據類型的特殊用法

本文參考連接：

http://www.javashuo.com/article/p-nijygvfs-gy.html

4、$關鍵字以及$修改器

上一篇文章中提到過 $set 這個系統關鍵字，用來修改值的，對吧！

可是MongoDB中相似這樣的關鍵字有不少, $lt $gt $lte $gte 等等,這麼多咱們也不方便記,這裏咱們說說幾個比較常見的

準備基礎數據

# 清空全部數據
> db.Oldboy.remove({})
WriteResult({ "nRemoved" : 3 })

# 插入3條數據
> db.Oldboy.insertMany([{"name":"Linux","score":59},{"name":"Python","score":100},{"name":"Go","score":80}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5b98f5b3430c27444ccdd64a"),
                ObjectId("5b98f5b3430c27444ccdd64b"),
                ObjectId("5b98f5b3430c27444ccdd64c")
        ]
}

# 查詢全部數據
> db.Oldboy.find()
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64a"), "name" : "Linux", "score" : 59 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64b"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64c"), "name" : "Go", "score" : 80 }

常見的$關鍵字

:(等於)

在MongoDB中什麼字段等於什麼值其實就是 " : " 來搞定好比 "name" : "Linux"

> db.Oldboy.find({"name":"Linux"})
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64a"), "name" : "Linux", "score" : 59 }

$in

查詢一個鍵的多個值

> db.Oldboy.find({"name":{$in:["Linux","Go"]}})
{ "_id" : ObjectId("5b9b9a4cc09c7f67e7a5e499"), "name" : "Linux", "score" : 59 }
{ "_id" : ObjectId("5b9b9a4cc09c7f67e7a5e49b"), "name" : "Go", "score" : 80 }

$or

知足任意 $or 條件的數據，至少要知足一個

> db.Oldboy.find({$or:[{"score":80},{"score":100}]})
{ "_id" : ObjectId("5b9b9a4cc09c7f67e7a5e49a"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b9b9a4cc09c7f67e7a5e49b"), "name" : "Go", "score" : 80 }

$gt(大於)

在MongoDB中的大於 > 號咱們用 : $gt 好比 : "score" : { $gt : 80 } 就是獲得 "score" 大於 80 的數據

> db.Oldboy.find({"score":{$gt:80}})
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64b"), "name" : "Python", "score" : 100 }

$lt(小於)

小於 : 在MongoDB中的小於 < 號咱們用 : $lt 好比 : "score" : { $lt : 80 } 就是獲得 "score" 小於 80 的數據

> db.Oldboy.find({"score":{$lt:80}})
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64a"), "name" : "Linux", "score" : 59 }

$gte(大於等於)

大於等於 : 在MongoDB中的大於等於 >= 號咱們用 : $gte 好比 : "score" : { $gte : 80 } 就是獲得 "score" 大於等於 80 的數據

> db.Oldboy.find({"score":{$gte:80}})
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64b"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64c"), "name" : "Go", "score" : 80 }

$lte(小於等於)

小於等於 : 在MongoDB中的小於等於 <= 號咱們用 : $lte 好比 : "score" : { $lte : 80 } 就是獲得 "score" 小於等於 80 的數據

> db.Oldboy.find({"score":{$lte:80}})
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64a"), "name" : "Linux", "score" : 59 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64c"), "name" : "Go", "score" : 80 }

這就是MongoDB中的運算符,是否是很相似咱們使用的ORM中的運算符啊,沒錯,最開始的時候咱們就已經說了,MongoDB的操做就是很相似ORM的

update修改器

經常使用的update修改器: $inc $set $unset $push $pull

在此前的update中,咱們用過$set,對數據進行過更新,其實在update中還存在不少的$關鍵字,咱們把update中的這些關鍵字叫作修改器

修改器不少,這裏挑一些重要的來講一說:

1. $inc

Python中的變量 += 1 , 將查詢到的結果加上某一個值而後保存

仍是上面的Collection數據,咱們來試一下$inc , 讓不及格的 "Linux" 變成 60 分

> db.Oldboy.updateOne({"score":59},{$inc:{"score":1}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

成功了 , {$inc:{"score":1}}的意思是,"score"的原有數值上面 +1

查看全部數據

> db.Oldboy.find()
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64a"), "name" : "Linux", "score" : 60 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64b"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64c"), "name" : "Go", "score" : 80 }

咱們再來實驗一次,把60改成20,這怎麼操做呢,其實能夠理解爲在 60 上加一個 -40

> db.Oldboy.updateOne({"score":60},{$inc:{"score":-40}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }

又成功了 , {$inc:{"score":-20}}也來越喜歡英俊瀟灑又不會翻車的本身了

$inc 的用法是否是很簡單啊,就是原有基礎上在增長多少對吧

查看全部數據

> db.Oldboy.find()
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64a"), "name" : "Linux", "score" : 20 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64b"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98f5b3430c27444ccdd64c"), "name" : "Go", "score" : 80 }

2. $set

此前咱們已經提到過 $set 的用法和特性(沒有就自動添加一條)了

再作一個例子:把 "score" 爲 100 分的 "price" 賦值爲 99.8

> db.Oldboy.updateOne({"score":100},{$set:{"price":99.8}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : "20" }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100, "price" : 99.8 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

發現Python多了一個屬性price

再把 "score" 爲 20 分的 "score" 賦值爲 59 分

> db.Oldboy.updateOne({"score":20},{$set:{"score":59}})
{ "acknowledged" : true, "matchedCount" : 0, "modifiedCount" : 0 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100, "price" : 99.8 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

完美~

3. $unset

用來刪除Key(field)的

作一個小例子 : 剛纔咱們有一個新的"price" 這個field ,如今咱們來刪除它

> db.Oldboy.updateOne({"score":100},{$unset:{"price":1}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

成功了! {$unset:{"price" : 1}} 就是刪除 "english_name" 這個 field 至關於關係型數據庫中刪除了字段

4. $push

它是用來對Array (list)數據類型進行增長新元素的,至關於咱們大Python中 list.append() 方法

作一個小例子 :首先咱們要先對原有數據增長一個Array類型的field:

> db.Oldboy.update({},{$set:{"test_list":[1,2,3,4,5]}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

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

使用updateMany $set 的方法能夠爲全部知足條件的 Document 添加 "test_list" , 注意我這裏的條件爲空 " {} " 就算是爲空,也要寫上"{}" 記住記住記住

接下來咱們就要隊列表進行添加了: 將 "score" 爲 59 的Document 中"test_list" 添加一個 6

> db.Oldboy.updateMany({"score":59},{$push:{"test_list":6}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5, 6 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

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

5. $pull

有了$push 對Array類型進行增長,就必定有辦法對其內部進行刪減,$pull 就是指定刪除Array中的某一個元素

作一個例子: 把咱們剛纔$push進去的 6 刪除掉

> db.Oldboy.updateMany({"score":59},{$pull:{"test_list":6}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

問題來了,若是 Array 數據類型中若是有多個 6 怎麼辦呢?

重複執行3條命令，查看全部數據

> db.Oldboy.updateMany({"score":59},{$push:{"test_list":6}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.updateMany({"score":59},{$push:{"test_list":6}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.updateMany({"score":59},{$push:{"test_list":6}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5, 6, 6, 6 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

再次執行命令，刪除6

> db.Oldboy.updateMany({"score":59},{$pull:{"test_list":6}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

所有刪掉了.....

得出了一個結論,只要知足條件,就會將Array中全部知足條件的數據所有清除掉

6. $pop

指定刪除Array中的第一個或最後一個元素

作個小例子: 刪除"score" 等於 59 分 test_list 的最後一個元素

> db.Oldboy.updateMany({"score":59},{$pop:{"test_list":1}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 1, 2, 3, 4 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

怎麼刪除第一個呢?

> db.Oldboy.updateMany({"score":59},{$pop:{"test_list":-1}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b98faa9430c27444ccdd64d"), "name" : "Linux", "score" : 59, "test_list" : [ 2, 3, 4 ] }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64e"), "name" : "Python", "score" : 100 }
{ "_id" : ObjectId("5b98faa9430c27444ccdd64f"), "name" : "Go", "score" : 80 }

{$pop:{"test_list" : -1}} -1 表明最前面, 1 表明最後邊 (這和咱們大Python正好相反) 記住哦

本文參考連接：

http://www.javashuo.com/article/p-wkespvfr-er.html

5、"$"的奇妙用法

在MongoDB中有一個很是神奇的符號 "$"

"$" 在 update 中加上關鍵字就變成了修改器

其實 "$" 字符獨立出現也是有意義的 , 我起名叫作代指符

準備基礎數據

# 清空數據
> db.Oldboy.remove({})
WriteResult({ "nRemoved" : 3 })

# 插入3條數據
> db.Oldboy.insertMany([{"name":"Linux","score":100,"test_list":[2,3,4]},{"name":"Python","score":80,"test_list":[1,2,3,4,5]},{"name":"Go","score":59,"test_list":[1,2,3,4,5]}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5b990189430c27444ccdd650"),
                ObjectId("5b990189430c27444ccdd651"),
                ObjectId("5b990189430c27444ccdd652")
        ]
}

# 查看全部數據
> db.Oldboy.find()
{ "_id" : ObjectId("5b990189430c27444ccdd650"), "name" : "Linux", "score" : 100, "test_list" : [ 2, 3, 4 ] }
{ "_id" : ObjectId("5b990189430c27444ccdd651"), "name" : "Python", "score" : 80, "test_list" : [ 1, 2, 3, 4, 5 ] }
{ "_id" : ObjectId("5b990189430c27444ccdd652"), "name" : "Go", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5 ] }

View Code

首先看個例子: 如今把 "score": 100 的 test_list 裏面的 2 改成 9

> db.Oldboy.updateOne({"score":100},{$set:{"test_list.0":9}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b990189430c27444ccdd650"), "name" : "Linux", "score" : 100, "test_list" : [ 9, 3, 4 ] }
{ "_id" : ObjectId("5b990189430c27444ccdd651"), "name" : "Python", "score" : 80, "test_list" : [ 1, 2, 3, 4, 5 ] }
{ "_id" : ObjectId("5b990189430c27444ccdd652"), "name" : "Go", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5 ] }

{$set :{"test_list.0" : 9}} 這樣就是對應 Array 中的下標進行修改了 "test_list.下標"

問題來了若是是一個很長很長很長的 Array 你要查找其中一個值,把這個值修改一下怎麼整呢?

把9還原成2

> db.Oldboy.updateMany({"score":100,"test_list":9},{$set:{"test_list.$":2}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.Oldboy.find()
{ "_id" : ObjectId("5b990189430c27444ccdd650"), "name" : "Linux", "score" : 100, "test_list" : [ 2, 3, 4 ] }
{ "_id" : ObjectId("5b990189430c27444ccdd651"), "name" : "Python", "score" : 80, "test_list" : [ 1, 2, 3, 4, 5 ] }
{ "_id" : ObjectId("5b990189430c27444ccdd652"), "name" : "Go", "score" : 59, "test_list" : [ 1, 2, 3, 4, 5 ] }

神奇不神奇?

$ 字符在語句中表明瞭什麼呢? 下標,位置

解釋一下: 首先咱們查詢一下db.Oldboy.findOne({"score":100,"test_list":3}) 返回給咱們知足條件的數據對吧

> db.Oldboy.findOne({"score":100,"test_list":3})
{
        "_id" : ObjectId("5b990189430c27444ccdd650"),
        "name" : "Linux",
        "score" : 100,
        "test_list" : [
                2,
                3,
                4
        ]
}

那麼若是咱們使用 update的話, 知足條件的數據下標位置就會傳遞到 $ 字符中,在咱們更新操做的時候就至關於對這個位置的元素進行操做

本文參考連接：

http://www.javashuo.com/article/p-obminxgs-eh.html

6、Array Object 的特殊操做

相比關係型數據庫, Array [1,2,3,4,5] 和 Object { 'name':'DragonFire' } 是MongoDB 比較特殊的類型了

特殊在哪裏呢?在他們的操做上又有什麼須要注意的呢?

那咱們先創建一條數據,包含 Array 和 Object 類型

# 清空全部數據
> db.Oldboy.remove({})
WriteResult({ "nRemoved" : 3 })

# 插入一條數據
> db.Oldboy.insert({"name":"路飛學城-騎士計劃","price":[19800,19500,19000,18800],"other":{"start":"2018年8月1日","start_time":"08:30","count":150}})
WriteResult({ "nInserted" : 1 })

# 查看全部數據
> db.Oldboy.find()
{ "_id" : ObjectId("5b990568430c27444ccdd653"), "name" : "路飛學城-騎士計劃", "price" : [ 19800, 19500, 19000, 18800 ], "other" : { "start" : "2018年8月1日", "start_time" : "08:30", "count" : 150 } }

View Code

數據看着可能不太直觀，大概是這個樣子

{
    "_id" : ObjectId("5b17d01a49bf137b585df891"),
    "name" : "路飛學城-騎士計劃",
    "price" : [
        19800,
        19500,
        19000,
    ],
    "other" : {
        "start" : "2018年8月1日",
        "start_time" : "08:30",
        "count" : 150
    }
}

好的,這條數據已經完成了

針對這條數據咱們進行一系列的操做,並講解使用方式

Array 小秀一波

把price 中 19000 改成 19300

> db.Oldboy.update({"name":"路飛學城-騎士計劃"},{$set:{"price.2":19300}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b990568430c27444ccdd653"), "name" : "路飛學城-騎士計劃", "price" : [ 19800, 19500, 19300, 18800 ], "other" : { "start" : "2018年8月1日", "start_time" : "08:30", "count" : 150 } }

db.Oldboy.update({"name":"路飛學城-騎士計劃"},{$set:{"price.2":19300}})

咱們用了引用下標的方法更改了數值 , "price.2"代指的是 Array 中第3個元素

混合用法

若是 price.1 中小於19800 則加 200

> db.Oldboy.update({"name":"路飛學城-騎士計劃","price.1":{$lt:19800}},{$inc:{"price.1":200}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()                                                                   ":200}})
{ "_id" : ObjectId("5b990568430c27444ccdd653"), "name" : "路飛學城-騎士計劃", "price" : [ 19800, 19700, 19300, 18800 ], "other" : { "start" : "2018年8月1日", "start_time" : "08:30", "count" : 150 } }

發現第二個價格，加了200塊！

複習一下:"price.1":{$lt:19800} 是查找 price.1 小於 19800

複習兩下:{$inc:{"price.1":200}} 是什麼啊? price.1 拿出來加上 200 以後再存進去

那麼瓜熟蒂落的混合到一塊兒了

上節課咱們也學習了 $ 的用法,如今咱們混搭 $ 再作一個練習

咱們把 price 小於 19500 的自動補上 200

> db.Oldboy.update({"name":"路飛學城-騎士計劃","price":{$lt:19500}},{$inc:{"price.$":200}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b990568430c27444ccdd653"), "name" : "路飛學城-騎士計劃", "price" : [ 19800, 19700, 19500, 18800 ], "other" : { "start" : "2018年8月1日", "start_time" : "08:30", "count" : 150 } }

發現第3個更改了！18800並無更改

細心的同窗已經發現了,只改了第一個匹配的！是的 $ 這個只儲存一個下標。

批量更改的話,嘻嘻嘻嘻截至2017年1月1日,MongoDB沒有這個功能

你只要把這個Array 拿出來,在程序裏面改完,原方不動的放回去不就搞定了嗎

Object 字典

Object 字典總玩兒過吧,可是這裏更像是 JavaScript 中的 Object 對象

1. 把other中 count 改成 199

> db.Oldboy.update({"name":"路飛學城-騎士計劃"},{$set:{"other.count":199}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b990568430c27444ccdd653"), "name" : "路飛學城-騎士計劃", "price" : [ 19800, 19700, 19500, 18800 ], "other" : { "start" : "2018年8月1日", "start_time" : "08:30", "count" : 199 } }

對了就是在這個對象打點兒 key 就能夠更改數值了 , 要注意的是, 我們用的 $set 進行修改的,那麼就意味着,若是沒有"other.count"這個field的話,他會自動建立

這個用法就到這裏了,下面咱們玩兒個更深的

2. 混合用法

若是 count 小於 200 那麼加 10

> db.Oldboy.update({"name":"路飛學城-騎士計劃","other.count":{$lt:200}},{$inc:{"other.count":10}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b990568430c27444ccdd653"), "name" : "路飛學城-騎士計劃", "price" : [ 19800, 19700, 19500, 18800 ], "other" : { "start" : "2018年8月1日", "start_time" : "08:30", "count" : 209 } }

這麼玩兒完了以後,條件位置的打點兒調用,也嘗試過了

Object的用法就這麼多了

Array + Object 的用法

Array + Object 的用法告訴大家,這個老High了

首先,咱們要先創建一條 Document 嘻嘻嘻嘻嘻

# 清空全部數據
> db.Oldboy.remove({})
WriteResult({ "nRemoved" : 1 })

# 插入一條數據
> db.Oldboy.insert({"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},]})
WriteResult({ "nInserted" : 1 })

# 查看全部數據
> db.Oldboy.find()
{ "_id" : ObjectId("5b990b6e430c27444ccdd654"), "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 } ] }

View Code

數據比較複雜，大概是這個樣子

{
    "_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
        }
    ]
}

View Code

insert的代碼要本身寫哦,學完一直沒怎麼練習過,Document添加完成以後

1. 把count 大於 175 的field 加 15

> db.Oldboy.update({"price.count":{$gt:175}},{$inc:{"price.$.count":15}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b990b6e430c27444ccdd654"), "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" : 195 } ] }

分析一下咱們的代碼:

{"price.count":{$gt:175}}, price 明明是個 Array 啊怎麼就直接打點兒 count 了呢這裏要知道price 打點兒就是從內部的Object 中找到 count 小於 175 的結果

{$inc:{"price.$.count":15}} , 這裏就比較好理解了,price裏面第 $ (大於175的第一個) 個元素中 count 增長 15

咱們要學會觸類旁通 $set 若是忘了, 就再來一個例子吧

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

> db.Oldboy.update({"price.count":{$gt:180}},{$set:{"price.$.start":"2018年8月10日"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.Oldboy.find()
{ "_id" : ObjectId("5b990b6e430c27444ccdd654"), "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月10日", "start_time" : "11:30", "count" : 195 } ] }

不作過多解釋了,沒學會的翻回去看吧

到此爲止咱們MongoDB的操做階段就已經學習結束了.

本文參考連接：

http://www.javashuo.com/article/p-rzvtaucu-dy.html

7、選取跳過排序

咱們已經學過MongoDB的 find() 查詢功能了,在關係型數據庫中的選取(limit),排序(sort) MongoDB中一樣有,並且使用起來更是簡單

首先咱們看下添加幾條Document進來

# 清空全部數據
> db.Oldboy.remove({})
WriteResult({ "nRemoved" : 1 })

# 插入多條數據
> db.Oldboy.insertMany([{"name" : "Python","price" : "15800"},{"name" : "騎士計劃","price" : "19800"},{"name" : "Linux","price" : "9800"},{"name" : "Python架構","price" : "13800"},])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5b990d6b430c27444ccdd655"),
                ObjectId("5b990d6b430c27444ccdd656"),
                ObjectId("5b990d6b430c27444ccdd657"),
                ObjectId("5b990d6b430c27444ccdd658")
        ]
}

# 查看全部數據
> db.Oldboy.find()
{ "_id" : ObjectId("5b990d6b430c27444ccdd655"), "name" : "Python", "price" : "15800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd658"), "name" : "Python架構", "price" : "13800" }

View Code

如今有四條Document 根據它們, 對 Limit Skip Sort 分別展開學習最後來一個大雜燴

Limit 選取

我要從這些 Document 中取出多少個

作個小例子 : 我只要 2 條 Document

> db.Oldboy.find().limit(2)
{ "_id" : ObjectId("5b990d6b430c27444ccdd655"), "name" : "Python", "price" : "15800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }

結果是很明顯的,很赤裸裸的,很一絲不掛的

可是我仍是要解釋一下 : limit(2) 就是選取兩條Document, 從整個Collection的第一條 Document 開始選取兩條

若是咱們不想從第一條Document開始選取,怎麼辦呢?

Skip 跳過

我要跳過多少個Document

作個小例子 : 我要跳過前兩個 Document 直接從第三個Document 開始

> db.Oldboy.find().skip(2)
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd658"), "name" : "Python架構", "price" : "13800" }

結果仍是很明顯,很赤裸

按照國際慣例解釋一下 : skip(2) 就是跳過兩條Document, 從整個Collection 的第一條 Document 開始跳,日後跳兩條

另外一個例子 : 跳過第一條直接從第二條開始

> db.Oldboy.find().skip(1)
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd658"), "name" : "Python架構", "price" : "13800" }

問題來了,我只想要第二條和第三條怎麼處理呢?

Limit + Skip

從這兒到那兒的選取

就是剛纔的問題,一個小例子 : 我只想要第二條和第三條怎麼處理呢

> db.Oldboy.find().skip(1).limit(2)
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }

國際慣例 : 跳過第一條Document 從第二條開始選取兩條 Document

彆着急,還有另外一種寫法

> db.Oldboy.find().limit(2).skip(1)
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }

兩種寫法徹底獲得的結果徹底同樣可是國際慣例的解釋卻不一樣

國際慣例 : 選取兩條Document 可是要跳過第一條Document 從第二條開始選取

繞了半天,都暈了,注意這裏特別要注意了!!!!!! 這裏的兩種寫法,必定必定必定要記住一個,由於只要記住一個就好了,徹底徹底沒區別,一個符合中國人的理解,一個是其餘國家的理解

Sort 排序

將結果按照關鍵字排序

作個小例子 : 將find出來的Document 按照 price 進行升序 | 降序排列

升序

> db.Oldboy.find().sort({"price":1})
{ "_id" : ObjectId("5b990d6b430c27444ccdd658"), "name" : "Python架構", "price" : "13800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd655"), "name" : "Python", "price" : "15800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }

降序

> db.Oldboy.find().sort({"price":-1})
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd655"), "name" : "Python", "price" : "15800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd658"), "name" : "Python架構", "price" : "13800" }

國際慣例 : 按照 price 字段進行升序 , 1 爲升序 , -1 爲降序

Limit + Skip + Sort

一個例子 : 選取第二條第三條並按照 price 進行升序排列

> db.Oldboy.find()
{ "_id" : ObjectId("5b990d6b430c27444ccdd655"), "name" : "Python", "price" : "15800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd657"), "name" : "Linux", "price" : "9800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd658"), "name" : "Python架構", "price" : "13800" }

> db.Oldboy.find().skip(1).limit(2).sort({"price":1})
{ "_id" : ObjectId("5b990d6b430c27444ccdd655"), "name" : "Python", "price" : "15800" }
{ "_id" : ObjectId("5b990d6b430c27444ccdd656"), "name" : "騎士計劃", "price" : "19800" }

問題出現了, 按道理不該該是 9800 而後 19800 嗎?

知識點來嘍

重點 : Sort + Skip + Limit 是有執行優先級的他們的界別分別是優先 Sort 其次 Skip 最後 Limt

Skip + Limit 的優先級也是先 Skip 再 Limit

看一次,記不住

看兩次,不會用

看三次,不如本身作一次

作一次,不如作三次

練習一下加深印象

本文參考連接：

http://www.javashuo.com/article/p-ahwxaezb-cd.html

8、客戶端操做

windows客戶端

nosqlbooster4mongo(客戶端)
連接：https://pan.baidu.com/s/1zZRAtSwj8H1hliErA1kOOA 密碼：tyng

使用

打卡以後，長這個樣子

點擊左側的Connect，點擊Create

默認配置就能夠了，點擊測試鏈接

出現ok，表示成功了

點擊保存並鏈接

默認的2個數據庫admin和local，是不能操做的！

只能操做本身建立的

查看數據

雙擊Oldbody，也就是表，效果以下：

選擇右側的table，能夠展現位表格數據

也能夠選擇，展現爲JSON數據

光標移動到ORM語句上，按F5，就會執行SQL!

因此：從此想執行哪句，將光標移動到此，按F5，就會執行指定的ORM語句！很是方便！

插入數據

插入一條數據

查看全部數據

其餘操做，遵循MongoDB的ORM語法便可！這裏就不演示了！

python程序

python操做MongoDB，須要安裝模塊 pymongo

pip install pymongo

鏈接

新建一個文件 test_mongo.py

import pymongo

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立

res = mongo_db.goods.find()
print(res)

執行輸出：

<pymongo.cursor.Cursor object at 0x000001F68B7D09E8>

插入數據

import pymongo

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立

# 插入多條數據
res = mongo_db.goods.insert_many([{"name" : "酸菜","price" : "1"},{"name" : "白菜","price" : "2"},{"name" : "小青菜","price" : "0.5"},])
print(res)

View Code

執行輸出：

<pymongo.results.InsertManyResult object at 0x00000143817B3548>

查詢數據

查詢全部

能夠將結果轉換爲列表

import pymongo

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立

# 插入多條數據
res = mongo_db.goods.find()
print(list(res))

View Code

執行輸出：

[{'_id': ObjectId('5b991895e125324a58178dd3'), 'name': '酸菜', 'price': '1'}, {'_id': ObjectId('5b991895e125324a58178dd4'), 'name': '白菜', 'price': '2'}, {'_id': ObjectId('5b991895e125324a58178dd5'), 'name': '小青菜', 'price': '0.5'}]

也能夠對結果作for循環

import pymongo

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立

# 插入多條數據
res = mongo_db.goods.find()
for i in res:
    print(i)

View Code

執行輸出：

{'_id': ObjectId('5b991895e125324a58178dd3'), 'name': '酸菜', 'price': '1'}
{'_id': ObjectId('5b991895e125324a58178dd4'), 'name': '白菜', 'price': '2'}
{'_id': ObjectId('5b991895e125324a58178dd5'), 'name': '小青菜', 'price': '0.5'}

查詢單條

import pymongo

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立

# 插入多條數據
res = mongo_db.goods.find_one()
print(res)

View Code

執行輸出：

{'_id': ObjectId('5b991895e125324a58178dd3'), 'name': '酸菜', 'price': '1'}

查詢指定id呢？

因爲_id是ObjectId對象，須要導入模塊

import pymongo
from bson import ObjectId

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立

# 插入多條數據
res = mongo_db.goods.find({"_id":ObjectId("5b991895e125324a58178dd5")})
for i in res:
    print(i)

View Code

執行輸出：

{'_id': ObjectId('5b991895e125324a58178dd5'), 'name': '小青菜', 'price': '0.5'}

更新

import pymongo
from bson import ObjectId

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立


res = mongo_db.goods.update_one({"name":"小青菜"},{"$set":{"price":2}})
print(res)

View Code

執行輸出：

<pymongo.results.UpdateResult object at 0x000001AF61E332C8> None

刪除

import pymongo
from bson import ObjectId

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立


res = mongo_db.goods.delete_one({"name":"小青菜"})
print(res,res.raw_result)

View Code

執行輸出：

<pymongo.results.DeleteResult object at 0x000001825B2134C8> {'n': 0, 'ok': 1.0}

排序

import pymongo
from bson import ObjectId

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立


res = mongo_db.goods.find({}).skip(1).limit(2)
print(list(res))

View Code

執行輸出：

[{'_id': ObjectId('5b991895e125324a58178dd4'), 'name': '白菜', 'price': '2'}]

進階

import pymongo
from bson import ObjectId

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立


res = mongo_db.goods.find({}).sort("age",pymongo.DESCENDING)
print(list(res))

View Code

執行輸出：

[{'_id': ObjectId('5b991895e125324a58178dd3'), 'name': '酸菜', 'price': '1'}, {'_id': ObjectId('5b991895e125324a58178dd4'), 'name': '白菜', 'price': '2'}]

高級操做

import pymongo
from bson import ObjectId

# 鏈接數據庫
mclient = pymongo.MongoClient(host="127.0.0.1", port=27017)
mongo_db = mclient["testdb"]  # 切換數據庫,不存在則建立


res = mongo_db.goods.find({}).sort("age",pymongo.DESCENDING).skip(1).limit(2)
print(list(res))

View Code

執行輸出：

[{'_id': ObjectId('5b991895e125324a58178dd4'), 'name': '白菜', 'price': '2'}]

今日內容總結

MongoDB:文件型數據庫 find（） update（） delete（） insert（）持久化
redis：get set 默認持久化

1.MongoDB是什麼及其概念：
MongoDB是一個快速存儲數據（JSON），並ORM操做的數據庫
MongoDB是文件型數據庫，不存在關係
MongoDB中基本上存儲了大量的冗餘數據
MongoDB中沒有字段的概念
MongoDB是很是靈活的數據庫
專有名詞：
    Mysql        MongoDB
    DB            DB
    Table        Colletions        Table概念
    row            Documents        row概念
    字段        Field            字段概念
                _id                惟一律念

不存在即建立：
    若是使用了不存在的對象即建立該對象
    

2.MongoDB的存儲結構：

關係型數據庫：
id     name             age        course        score    score1
1    子龍            84        python        99        0
2    xiaoqinglong    73        javascript    0        99

文件型數據庫：
[
    {
        _id:ObjectId("1298478375f8234d")
        ids：1，
        names：子龍，
        ages：84,
        courses：python,
        scores：99
    },
    {
        id:2,
        name:xiaoqinglong,
        age:73，
        course：javascript,
        score1：99
    }
]


3.初識MongoDB
    1.安裝mongoDB bin目錄環境變量
    2.啓動mongoDB：
        mongod (手動建立文件夾) c:\data\db
        mongod --dbpath "E:\Program Files\MongoDB\data\db"
    3.MongoDB的默認端口號：27017  （redis：6379 MySql：3306）

4.mongodb 的指令：
    show dbs 查看當前數據庫服務器中的全部數據庫（DB）
    use dbname 建立或使用數據庫
    db 查看當前使用的數據庫 / 代指當前使用的數據庫的名字或對象 
    show tables 查看當前數據庫的 數據表 Collations
    
    
5.MongoDB的增刪改查：
    增：
        db.Collations.insert({"name":"zilong"}) 
        db.Collations.insert([{"name":"zilong"},{"name":"123"}]) 
        // insert 方式 被官方不推薦了
        1.db.Collations.insertOne({}) 只能單行操做插入
        2.db.Collations.insertMany([{},{}]) 根據array（列表）中的元素插入多行數據
        
    改：
        db.user.update({"name":"酸菜"},{$set:{"name":"老壇酸菜"}})
        db.user.update({"name":"酸菜"},{$set:{"name":"老壇酸菜"}},多條修改:true)
        // update 方式 被官方不推薦了
        db.user.updateOne({"name":"子龍"},{$set:{"name":"趙子龍"}})
        db.user.updateMany({"name":"小青龍"},{$set:{"name":"白虎"}})
        
    刪除：
        db.user.remove({})
        // remove 方式 被官方不推薦了
        db.user.deleteOne({"name":"白虎"})
        db.user.deleteMany({"name":"翠花兒"})
    
    查：
        1.db.find({條件:1})
            
        2.db.findOne({條件:1})
            db.user.findOne({"name":"酸菜","age":1}) 逗號至關於 and
        
        3.數學比較符：
            $lt 小於
            $gt 大於
            $lte 小於等於
            $gte 大於等於
            find({"字段":{$比較符:值}})
            db.user.find({"age":{$gt:2}}) # where age > 2
6.修改器：
    $set : 將某個key的value 修改成 某值
    $unset: 刪除字段 {$unset: {test: "" }}
    
    $inc:{$inc:{"age":100}} 原有值基礎上增長 xxx
    
    array：
    $push : 向數組Array最後位置插入一條元素 {$push:{"hobby":1234}} [].append(1234)
    $pull : 刪除數組中的某一個元素 {$pull:{"hobby":123}} 
            #刪除字典 db.user.updateOne({"_id":ObjectId("5b98794ec34b9812bcabdde7"),"hobby.age":18},{$unset:{"hobby.$":1}})    
    $pop : 刪除數組的第一個或最後一個  
        最後一個：{$pop:{"hobby":1}} 
        第一個：{$pop:{"hobby":-1}} 
        
    $ ：代指符合條件的某數據  array.$ :
        db.user.updateOne({"_id":ObjectId("5b98794ec34b9812bcabdde7"),"hobby.name":"翠花兒"},{$set:{"hobby.$.name":"農婦山泉"}})
        
        
    
查詢$關鍵字：
    $in: db.user.find({age:{$in:[1,2,3]}}) 字段符合in，array中的數值
    $or: db.user.find({$or:[{age:{$in:[1,2,3,4]}},{name:666}]})
    $all: db.user.find({test:{$all:[1,2]}}) array元素相同便可 或 包含全部$all中的元素
    
    


        
7.數據類型：
    基於BSON結構
    string     字符串，Utf8
    integer    整型
    double    雙精度，包含float，MongoDB中不存在Float
    Null    空數據類型
    Date    時間類型 ISODate(2018-9-12 10:45:58)
    Timestamp 時間戳類型 ISODate("123123")
    
    ObjectId    對象ID    Documents 自生成的 _id ObjectId("5b98794ec34b9812bcabdde7")
                #"5b151f85"     代指的是時間戳,這條數據的產生時間
                #"364098"         代指某臺機器的機器碼,存儲這條數據時的機器編號
                #"09ab"         代指進程ID,多進程存儲數據的時候,很是有用的
                #"2e6b26"         代指計數器,這裏要注意的是,計數器的數字可能會出現重複,不是惟一的
                #以上四種標識符拼湊成世界上惟一的ObjectID
                #只要是支持MongoDB的語言,都會有一個或多個方法,對ObjectID進行轉換
                #能夠獲得以上四種信息
    
    不可以被 JSON 化
    from BSON import ObjectId
            
    ？arrays [] 數組類型 至關於python中的list $pop $push $pull
    ？object {name:1} 對象類型 至關於python中的dict
    
    ps：因爲MongoDB存儲自由度沒有限制，因此咱們程序員要定義好數據格式，儘量少的修改格式（開發階段隨便修改）
    
    
    
8. 排序 跳過 顯示條目
sort 排序 find().sort(id:-1/1) 1 升序 2 降序 desc
skip 跳過 find().skip(2) 從三條開始返回
limit 顯示條目 find().limit(2)只顯示前兩條

混搭：
db.user.find({}).sort({age:-1 }).skip(1).limit(2)
根據age字段進行降序排列，而且跳過第一條，從第二條開始返回，兩條數據

9.pymongo：
    sort("age",pymongo.DESCENDING)

View Code

今日做業

1.本身練習一下$的用法
2.基於昨天的web版問答系統,問了什麼問題，存在Mongodb數據庫裏
3.回答什麼答案，存在Mongodb數據庫裏
4.作一個聊天記錄查詢的功能

附加做業：
最好：
    {
        user_name:123,chat_list:[
            {q:"123",a:"456",update_at:123123123}
        ]
    }

進階：
    {
        user_name:123,chat_list:[
            {q:"123",a:"456",update_at:123123123}
        ],
        # 問題和回答統計,使用$inc
        qcount:10,acount:10
    }