mongodb - 可視化工具 / pymongo - 使用方法

本文轉載自查看原文 2018-10-11 15:29 825 MySQL/ Sql - 學習

一、mongodb可視化工具 - adminMongo

https://www.cnblogs.com/shiweida/p/7692468.html

https://github.com/mrvautin/adminMongo

Installation

Navigate to folder & install adminMongo: git clone https://github.com/mrvautin/adminMongo.git && cd adminMongo
Install dependencies: npm install
Start application: npm start or node app
Visit http://127.0.0.1:1234 in your browser

安裝npm

https://blog.csdn.net/gaomengwang/article/details/77540429

　　sudo apt-get install nodejs

　　sudo ln -s /usr/bin/nodejs /usr/bin/node

　　sudo apt-get install npm

二、mongodb可視化工具 - Robo 3T

　　https://robomongo.org/

下載

點擊：

　　create

　　Connection

　　　　name:

　　　　ip：

　　　　端口：

　　Authentication

　　　　Database 認證數據庫

　　　　賬號：

　　　　密碼：

　　　　Auth Mechanism : MONGDB-CR

　　Test 測試，就可以連接成功！！！

三、pymongo使用方法

引用：

https://www.cnblogs.com/nixingguo/p/7260604.html

官方文檔：

http://api.mongodb.com/python/current/api/pymongo/

http://api.mongodb.com/python/current/api/pymongo/collection.html

https://docs.mongodb.com/manual/reference/operator/query/

#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
MongoDB存儲
    在這里我們來看一下Python3下MongoDB的存儲操作，在本節開始之前請確保你已經安裝好了MongoDB並啟動了其服務，另外安裝好了Python
    的PyMongo庫。
 
連接MongoDB
    連接MongoDB我們需要使用PyMongo庫里面的MongoClient，一般來說傳入MongoDB的IP及端口即可，第一個參數為地址host，
    第二個參數為端口port，端口如果不傳默認是27017。
