In diesem Artikel werde ich beschreiben, wie Aggregat (Aggregatfunktion in SQL) verwendet wird, nachdem mit Python eine Verbindung zu Mongodb hergestellt wurde. In den folgenden Artikeln erfahren Sie, wie Sie mongodb starten und pymongo installieren. https://qiita.com/bc_yuuuuuki/items/2b92598434f6cc320112
Für die Vorbereitungsdaten verwenden wir die Artikelinformationen von Qiita, die im folgenden Artikel in mongoDB eingetaucht sind [Python] Ich habe Qiitas Artikelinformationen in mongoDB eingefügt
Wie man das Aggregat von mongoDB verwendet, fällt mir nicht ein, wenn Sie an SQL gewöhnt sind. Die folgende Tabelle ist eine Vergleichstabelle von SQL und Aggregat.
| SQL | aggregate |
|---|---|
| WHERE | $match |
| GROUP BY | $group |
| HAVING | $match |
| SELECT | $project |
| ORDER BY | $sort |
| LIMIT | $limit |
| SUM() | $sum |
| COUNT() | $sum |
Ich mache verschiedene Klassen, die MongoDB mit Pymongo verwenden.
mongo_sample.py
from pymongo import MongoClient
class MongoSample(object):
def __init__(self, dbName, collectionName):
self.client = MongoClient()
self.db = self.client[dbName] #Legen Sie den DB-Namen fest
self.collection = self.db.get_collection(collectionName)
def aggregate(self, filter, **keyword):
return self.collection.aggregate(filter, keyword)
Ich erstelle gerade eine Funktion zum Aufrufen von Aggregat.
Erstens ist der Code.
aggregate_sample.py
from mongo_sample import MongoSample
import pprint
# arg1:DB Name
# arg2:Collection Name
mongo = MongoSample("db", "qiita")
#Maximalwert
pipeline = [
{"$group":{ "_id":"title","page_max_view":{"$max":"$page_views_count"}}}
]
results = mongo.aggregate(pipeline)
print("------------------------Maximalwert-----------------------------")
pprint.pprint(list(results))
#Mindestwert
pipeline = [
{"$group":{ "_id":"title","page_min_view":{"$min":"$page_views_count"}}}
]
results = mongo.aggregate(pipeline)
print("------------------------Mindestwert-----------------------------")
pprint.pprint(list(results))
#Durchschnittswert
pipeline = [
{"$group":{ "_id":"average","page_average_view":{"$avg":"$page_views_count"}}}
]
#gesamt
pipeline = [
{"$group":{"_id":"page_total_count","total":{"$sum":"$page_views_count"}}}
]
results = mongo.aggregate(pipeline)
print("------------------------Durchschnittswert-----------------------------")
pprint.pprint(list(results))
#Zählen Sie die Anzahl der Vorkommen für jedes Tag
pipeline = [
{ "$unwind": "$tag_list"},
{ "$group": { "_id": "$tag_list", "count": { "$sum":1}}},
{ "$sort": {"count": -1, "_id":1}}
]
results = mongo.aggregate(pipeline)
print("------------------------Gesamtwert-----------------------------")
pprint.pprint(list(results))
Was Sie tun, ist keine große Sache. Der Maximalwert, der Minimalwert, der Durchschnittswert und die Anzahl für jedes Tag werden erfasst.
pprint muss installiert sein.
pip install pprint
Wir werden jedes mit der Operationsmethode von mongoDB vergleichen.
Zuerst der Befehl mongoDB Das Beispiel ist nur der Maximalwert. Wenn max in min, avg oder sum geändert wird, wird dies zum minimalen / durchschnittlichen / maximalen Wert.
db.qiita.aggregate([{$group:{_id:"page_max_views",total:{$max:"$page_views_count"}}}])
pipeline = [
{"$group":{ "_id":"title","page_max_view":{"$max":"$page_views_count"}}}
]
Ausführungsergebnis
[{'_id': 'title', 'page_max_view': 2461}]
Diese Methode hat "_id" auf "title" festgelegt und dazu geführt, dass in allen Datensätzen der Maximalwert ermittelt wurde.
Ich möchte jedoch den Titel des Artikels anzeigen, da ich wissen möchte, welcher Artikel am meisten gelesen wird.
mongoDB Befehl
> db.qiita.aggregate([{$project:{title:1,page_views_count:1}},{$group:{_id:"$title", total:{$max:"$page_views_count"}}},{$sort:{total:-1}}])
{"_id": "Mongodb mit Python-Teil 2 betreiben: find-", "total": 2461}
{"_id": "Mongodb mit Python-Teil 3 betreiben: update-", "total": 1137}
{"_id": "Mongodb mit Python-Part 4 betreiben: insert-", "total": 1102}
{"_id": "Verschiedene Suchbedingungen mit Pymongo (UND / ODER / Teilübereinstimmung / Bereichssuche)", "gesamt": 1019}
(Weggelassen)
Mit diesem Befehl konnte ich den Titel des Artikels und die Häufigkeit sehen, mit der die Seite angezeigt wurde. Offensichtlich macht es nicht viel Sinn, da es nach Artikelnamen gruppiert ist. .. Wenn es sich um den Maximalwert handelt, für den keine Gruppierung erforderlich ist, scheint es gut zu sein, mit find und set limit zu sortieren.
Versuchen Sie, den Maximalwert für jedes Tag1 zu ermitteln.
> db.qiita.aggregate([{$group:{_id:"$tag1", total:{$max:"$page_views_count"}}},{$sort:{total:-1}}])
{ "_id" : "Python", "total" : 2461 }
{ "_id" : "Vagrant", "total" : 946 }
{ "_id" : "Java", "total" : 617 }
{ "_id" : "Hyperledger", "total" : 598 }
{ "_id" : "solidity", "total" : 363 }
{ "_id" : "Ethereum", "total" : 347 }
{"_id": "blockchain", "total": 232}
{ "_id" : "Blockchain", "total" : 201 }
{ "_id" : "coverage", "total" : 199 }
Ja. Ich habe es mit einem guten Gefühl bekommen.
Vorerst werde ich auch den Python-Code ändern.
# Maximalwert
pipeline = [
{"$group":{ "_id":"$tag1","page_max_view":{"$max":"$page_views_count"}}}
]
results = mongo.aggregate(pipeline)
print ("------------------------ Maximalwert --------------------- -------- ")
pprint.pprint(list(results))
Ich möchte zählen, wie viele Artikel für jedes Tag geschrieben werden. Die Aggregation verwendet ein Element namens tag_list, das folgendermaßen aussieht:
> db.qiita.find({},{_id:0,tag_list:1})
{ "tag_list" : [ "Python", "MongoDB", "Python3", "pymongo" ] }
{ "tag_list" : [ "Python", "Python3" ] }
{"tag_list": ["Python", "Python3", "Blockchain", "Blockchain", "Hyperledger-Iroha"]}
{"tag_list": ["Blockchain", "Blockchain", "Hyperledger-Iroha"]}
{ "tag_list" : [ "Blockchain", "Ethereum", "Hyperledger", "Hyperledger-sawtooth" ] }
{"tag_list": ["Blockchain", "Hyperledger", "Hyperledger-Sägezahn"]}
{"tag_list": ["Java", "Blockchain", "Hyperledger", "Hyperledger-Iroha"]}
{"tag_list": ["Blockchain", "Hyperledger", "Hyperledger-Iroha"]}
{"tag_list": ["Java", "Ethereum", "Blockchain", "Hyperledger", "Hyperledger-Iroha"]}
{"tag_list": ["Java", "Blockchain", "Hyperledger", "Hyperledger-Iroha"]}
{ "tag_list" : [ "Hyperledger", "Hyperledger-Iroha", "Hyperledger-burrow", "Hyperledger-sawtooth", "Hyperledger-besu" ] }
{ "tag_list" : [ "Vagrant", "VirtualBox", "Hyper-V" ] }
{"tag_list": ["Java", "Ethereum", "Solidität", "Blockchain", "web3j"]}
{"tag_list": ["Java", "Ethereum", "blockchain", "web3j"]}
{"tag_list": ["Java", "Ethereum", "blockchain", "web3j"]}
{"tag_list": ["Java", "Ethereum", "blockchain", "web3j"]}
{"tag_list": ["Java", "Ethereum", "Solidität", "Blockchain", "web3j"]}
{"tag_list": ["Java", "Ethereum", "blockchain", "web3j"]}
{"tag_list": ["Java", "Ethereum", "blockchain", "web3j"]}
{"tag_list": ["Ethereum", "blockchain"]}
Es ist ziemlich ärgerlich, die in diesem Format in SQL gespeicherten Daten zusammenzufassen. ..
In mongoDB ist es durch die Verwendung von "Unwind" möglich, Daten im LIST-Format zu teilen und zu aggregieren.
> db.qiita.aggregate( { $project:{tag_list:1}}, { $unwind: "$tag_list"}, { $group: { _id: "$tag_list", count: { $sum:1}}},{ $sort: {"count": -1, "_id":1}} )
{"_id": "blockchain", "count": 16}
{ "_id" : "Ethereum", "count" : 11 }
{ "_id" : "Java", "count" : 10 }
{ "_id" : "Python", "count" : 9 }
{ "_id" : "Python3", "count" : 9 }
{ "_id" : "Hyperledger", "count" : 7 }
{ "_id" : "Hyperledger-Iroha", "count" : 7 }
{ "_id" : "MongoDB", "count" : 7 }
{ "_id" : "web3j", "count" : 7 }
{ "_id" : "solidity", "count" : 4 }
{ "_id" : "Blockchain", "count" : 3 }
{ "_id" : "Hyperledger-sawtooth", "count" : 3 }
{ "_id" : "Hyper-V", "count" : 1 }
{ "_id" : "Hyperledger-besu", "count" : 1 }
{ "_id" : "Hyperledger-burrow", "count" : 1 }
{ "_id" : "Vagrant", "count" : 1 }
{ "_id" : "VirtualBox", "count" : 1 }
{ "_id" : "coverage", "count" : 1 }
{ "_id" : "pymongo", "count" : 1 }
{ "_id" : "truffle", "count" : 1 }
Der Python-Code enthält nicht "{" $ project ": {" tag_list ": 1}}". Das Ergebnis hat sich mit oder ohne nicht geändert. Ich bin mir nicht sicher, wie ich dieses Projekt verwenden soll.
Es gibt viele Teile, die schwer zu verstehen sind, wenn Sie an SQL gewöhnt sind, aber es scheint, dass eine flexible Aggregation mithilfe von Unwind usw. erfolgen kann.
Recommended Posts