"""
import pymongo
client = pymongo.MongoClient(host='localhost', port=27017)
"""
這樣我們就可以創建一個MongoDB的連接對象了。另外MongoClient的第一個參數host還可以直接傳MongoDB的連接字符串，以mongodb開頭，
例如：client = MongoClient('mongodb://localhost:27017/')可以達到同樣的連接效果。
"""

創建連接對象時,用client = pymongo.MongoClient('mongodb://user:password@localhost:27017/')這樣的方式,增加權限認證

# 指定數據庫
# MongoDB中還分為一個個數據庫，我們接下來的一步就是指定要操作哪個數據庫，在這里我以test數據庫為例進行說明，所以下一步我們
# 需要在程序中指定要使用的數據庫。
 
db = client.test
# 調用client的test屬性即可返回test數據庫，當然也可以這樣來指定：
# db = client['test']
#　兩種方式是等價的。
 
# 指定集合
# MongoDB的每個數據庫又包含了許多集合Collection，也就類似與關系型數據庫中的表，下一步我們需要指定要操作的集合，
# 在這里我們指定一個集合名稱為students，學生集合。還是和指定數據庫類似，指定集合也有兩種方式。
 
collection = db.students
# collection = db['students']
# 插入數據,接下來我們便可以進行數據插入了，對於students這個Collection，我們新建一條學生數據，以字典的形式表示：
 
student = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}
# 在這里我們指定了學生的學號、姓名、年齡和性別，然后接下來直接調用collection的insert()方法即可插入數據。
 
result = collection.insert(student)
print(result)
# 在MongoDB中，每條數據其實都有一個_id屬性來唯一標識，如果沒有顯式指明_id，MongoDB會自動產生一個ObjectId類型的_id屬性。
# insert()方法會在執行后返回的_id值。
 
# 運行結果：
# 5932a68615c2606814c91f3d
# 當然我們也可以同時插入多條數據，只需要以列表形式傳遞即可，示例如下：
 
student1 = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}
 
student2 = {
    'id': '20170202',
    'name': 'Mike',
    'age': 21,
    'gender': 'male'
}
 
result = collection.insert([student1, student2])
print(result)
# 返回的結果是對應的_id的集合，運行結果：
# [ObjectId('5932a80115c2606a59e8a048'), ObjectId('5932a80115c2606a59e8a049')]
# 實際上在PyMongo 3.X版本中，insert()方法官方已經不推薦使用了，當然繼續使用也沒有什么問題，
# 官方推薦使用insert_one()和insert_many()方法將插入單條和多條記錄分開。
 
student = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}
 
result = collection.insert_one(student)
print(result)
print(result.inserted_id)
# 運行結果：
# <pymongo.results.InsertOneResult object at 0x10d68b558>
# 5932ab0f15c2606f0c1cf6c5
# 返回結果和insert()方法不同，這次返回的是InsertOneResult對象，我們可以調用其inserted_id屬性獲取_id。
 
# 對於insert_many()方法，我們可以將數據以列表形式傳遞即可，示例如下：
 
student1 = {
    'id': '20170101',
    'name': 'Jordan',
    'age': 20,
    'gender': 'male'
}
 
student2 = {
    'id': '20170202',
    'name': 'Mike',
    'age': 21,
    'gender': 'male'
}
 
result = collection.insert_many([student1, student2])
print(result)
print(result.inserted_ids)
# insert_many()方法返回的類型是InsertManyResult，調用inserted_ids屬性可以獲取插入數據的_id列表，運行結果：
 
# <pymongo.results.InsertManyResult object at 0x101dea558>
# [ObjectId('5932abf415c2607083d3b2ac'), ObjectId('5932abf415c2607083d3b2ad')]
# 查詢，插入數據后我們可以利用find_one()或find()方法進行查詢，find_one()查詢得到是單個結果，find()則返回多個結果。
 
result = collection.find_one({'name': 'Mike'})
print(type(result))
print(result)
# 在這里我們查詢name為Mike的數據，它的返回結果是字典類型，運行結果：
# <class'dict'>
# {'_id': ObjectId('5932a80115c2606a59e8a049'), 'id': '20170202', 'name': 'Mike', 'age': 21, 'gender': 'male'}
# 可以發現它多了一個_id屬性，這就是MongoDB在插入的過程中自動添加的。
 
# 我們也可以直接根據ObjectId來查詢，這里需要使用bson庫里面的ObjectId。
 
from bson.objectid import ObjectId
 
result = collection.find_one({'_id': ObjectId('593278c115c2602667ec6bae')})
print(result)
# 其查詢結果依然是字典類型，運行結果：
 
# {' ObjectId('593278c115c2602667ec6bae'), 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male'}
# 當然如果查詢_id':結果不存在則會返回None。
 
# 對於多條數據的查詢，我們可以使用find()方法，例如在這里查找年齡為20的數據，示例如下：
 
results = collection.find({'age': 20})
print(results)
for result in results:
    print(result)
# 運行結果：
 
# <pymongo.cursor.Cursor object at 0x1032d5128>
# {'_id': ObjectId('593278c115c2602667ec6bae'), 'id': '20170101', 'name': 'Jordan', 'age': 20, 'gender': 'male'}
# {'_id': ObjectId('593278c815c2602678bb2b8d'), 'id': '20170102', 'name': 'Kevin', 'age': 20, 'gender': 'male'}
# {'_id': ObjectId('593278d815c260269d7645a8'), 'id': '20170103', 'name': 'Harden', 'age': 20, 'gender': 'male'}
# 返回結果是Cursor類型，相當於一個生成器，我們需要遍歷取到所有的結果，每一個結果都是字典類型。
 
# 如果要查詢年齡大於20的數據，則寫法如下：
 
results = collection.find({'age': {'$gt': 20}})
# 在這里查詢的條件鍵值已經不是單純的數字了，而是一個字典，其鍵名為比較符號$gt，意思是大於，鍵值為20，這樣便可以查詢出所有
# 年齡大於20的數據。
 
# 在這里將比較符號歸納如下表：
"""
符號含義示例
$lt小於{'age': {'$lt': 20}}
$gt大於{'age': {'$gt': 20}}
$lte小於等於{'age': {'$lte': 20}}
$gte大於等於{'age': {'$gte': 20}}
$ne不等於{'age': {'$ne': 20}}
$in在范圍內{'age': {'$in': [20, 23]}}
$nin不在范圍內{'age': {'$nin': [20, 23]}}
"""
# 另外還可以進行正則匹配查詢，例如查詢名字以M開頭的學生數據，示例如下：
 
results = collection.find({'name': {'$regex': '^M.*'}})
# 在這里使用了$regex來指定正則匹配，^M.*代表以M開頭的正則表達式，這樣就可以查詢所有符合該正則的結果。
 
# 在這里將一些功能符號再歸類如下：
"""
符號含義示例示例含義
$regex匹配正則{'name': {'$regex': '^M.*'}}name以M開頭
$exists屬性是否存在{'name': {'$exists': True}}name屬性存在
$type類型判斷{'age': {'$type': 'int'}}age的類型為int
$mod數字模操作{'age': {'$mod': [5, 0]}}年齡模5余0
$text文本查詢{'$text': {'$search': 'Mike'}}text類型的屬性中包含Mike字符串
$where高級條件查詢{'$where': 'obj.fans_count == obj.follows_count'}自身粉絲數等於關注數
"""
# 這些操作的更詳細用法在可以在MongoDB官方文檔找到：
# https://docs.mongodb.com/manual/reference/operator/query/
 
# 計數
# 要統計查詢結果有多少條數據，可以調用count()方法，如統計所有數據條數：
 
count = collection.find().count()
print(count)
# 或者統計符合某個條件的數據：
 
count = collection.find({'age': 20}).count()
print(count)
# 排序
# 可以調用sort方法，傳入排序的字段及升降序標志即可，示例如下：
 
results = collection.find().sort('name', pymongo.ASCENDING)
print([result['name'] for result in results])
# 運行結果：
 
# ['Harden', 'Jordan', 'Kevin', 'Mark', 'Mike']
# 偏移,可能想只取某幾個元素，在這里可以利用skip()方法偏移幾個位置，比如偏移2，就忽略前2個元素，得到第三個及以后的元素。
 
results = collection.find().sort('name', pymongo.ASCENDING).skip(2)
print([result['name'] for result in results])
# 運行結果：
# ['Kevin', 'Mark', 'Mike']
# 另外還可以用limit()方法指定要取的結果個數，示例如下：
 
results = collection.find().sort('name', pymongo.ASCENDING).skip(2).limit(2)
print([result['name'] for result in results])
# 運行結果：
# ['Kevin', 'Mark']
# 如果不加limit()原本會返回三個結果，加了限制之后，會截取2個結果返回。
 
# 值得注意的是，在數據庫數量非常龐大的時候，如千萬、億級別，最好不要使用大的偏移量來查詢數據，很可能會導致內存溢出，
# 可以使用類似find({'_id': {'$gt': ObjectId('593278c815c2602678bb2b8d')}}) 這樣的方法來查詢，記錄好上次查詢的_id。
 
# 更新
# 對於數據更新可以使用update()方法，指定更新的條件和更新后的數據即可，例如：
 
condition = {'name': 'Kevin'}
student = collection.find_one(condition)
student['age'] = 25
result = collection.update(condition, student)
print(result)
# 在這里我們將name為Kevin的數據的年齡進行更新，首先指定查詢條件，然后將數據查詢出來，修改年齡，
# 之后調用update方法將原條件和修改后的數據傳入，即可完成數據的更新。
 
# 運行結果：
 
# {'ok': 1, 'nModified': 1, 'n': 1, 'updatedExisting': True}
# 返回結果是字典形式，ok即代表執行成功，nModified代表影響的數據條數。
 
# 另外update()方法其實也是官方不推薦使用的方法，在這里也分了update_one()方法和update_many()方法，用法更加嚴格，
# 第二個參數需要使用$類型操作符作為字典的鍵名，我們用示例感受一下。
 
condition = {'name': 'Kevin'}
student = collection.find_one(condition)
student['age'] = 26
result = collection.update_one(condition, {'$set': student})
print(result)
print(result.matched_count, result.modified_count)
# 在這里調用了update_one方法，第二個參數不能再直接傳入修改后的字典，而是需要使用{'$set': student}這樣的形式，
# 其返回結果是UpdateResult類型，然后調用matched_count和modified_count屬性分別可以獲得匹配的數據條數和影響的數據條數。
 
# 運行結果：
#
# <pymongo.results.UpdateResult object at 0x10d17b678>
# 1 0
# 我們再看一個例子：
 
condition = {'age': {'$gt': 20}}
result = collection.update_one(condition, {'$inc': {'age': 1}})
print(result)
print(result.matched_count, result.modified_count)
# 在這里我們指定查詢條件為年齡大於20，然后更新條件為{'$inc': {'age': 1}}，執行之后會講第一條符合條件的數據年齡加1。
 
# 運行結果：
#
# <pymongo.results.UpdateResult object at 0x10b8874c8>
# 1 1
# 可以看到匹配條數為1條，影響條數也為1條。
 
# 如果調用update_many()方法，則會將所有符合條件的數據都更新，示例如下：
 
condition = {'age': {'$gt': 20}}
result = collection.update_many(condition, {'$inc': {'age': 1}})
print(result)
print(result.matched_count, result.modified_count)
# 這時候匹配條數就不再為1條了，運行結果如下：
#
# <pymongo.results.UpdateResult object at 0x10c6384c8>
# 3 3
# 可以看到這時所有匹配到的數據都會被更新。
 
# 刪除
# 刪除操作比較簡單，直接調用remove()方法指定刪除的條件即可，符合條件的所有數據均會被刪除，示例如下：
 
result = collection.remove({'name': 'Kevin'})
print(result)
# 運行結果：
#
# {'ok': 1, 'n': 1}
# 另外依然存在兩個新的推薦方法，delete_one()和delete_many()方法，示例如下：
 
result = collection.delete_one({'name': 'Kevin'})
print(result)
print(result.deleted_count)
result = collection.delete_many({'age': {'$lt': 25}})
print(result.deleted_count)
# 運行結果：
 
# <pymongo.results.DeleteResult object at 0x10e6ba4c8>
# 1
# 4
# delete_one()即刪除第一條符合條件的數據，delete_many()即刪除所有符合條件的數據，返回結果是DeleteResult類型，
# 可以調用deleted_count屬性獲取刪除的數據條數。
 
# 更多
# 另外PyMongo還提供了一些組合方法，如find_one_and_delete()、find_one_and_replace()、find_one_and_update()，
# 就是查找后刪除、替換、更新操作，用法與上述方法基本一致。
 
# 另外還可以對索引進行操作，如create_index()、create_indexes()、drop_index()等。
 
# 詳細用法可以參見官方文檔：http://api.mongodb.com/python/current/api/pymongo/collection.html
 
# 另外還有對數據庫、集合本身以及其他的一些操作，在這不再一一講解，可以參見
# 官方文檔：http://api.mongodb.com/python/current/api/pymongo/

四、python - mongodb基本操作 - 補充

http://www.cnblogs.com/liuwei0824/p/8329705.html

數據庫
    增
        use db1 #有則切換，無則新增

    查
        show dbs #查看所有
        db #當前

    刪
        db.dropDatabase()

集合：
    增:
        db.user
        db.user.info
        db.user.auth

    查看
        show collections
        show tables

     刪
        db.user.info.drop()

文檔：
    增
        db.user.insert({"_id":1,"name":"egon"})
        user0={
            "name":"egon",
            "age":10,
            'hobbies':['music','read','dancing'],
            'addr':{
                'country':'China',
                'city':'BJ'
            }
        }

        db.user.insert(user0)
        db.user.insertMany([user1,user2,user3,user4,user5])

        db.t1.insert({"_id":1,"a":1,"b":2,"c":3})
        #有相同的_id則覆蓋，無相同的_id則新增，必須指定_id
        db.t1.save({"_id":1,"z":6})
        db.t1.save({"_id":2,"z":6})
        db.t1.save({"z":6})

　　　　　save與insert的區別:
       　　 若新增的數據中存在主鍵 ，insert() 會提示錯誤，而save() 則更改原來的內容為新內容。
       　　 如：
    　　　　 已存在數據：  {_id : 1, " name " : " n1 " }，再次進行插入操作時，
    　　　　 insert({_id : 1, " name " : " n2 " })    會報主鍵重復的錯誤提示
    　　　　 save({ _id : 1, " name " : " n2 " })     會把 n1 修改為  n2  。
    　　　　 相同點：
    　　　　 若新增的數據中沒有主鍵時，會增加一條記錄。
    　　　　 已存在數據：  { _id : 1, " name " : " n1 " }，再次進行插入操作時，
    　　　　 insert({ " name " : " n2 " })    插入的數據因為沒有主鍵，所以會增加一條數據
    　　　　 save({  " name " : " n2 " })   增加一條數據。
    查

        比較運算：=，!=,>,<,>=,<=
        #1、select * from db1.user where id = 3
        db.user.find({"_id":3})

        #2、select * from db1.user where id != 3
        db.user.find({"_id":{"$ne":3}})

        #3、select * from db1.user where id > 3
        db.user.find({"_id":{"$gt":3}})

        #4、select * from db1.user where age < 3
        db.user.find({"age":{"$lt":3}})

        #5、select * from db1.user where id >= 3
        db.user.find({"_id":{"$gte":3}})

        #6、select * from db1.user where id <= 3
        db.user.find({"_id":{"$lte":3}})


        #邏輯運算:$and,$or,$not
        #1 select * from db1.user where id >=3 and id <=4;
        db.user.find({"_id":{"$gte":3,"$lte":4}})

        #2 select * from db1.user where id >=3 and id <=4 and age >=40;
        db.user.find({
            "_id":{"$gte":3,"$lte":4},
            "age":{"$gte":40}
        })

        db.user.find({"$and":[
        {"_id":{"$gte":3,"$lte":4}},
        {"age":{"$gte":40}}
        ]})


        #3 select * from db1.user where id >=0 and id <=1 or id >=4 or name = "yuanhao";
        db.user.find({"$or":[
        {"_id":{"$lte":1,"$gte":0}},
        {"_id":{"$gte":4}},
        {"name":"yuanhao"}
        ]})

        #4 select * from db1.user where id % 2 = 1;
        db.user.find({"_id":{"$mod":[2,1]}})


        db.user.find({
            "_id":{"$not":{"$mod":[2,1]}}
        })

        #成員運算:$in,$nin
        db.user.find({"name":{"$in":["alex","egon"]}})
        db.user.find({"name":{"$nin":["alex","egon"]}})


        #正則匹配
        select * from db1.user where name regexp "^jin.*?(g|n)$";
        db.user.find({
            "name":/^jin.*?(g|n)$/i
        })


        #查看指定字段
        select name,age from db1.user where name regexp "^jin.*?(g|n)$";
        db.user.find({
            "name":/^jin.*?(g|n)$/i
        },
        {
            "_id":0,
            "name":1,
            "age":1
        }
        )

        #查詢數組相關
        db.user.find({
            "hobbies":"dancing"
        })

        db.user.find({
            "hobbies":{"$all":["dancing","tea"]}
        })

        db.user.find({
            "hobbies.2":"dancing"
        })

        db.user.find(
        {},
        {
            "_id":0,
            "name":0,
            "age":0,
            "addr":0,
            "hobbies":{"$slice":[1,2]},
        }
        )


        db.user.find(
        {},
        {
            "_id":0,
            "name":0,
            "age":0,
            "addr":0,
            "hobbies":{"$slice":2},
        }
        )


        db.user.find(
        {
            "addr.country":"China"
        }
        )

        db.user.find().sort({"_id":1,"age":-1})


        db.user.find().limit(2).skip(0)
        db.user.find().limit(2).skip(2)
        db.user.find().limit(2).skip(4)
        db.user.find().distinct()
        
    改
        一 語法：
            db.table.update(
            條件,
            修改字段,
            其他參數
            )

            update db1.t1 set id=10 where name="egon";

            db.table.update(
            {},
            {"age":11},
            {
                "multi":true,
                "upsert":true
            }
            )

            1、update db1.user set age=23,name="武大郎" where name="wupeiqi";
            #覆蓋式
            db.user.update(
                {"name":"wupeiqi"},
                {"age":23,"name":"武大郎"}
            )
            #局部修改:$set
            db.user.update(
                {"name":"alex"},
                {"$set":{"age":73,"name":"潘金蓮-alex"}}
            )

            #改多條
            db.user.update(
                {"_id":{"$gte":1,"$lte":2}},
                {"$set":{"age":53,}},
                {"multi":true}
            )
            #有則修改，無則添加
            db.user.update(
                {"name":"EGON"},
                {"$set":{"name":"EGON","age":28,}},
                {"multi":true,"upsert":true}
            )

            #修改嵌套文檔
            db.user.update(
                {"name":"潘金蓮-alex"},
                {"$set":{"addr.country":"Japan"}}
            )

            #修改數組
            db.user.update(
                {"name":"潘金蓮-alex"},
                {"$set":{"hobbies.1":"Piao"}}
            )

            #刪除字段
            db.user.update(
                {"name":"潘金蓮-alex"},
                {"$unset":{"hobbies":""}}
            )

            2、$inc
            db.user.update(
                {},
                {"$inc":{"age":1}},
                {"multi":true}
            )

            db.user.update(
                {},
                {"$inc":{"age":-10}},
                {"multi":true}
            )

            3、$push, $pop  $pull
            db.user.update(
                {"name":"yuanhao"},
                {"$push":{"hobbies":"tangtou"}},
                {"multi":true}
            )

            db.user.update(
                {"name":"yuanhao"},
                {"$push":{"hobbies":{"$each":["紋身","抽煙"]}}},
                {"multi":true}
            )

            #從頭刪-1，從尾刪1
            db.user.update(
                {"name":"yuanhao"},
                {"$pop":{"hobbies":-1}},
                {"multi":true}
            )

            db.user.update(
                {"name":"yuanhao"},
                {"$pop":{"hobbies":1}},
                {"multi":true}
            )

            #按條件刪
            db.user.update(
                {"name":"yuanhao"},
                {"$pull":{"hobbies":"紋身"}},
                {"multi":true}
            )

            #3、$addToSet
            db.t3.insert({"urls":[]})
            db.t3.update(
                {},
                {"$addToSet":{"urls":{"$each":[
                    "http://www.baidu.com",
                    "http://www.baidu.com",
                    "http://www.baidu.com",
                    "http://www.baidu.com",
                    "http://www.baidu.com"
                ]}}},
                {"multi":true}
            )


    刪
        db.user.deleteOne({"_id":{"$gte":3}})
        db.user.deleteMany({"_id":{"$gte":3}})
        db.user.deleteMany({})

        
    聚合
        一：$match
            例：
                select post from db1.emp where age > 20 group by post having avg(salary) > 10000;

            #$match
            #1、select * from db1.emp where age > 20
            db.emp.aggregate({"$match":{"age":{"$gt":20}}})

            #$group
            #2、select post from db1.emp where age > 20 group by post;
            db.emp.aggregate(
                {"$match":{"age":{"$gt":20}}},
                {"$group":{"_id":"$post"}}
            )

            #3、select post,avg(salary) as avg_salary from db1.emp where age > 20 group by post;
            db.emp.aggregate(
                {"$match":{"age":{"$gt":20}}},
                {"$group":{"_id":"$post","avg_salary":{"$avg":"$salary"}}}
            )

            #select post from db1.emp where age > 20 group by post having avg(salary) > 10000;
            db.emp.aggregate(
                {"$match":{"age":{"$gt":20}}},
                {"$group":{"_id":"$post","avg_salary":{"$avg":"$salary"}}},
                {"$match":{"avg_salary":{"$gt":10000}}}
            )

        二： 投射
　　　　　　      {"$project":{"要保留的字段名":1,"要去掉的字段名":0,"新增的字段名":"表達式"}}
            例1：
            db.emp.aggregate(
                {"$project":{"_id":0,"name":1,"post":1,"annual_salary":{"$multiply":[12,"$salary"]}}},
                {"$group":{"_id":"$post","平均年薪":{"$avg":"$annual_salary"}}},
                {"$match":{"平均年薪":{"$gt":1000000}}},
                {"$project":{"部門名":"$_id","平均年薪":1,"_id":0}}
            )

            例2：
            db.emp.aggregate(
                {"$project":{"_id":0,"name":1,"hire_period":{"$subtract":[new Date(),"$hire_date"]}}}
            )


            db.emp.aggregate(
                {"$project":{"_id":0,"name":1,"hire_year":{"$year":"$hire_date"}}}
            )

            db.emp.aggregate(
                {"$project":{"_id":0,"name":1,"hire_period":{"$subtract":[{"$year":new Date()},{"$year":"$hire_date"}]}}}
            )

            例3：
            db.emp.aggregate(
                {"$project":{"_id":0,"new_name":{"$toUpper":"$name"},}}
            )

            db.emp.aggregate(
                {"$match":{"name":{"$ne":"egon"}}},
                {"$project":{"_id":0,"new_name":{"$concat":["$name","_SB"]},}}
            )

            db.emp.aggregate(
                {"$match":{"name":{"$ne":"egon"}}},
                {"$project":{"_id":0,"new_name":{"$substr":["$name",0,3]},}}
            )

        三：{"$group":{"_id":分組字段,"新的字段名":聚合操作符}}

            #select post,max,min,sum,avg,count,group_concat from db1.emp group by post;

            db.emp.aggregate(
                {"$group":{
                    "_id":"$post",
                    "max_age":{"$max":"$age"},
                    "min_id":{"$min":"$_id"},
                    "avg_salary":{"$avg":"$salary"},
                    "sum_salary":{"$sum":"$salary"},
                    "count":{"$sum":1},
                    "names":{"$push":"$name"}
                    }
                }
            )


        四：排序：$sort、限制：$limit、跳過：$skip
            db.emp.aggregate(
                {"$match":{"name":{"$ne":"egon"}}},
                {"$project":{"_id":1,"new_name":{"$substr":["$name",0,3]},"age":1}},
                {"$sort":{"age":1,"_id":-1}},
                {"$skip":5},
                {"$limit":5}
            )


        # 補充
        db.emp.aggregate({"$sample":{"size":3}})   #隨機選取3個文檔

補充：

db.tb1.find() //查詢全部，用it查看下一頁。
db.tb1.find({"age":1}) //查詢年齡==1的記錄
db.tb1.find({},{"age":1}) //查詢年齡==1的記錄
db.tb1.find({"name":{$all:["a","b"]}}) //查詢name含有a,b的記錄
db.tb1.find({"name":{$exists:true}}) //查詢存在name字段的記錄。
db.tb1.find({"age":{$nin:[12,14]}}) //查詢age不含12,14值的記錄。
db.tb1.find({name) //查詢name含a字母的記錄

.......

總結如下：
查詢格式如下：Db.collection.find({“field”: { operator: val}})
field為colleciton的字段名,operator為操作符，val為比較值。
operator有如下：
$gt,$gte,$lt,$lte: val  v1.
$all :都有, val  {v1,v2,v3...}
$exists:存在, val  true/false;
$ne :不等於, val  v1
$mod: 取模。 Val  [v1取模數,v2余數]
$in :包含某值，val  [v1,v2,v3...]
$nin :不包含某值，val  [v1,v2,v3...]
$size: 指定長度數組, val  v1
$regex: 正則查詢,val  v1 :通配符查詢：/s/ ,但是s/，/是這樣語法錯誤。
Javascript查詢: 編寫function,然后查詢。

>Find(條件).count() / limit(v) /skip(v) /sort({“field”: 1/-1},{“field2”: 1/-1}...)
分頁查詢，通過limit,skip,sort組合進行分頁查詢。
如每頁X條，第N頁
> Find(條件).SKIP * X).Limit(X).SORT.
distinct: 查詢指定鍵的不同值。db.runCommand({"distinct":”集合名","key":"字段名"})
group: 較復雜。

五、mongodb聚合利用日期分組

參考：https://blog.csdn.net/u013066244/article/details/53842355

$dayOfYear: 返回該日期是這一年的第幾天。（全年366天）
$dayOfMonth: 返回該日期是這一個月的第幾天。（1到31）
$dayOfWeek: 返回的是這個周的星期幾。（1：星期日，7：星期六）
$year: 返回該日期的年份部分
$month： 返回該日期的月份部分（between 1 and 12.）
$week： 返回該日期是所在年的第幾個星期（between 0 and 53）
$hour： 返回該日期的小時部分
$minute: 返回該日期的分鍾部分
$second: 返回該日期的秒部分（以0到59之間的數字形式返回日期的第二部分，但可以是60來計算閏秒。）
$millisecond：返回該日期的毫秒部分（between 0 and 999.）
$dateToString：
    { $dateToString: { format: <formatString>, date: <dateExpression> } }

%Y  Year (4 digits, zero padded)    0000-9999
%m  Month (2 digits, zero padded)   01-12
%d  Day of Month (2 digits, zero padded)    01-31
%H  Hour (2 digits, zero padded, 24-hour clock) 00-23
%M  Minute (2 digits, zero padded)  00-59
%S  Second (2 digits, zero padded)  00-60
%L  Millisecond (3 digits, zero padded) 000-999
%j  Day of year (3 digits, zero padded) 001-366
%w  Day of week (1-Sunday, 7-Saturday)  1-7
%U  Week of year (2 digits, zero padded)    00-53
%%  Percent Character as a Literal  %

假設有這么一個集合

{
  "_id" : 1,
  "item" : "abc",
  "price" : 10,
  "quantity" : 2,
  "date" : ISODate("2014-01-01T08:15:39.736Z")
}

我們在執行：

$project yearMonthDay format 都要加 “ ” 才行。

db.sales.aggregate(
   [
     {
       $project: {
          yearMonthDay: { $dateToString: { format: "%Y-%m-%d", date: "$date" } },
          time: { $dateToString: { format: "%H:%M:%S:%L", date: "$date" } }
       }
     }
   ]
)

結果就是：

{ "_id" : 1, "yearMonthDay" : "2014-01-01", "time" : "08:15:39:736" }

$dateToString，這個需要mongodb3.0+支持。

再執行：

注意：year 和 $year 。。。要加 “ ” 才能正常顯示

db.sales.aggregate(
   [
     {
       $project:
         {
           year: { $year: "$date" },
           month: { $month: "$date" },
           day: { $dayOfMonth: "$date" },
           hour: { $hour: "$date" },
           minutes: { $minute: "$date" },
           seconds: { $second: "$date" },
           milliseconds: { $millisecond: "$date" },
           dayOfYear: { $dayOfYear: "$date" },
           dayOfWeek: { $dayOfWeek: "$date" },
           week: { $week: "$date" }
         }
     }
   ]
)

得到的結果就是：

{
  "_id" : 1,
  "year" : 2014,
  "month" : 1,
  "day" : 1,
  "hour" : 8,
  "minutes" : 15,
  "seconds" : 39,
  "milliseconds" : 736,
  "dayOfYear" : 1,
  "dayOfWeek" : 4,
  "week" : 0
}

六、pymongo處理正則表達式的情況

在python里使用pymongo處理mongodb數據庫，在插入或者查詢的時候，我們有時需要使用操作符號，如set，in，

具體操作符的可以參考 https://docs.mongodb.com/manual/reference/operator/query/

需求：需要用到正則表達式來插入或查詢，如何操作？

1.首先要了解一下，mongodb里面的正則表達式怎么用

參考：https://docs.mongodb.com/manual/reference/operator/query/regex/

使用如下語法：

{ <field>: { $regex: /pattern/, $options: '<options>' } }
{ <field>: { $regex: 'pattern', $options: '<options>' } }
{ <field>: { $regex: /pattern/<options> } }

或者

{ <field>: /pattern/<options> }

當然option的含義是對正則表達式的一種選擇，有

i 不區分大小寫

m 包含錨的模式（即起始為 ^，結束為 $）

x 擴展

s 允許.點字符

詳細的參考官網，這只是很簡單的介紹

2.在pymongo里如何使用

mongodb默認使用的是bson數據，所以要在python里轉換為該格式的數據

import bson

然后參照官網教程：http://api.mongodb.com/python/current/api/bson/regex.html

>>> pattern = re.compile('.*')
>>> regex = Regex.from_native(pattern)
>>> regex.flags ^= re.UNICODE
>>> db.collection.insert({'pattern': regex})

這里注意一下，Regex是bson的類，可以導入

我的實例：

    for collection in col_list:
        pattern = re.compile(time.strftime('%Y-%m-%d'))
        regex = bson.regex.Regex.from_native(pattern)
        regex.flags ^= re.UNICODE
        for item in db[collection].find({"insert_time":regex}):
            for j in item['value']:
                ...

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 可視化工具之 IGV 使用方法 mongoDB可視化工具 mongodb與mongodb可視化工具adminMongo結合使用 MongoDB可視化工具--Robo 3T 使用教程 MongoDB可視化工具Studio 3T的使用 MongoDB可視化工具--Robo 3T 使用教程【MongoDB】2.可視化工具的安裝和使用【MongoDB】2.可視化工具的安裝和使用 mongoDB可視化工具RoBo 3T的安裝和使用 MongoDB 可視化工具RoboMongo --- windows