MongoDB(28) - 集計処理（aggregate）⑨コレクション結合・オブジェクト型と文字列型に展開

今回は、結合したコレクションをオブジェクト型と文字列型に展開します。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

オブジェクト型に変換

前回のコレクション結合では、結合先コレクションのdivision_docsが [{}] というように配列の中にオブジェクトが入っている構造になっています。

$unwindを使うと、配列の中の値を展開することができます。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> db.employee.aggregate([
     {$lookup:{
         from: "division",
         localField:"k_id",
         foreignField:"k_id",
         as: "division_docs"
     }},
     {$project:{
         "_id":0,
         "name":1,
         "division_docs.name":1
     }},
     {$unwind:"$division_docs"}
 ])
{ "name" : "高山", "division_docs" : { "name" : "総務課" } }
{ "name" : "生駒", "division_docs" : { "name" : "企画課" } }
{ "name" : "嘉喜", "division_docs" : { "name" : "開発1課" } }
{ "name" : "与田", "division_docs" : { "name" : "開発2課" } }
{ "name" : "松田", "division_docs" : { "name" : "開発1課" } }
{ "name" : "菅井", "division_docs" : { "name" : "開発2課" } }

division_docsの[]がとれて、{}というオブジェクト型になりました。

文字列型に変換

次にオブジェクト型を文字列型に変換します。

オブジェクト型に変換したデータに対して$groupを使い_id（集計キー）にe_id（従業員ID）を指定します。

e_idはユニークなので集計されません。

さらに表示したいフィールドに何らかの集計関数(maxなど)を使って、オブジェクト型から文字列型に変換します。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
> db.employee.aggregate([
     {$lookup:{
         from: "division",
         localField:"k_id",
         foreignField:"k_id",
         as: "division_docs"
     }},
     {$project:{
         "_id":0,
         "e_id":1,
         "name":1,
         "division_docs.name":1
     }},
     {$unwind:"$division_docs"},
     {$group:{
         _id:"$e_id",
         employeeName:{$max:"$name"},
         divisionName:{$max:"$division_docs.name"}
     }}
 ])
{ "_id" : "emp002", "employeeName" : "生駒", "divisionName" : "企画課" }
{ "_id" : "emp001", "employeeName" : "高山", "divisionName" : "総務課" }
{ "_id" : "emp004", "employeeName" : "与田", "divisionName" : "開発2課" }
{ "_id" : "emp006", "employeeName" : "菅井", "divisionName" : "開発2課" }
{ "_id" : "emp005", "employeeName" : "松田", "divisionName" : "開発1課" }
{ "_id" : "emp003", "employeeName" : "嘉喜", "divisionName" : "開発1課" }

結合した課コレクションの課の名称(division_docs.name)を、オブジェクト型から文字列型に変換することができました。

少々強引な方法なので、アプリケーション側で処理した方が楽に展開できるかもしれません。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# コレクションの結合（オブジェクト型に展開）
docs = db1.employee.aggregate([
             {'$lookup':{
                 'from': 'division',
                 'localField':'k_id',
                 'foreignField':'k_id',
                 'as': 'division_docs'
             }},
             {'$project':{
                 '_id':0,
                 'name':1,
                 'division_docs.name':1
             }},
             {'$unwind':'$division_docs'}
            ])
for doc in docs:
    print(doc)

# コレクションの結合（文字列型に展開）
docs = db1.employee.aggregate([
             {'$lookup':{
                 'from': 'division',
                 'localField':'k_id',
                 'foreignField':'k_id',
                 'as': 'division_docs'
             }},
             {'$project':{
                 '_id':0,
                 'e_id':1,
                 'name':1,
                 'division_docs.name':1
             }},
             {'$unwind':'$division_docs'},
             {'$group':{
                 '_id':'$e_id',
                 'employeeName':{'$max':'$name'},
                 'divisionName':{'$max':'$division_docs.name'}
             }}
           ])
for doc in docs:
    print(doc)

次回は、コレクションの二重結合を行います。

MongoDB(27) - 集計処理（aggregate）⑧コレクション結合

今回は、コレクションの結合を行います。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

コレクションの結合

$lookupを使うと、コレクションの結合を行うことができます。

従業員コレクション(employee)と課コレクション(division)を結合します。

設定値の意味は下記の通りです。

  • from
    結合先のコレクション名
  • localField
    結合元のフィールド名
  • foreignField
    結合先のフィールド名
  • as
    結合先コレクションの別名

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> db.employee.aggregate([
     {$lookup:{
         from: "division",
         localField:"k_id",
         foreignField:"k_id",
         as: "division_docs"
     }}
 ])
{ "_id" : ObjectId("612f07f568110fe533ed9d21"), "e_id" : "emp001", "k_id" : "ka1", "p_id" : "po1", "name" : "高山", "age" : 31, "salary" : 400000, "division_docs" : [ { "_id" : ObjectId("612f07b568110fe533ed9d19"), "k_id" : "ka1", "b_id" : "bu1", "name" : "総務課" } ] }
{ "_id" : ObjectId("612f07f568110fe533ed9d22"), "e_id" : "emp002", "k_id" : "ka2", "p_id" : "po2", "name" : "生駒", "age" : 37, "salary" : 250000, "division_docs" : [ { "_id" : ObjectId("612f07b568110fe533ed9d1a"), "k_id" : "ka2", "b_id" : "bu2", "name" : "企画課" } ] }
{ "_id" : ObjectId("612f07f568110fe533ed9d23"), "e_id" : "emp003", "k_id" : "ka3", "p_id" : "po3", "name" : "嘉喜", "age" : 23, "salary" : 200000, "division_docs" : [ { "_id" : ObjectId("612f07b568110fe533ed9d1b"), "k_id" : "ka3", "b_id" : "bu3", "name" : "開発1課" } ] }
{ "_id" : ObjectId("612f07f568110fe533ed9d24"), "e_id" : "emp004", "k_id" : "ka4", "p_id" : "po4", "name" : "与田", "age" : 33, "salary" : 100000, "division_docs" : [ { "_id" : ObjectId("612f07b568110fe533ed9d1c"), "k_id" : "ka4", "b_id" : "bu3", "name" : "開発2課" } ] }
{ "_id" : ObjectId("612f07f568110fe533ed9d25"), "e_id" : "emp005", "k_id" : "ka3", "p_id" : "po4", "name" : "松田", "age" : 35, "salary" : 550000, "division_docs" : [ { "_id" : ObjectId("612f07b568110fe533ed9d1b"), "k_id" : "ka3", "b_id" : "bu3", "name" : "開発1課" } ] }
{ "_id" : ObjectId("612f07f568110fe533ed9d26"), "e_id" : "emp006", "k_id" : "ka4", "p_id" : "po4", "name" : "菅井", "age" : 45, "salary" : 120000, "division_docs" : [ { "_id" : ObjectId("612f07b568110fe533ed9d1c"), "k_id" : "ka4", "b_id" : "bu3", "name" : "開発2課" } ] }

“division_docs”という配列のデータが、結合したコレクションから取得したデータになります。

結合したコレクションの表示フィールドを絞る

$projectを使うと、結合したコレクションの表示フィールドを絞って表示することができます。

_idを非表示にして、従業員コレクションのnameと課コレクションのnameだけを表示してみます。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
> db.employee.aggregate([
     {$lookup:{
         from: "division",
         localField:"k_id",
         foreignField:"k_id",
         as: "division_docs"
     }},
     {$project:{
         "_id":0,
         "name":1,
         "division_docs.name":1
     }}
 ])
{ "name" : "高山", "division_docs" : [ { "name" : "総務課" } ] }
{ "name" : "生駒", "division_docs" : [ { "name" : "企画課" } ] }
{ "name" : "嘉喜", "division_docs" : [ { "name" : "開発1課" } ] }
{ "name" : "与田", "division_docs" : [ { "name" : "開発2課" } ] }
{ "name" : "松田", "division_docs" : [ { "name" : "開発1課" } ] }
{ "name" : "菅井", "division_docs" : [ { "name" : "開発2課" } ] }

指定した通りのフィールドを表示することができました。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# コレクションの結合
docs = db1.employee.aggregate([
             {'$lookup':{
                 'from': 'division',
                 'localField':'k_id',
                 'foreignField':'k_id',
                 'as': 'division_docs'
             }}
            ])
for doc in docs:
    print(doc)

# 結合したコレクションの表示フィールドを絞る
docs = db1.employee.aggregate([
             {'$lookup':{
                 'from': 'division',
                 'localField':'k_id',
                 'foreignField':'k_id',
                 'as': 'division_docs'
             }},
             {'$project':{
                 '_id':0,
                 'name':1,
                 'division_docs.name':1
             }}
           ])
for doc in docs:
    print(doc)

次回は、結合したコレクションをオブジェクト型と文字列型に展開します。

MongoDB(26) - 集計処理（aggregate）⑦データ数のカウント

今回は、データ数のカウントを行います。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

データ数のカウント

データ数をカウントする場合は、$countを使います。

$countには表示名を指定します。

[Mongoシェル]

1
2
3
4
> db.employee.aggregate([
     {$count: "employee_count"}
 ])
{ "employee_count" : 6 }

従業員コレクション(employee)全体のデータ数をカウントできました。

条件を指定してデータ数のカウント

$matchに検索条件を指定すると、条件を指定してのデータ数カウントができます。

30歳以上の従業員数をカウントする場合は、以下のようになります。

[Mongoシェル]

1
2
3
4
5
> db.employee.aggregate([
     {$match: {age: {$gte:30}}},
     {$count: "employee_count"}
 ])
{ "employee_count" : 5 }

グループごとのカウント

$countでは、グループごとのカウントを行うことができません。

$groupと$sumを使うことでグループごとのカウントを行うことができます。

ポイントは{$sum:1}とすることです。

[Mongoシェル]

1
2
3
4
5
6
7
> db.employee.aggregate([
     {$group: {_id:"$k_id", employee_count:{$sum:1}}}
 ])
{ "_id" : "ka2", "employee_count" : 1 }
{ "_id" : "ka3", "employee_count" : 2 }
{ "_id" : "ka4", "employee_count" : 2 }
{ "_id" : "ka1", "employee_count" : 1 }

課ごとの従業員数をカウントすることができました。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# コレクション全体のカウント（従業員数）
docs = db1.employee.aggregate([
               {'$count': 'employee_count'}
            ])
for doc in docs:
    print(doc)

# 30歳以上の従業員数をカウント
docs = db1.employee.aggregate([
               {'$match': {'age': {'$gte':30}}},
               {'$count': 'employee_count'}
            ])
for doc in docs:
    print(doc)

# 課ごとの従業員数をカウント
docs = db1.employee.aggregate([
               {'$group': {'_id':'$k_id', 'employee_count':{'$sum':1}}}
            ])
for doc in docs:
    print(doc)

次回は、コレクションの結合を行います。

MongoDB(25) - 集計処理（aggregate）⑥コレクション全体の集計

今回は、コレクション全体の集計を行います。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

コレクション全体の集計

$groupを使って、コレクション全体の集計を行うことができます。

コレクション全体の集計を行うためには_idにnullを指定します。

[Mongoシェル]

1
2
3
4
> db.employee.aggregate([
...     {$group: {_id:null, total:{$sum:"$salary"}}}
... ])
{ "_id" : null, "total" : 1620000 }

従業員コレクション(employee)全体の給料合計を集計することができました。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

pythonではnullの代わりにNoneを指定します。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# コレクション全体の集計
docs = db1.employee.aggregate([
               {'$group': {'_id':None, 'total':{'$sum':'$salary'}}}
            ])
for doc in docs:
    print(doc)

次回は、データ数のカウントを行います。

MongoDB(24) - 集計処理（aggregate）⑤最大値・最小値・平均値の集計

今回は、最大値・最小値・平均値の集計を行います。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

最大値取得

$maxを使うと、最大値を取得することができます。

[Mongoシェル]

1
2
3
4
5
6
7
> db.employee.aggregate([
           {$group: {_id:"$k_id", salary_max:{$max:"$salary"}}}
    ])
{ "_id" : "ka1", "salary_max" : 400000 }
{ "_id" : "ka3", "salary_max" : 550000 }
{ "_id" : "ka4", "salary_max" : 120000 }
{ "_id" : "ka2", "salary_max" : 250000 }

最小値取得

$minを使うと、最小値を取得することができます。

[Mongoシェル]

1
2
3
4
5
6
7
> db.employee.aggregate([
        {$group: {_id:"$k_id", salary_min:{$min:"$salary"}}}
    ])
{ "_id" : "ka1", "salary_min" : 400000 }
{ "_id" : "ka3", "salary_min" : 200000 }
{ "_id" : "ka4", "salary_min" : 100000 }
{ "_id" : "ka2", "salary_min" : 250000 }

平均値取得

$avgを使うと、平均値を取得することができます。

[Mongoシェル]

1
2
3
4
5
6
7
> db.employee.aggregate([
        {$group: {_id:"$k_id", salary_avg:{$avg:"$salary"}}}
    ])
{ "_id" : "ka1", "salary_avg" : 400000 }
{ "_id" : "ka2", "salary_avg" : 250000 }
{ "_id" : "ka3", "salary_avg" : 375000 }
{ "_id" : "ka4", "salary_avg" : 110000 }

複数の集計を同時に行う

$groupの後にフィールドを追加していくことで、複数の集計を同時に行うことができます。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
> db.employee.aggregate([
        {$group: {_id:"$k_id", salary_max:{$max:"$salary"},
                               salary_min:{$min:"$salary"},
                               salary_avg:{$avg:"$salary"}}}
    ])
{ "_id" : "ka1", "salary_max" : 400000, "salary_min" : 400000, "salary_avg" : 400000 }
{ "_id" : "ka2", "salary_max" : 250000, "salary_min" : 250000, "salary_avg" : 250000 }
{ "_id" : "ka3", "salary_max" : 550000, "salary_min" : 200000, "salary_avg" : 375000 }
{ "_id" : "ka4", "salary_max" : 120000, "salary_min" : 100000, "salary_avg" : 110000 }

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# 最大値を取得
docs = db1.employee.aggregate([
               {'$group': {'_id':'$k_id', 'salary_max':{'$max':'$salary'}}}
            ])
for doc in docs:
    print(doc)

# 最小値を取得
docs = db1.employee.aggregate([
               {'$group': {'_id':'$k_id', 'salary_min':{'$min':'$salary'}}}
            ])
for doc in docs:
    print(doc)

# 平均値を取得
docs = db1.employee.aggregate([
               {'$group': {'_id':'$k_id', 'salary_avg':{'$avg':'$salary'}}}
            ])
for doc in docs:
    print(doc)

# 最大値・最小値・平均値を取得
docs = db1.employee.aggregate([
               {'$group': {'_id':'$k_id','salary_max':{'$max':'$salary'},
                                         'salary_min':{'$min':'$salary'},
                                         'salary_avg':{'$avg':'$salary'}}}
            ])
for doc in docs:
    print(doc)

次回は、コレクション全体の集計を行います。

MongoDB(23) - 集計処理（aggregate）④集計前後に検索

今回は、集計の前後に検索を行ってみます。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

集計後に検索

集計後に検索を行います。

具体的には①課ごとに給料合計を集計し、②総務課を抽出します。

groupにフィールドを指定する場合はフィールド名の先頭に$を付けますが、matchにフィールドを指定する場合はフィールド名の先頭に$をつける必要はありません。

[Mongoシェル]

1
2
3
4
5
6
> db.employee.aggregate([
          {$group: {_id:"$k_id", salary_total:{$sum:"$salary"}}},
          {$match: {_id:"ka1"}},
       ])

> { "_id" : "ka1", "salary_total" : 400000 }

集計結果への検索を行うことができました。

集計の前後に検索

集計前と集計後に検索を行います。

具体的には①３０歳以上の従業員を検索し、②課ごとに給料合計を集計し、③開発1課を抽出します。

[Mongoシェル]

1
2
3
4
5
6
7
>  db.employee.aggregate([
          {$match: {age:{$gte: 30}}},
          {$group: {_id:"$k_id", salary_total:{$sum:"$salary"}}},
          {$match: {_id:"ka3"}},
       ])

> { "_id" : "ka3", "salary_total" : 550000 }

集計の前と後に検索を行うことができました。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# ①課ごとに給料合計を集計
# ②総務課を抽出
docs = db1.employee.aggregate([
            {'$group':{'_id':'$k_id', 'salary_total':{'$sum':'$salary'}}},
            {'$match': {'_id': 'ka1'}}
            ])
for doc in docs:
    print(doc)

# ①３０歳以上の従業員
# ②課ごとに給料合計を集計
# ③開発1課を抽出
docs = db1.employee.aggregate([
            {'$match': {'age': {'$gte':30}}},
            {'$group':{'_id':'$k_id', 'salary_total':{'$sum':'$salary'}}},
            {'$match': {'_id': 'ka3'}}
            ])
for doc in docs:
    print(doc)

次回は、最大値・最小値・平均値の集計を行います。

MongoDB(22) - 集計処理（aggregate）③合計(sum)+条件(match)

今回は、検索条件に年齢を加えて集計を行います。

サンプルデータ

以前用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

検索条件を追加して課ごとの給料合計

集計時の検索条件を追加する場合は$matchを使います。

従業員コレクション(employee)から、年齢が35歳以上の従業員を対象として課ごとの給料合計を表示します。

[Mongoシェル]

1
2
3
4
5
6
7
> db.employee.aggregate([
     {$match: {age: {$gte:35}}},
     {$group:{_id:"$k_id", salary_total:{$sum:"$salary"}}}
  ])
{ "_id" : "ka3", "salary_total" : 550000 }
{ "_id" : "ka4", "salary_total" : 120000 }
{ "_id" : "ka2", "salary_total" : 250000 }

35歳以上の従業員の給料合計を、課ごとに集計できました。

groupとmatchの順番を入れ替える

$groupと$matchの順番は入れ替えることができます。

先ほど実行した集計に関して、$groupと$matchの順番を入れ替えて実行してみます。

[Mongoシェル]

1
2
3
4
5
6
> db.employee.aggregate([
     {$group:{_id:"$k_id", salary_total:{$sum:"$salary"}}},
     {$match: {age: {$gte:35}}}
  ])

>

何も結果が返ってきませんでした。どうしてでしょうか。


理由は、aggregateではクエリーを上から順番に実行しているためです。

まず、$groupで課ごとに集計作業が実行されて_idとsalary_totalのフィールドのみの結果になります。
次にageフィールドで検索を行っても、ageフィールドがないため検索結果がないということになります。

$groupと$matchは順番を変えたり、複数回指定することが可能ですが、その順番には気を付けましょう。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# ①年齢が35歳以上の従業員
# ②課ごとの給料合計表示
docs = db1.employee.aggregate([
            {'$match': {'age': {'$gte':35}}},
            {'$group':{'_id':'$k_id', 'salary_total':{'$sum':'$salary'}}}])
for doc in docs:
    print(doc)

# ①課ごとの給料合計算出
# ②年齢が35歳以上の従業員
docs = db1.employee.aggregate([
            {'$group':{'_id':'$k_id', 'salary_total':{'$sum':'$salary'}}},
            {'$match': {'age': {'$gte':35}}}])
for doc in docs:
    print(doc)

次回は、集計した結果に対して検索を行います。

MongoDB(21) - 集計処理（aggregate）②合計($sum)

今回は、簡単な集計として従業員の課ごとの給料合計を集計してみます。

サンプルデータ

前回用意した会社の部、課、従業員データを使用します。

集計処理（aggregate）①データ準備 - https://ailog.site/2021/09/02/2021/0902/

課ごとの給料合計

指定したフィールドで集計を行うためにはaggregateの引数に$groupを指定し、集計条件を設定します。

合計を表示するためには$sumを集計条件に指定します。

従業員コレクション(employee)から、課ごとの給料合計を表示してみます。

[Mongoシェル]

1
2
3
4
5
6
7
> db.employee.aggregate([
    {$group:{_id:"$k_id", salary_total:{$sum:"$salary"}}}
  ])
{ "_id" : "ka1", "salary_total" : 400000 }
{ "_id" : "ka3", "salary_total" : 750000 }
{ "_id" : "ka4", "salary_total" : 220000 }
{ "_id" : "ka2", "salary_total" : 250000 }

集計条件の設定内容は以下の通りです。

  • _idに指定したフィールド($k_id)で集計を行います。
    フィールドは“$フィールド名”と先頭に$を追加して指定します。
    SQLだと[ group by k_id ]の意味です。
  • salary_totalは集計結果のフィールド名です。
    SQLだと[ select salary_total ]の意味です。
  • 集計関数として$sumを指定し、集計するフィールドは“$フィールド名”と先頭に$を追加して設定します。
    SQLだと[ sum(salary) ]の意味です。

SQLに慣れている人ですと、フィールド名の先頭に$をつけたり、記述がやや込み入って見えたりするかもしれませんが、１つ１つ対応関係を確認すれば読み解けるかと思います。

Pythonで操作

上記の集計処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# 課ごとの給料合計表示
docs = db1.employee.aggregate([{'$group':{'_id':'$k_id', 'salary_total':{'$sum':'$salary'}}}])
for doc in docs:
    print(doc)

次回は、検索条件に年齢を加えて集計を行います。

MongoDB(20) - 集計処理（aggregate）①データ準備

今回から、MongoDBでの集計処理(aggretate)を行っていきます。

今回は前準備として集計動作確認用のデータを作成します。

サンプルデータ

会社の部、課、従業員を想定したデータを用意します。

データのイメージは次の通りです。

  • 課は１つの部に所属します。
  • 従業員は１つの課に所属します。
  • 従業員は１つの役職を持ちます。

部のデータ作成

部のデータを作成します。コレクション名はdepartmentです。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
> db.department.insertMany([
     {b_id:"bu1", name:"総務部"},
     {b_id:"bu2", name:"企画部"},
     {b_id:"bu3", name:"開発部"}
 ])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("612f075468110fe533ed9d16"),
                ObjectId("612f075468110fe533ed9d17"),
                ObjectId("612f075468110fe533ed9d18")
        ]
}

> db.department.find({}, {_id:0})
{ "b_id" : "bu1", "name" : "総務部" }
{ "b_id" : "bu2", "name" : "企画部" }
{ "b_id" : "bu3", "name" : "開発部" }

課のデータ作成

課のデータを作成します。コレクション名はdivisionです。

b_idフィールドは所属する部署を表します。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> db.division.insertMany([
     {k_id:"ka1", b_id:"bu1", name:"総務課"},
     {k_id:"ka2", b_id:"bu2", name:"企画課"},
     {k_id:"ka3", b_id:"bu3", name:"開発1課"},
     {k_id:"ka4", b_id:"bu3", name:"開発2課"}
 ])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("612f07b568110fe533ed9d19"),
                ObjectId("612f07b568110fe533ed9d1a"),
                ObjectId("612f07b568110fe533ed9d1b"),
                ObjectId("612f07b568110fe533ed9d1c")
        ]
}

> db.division.find({}, {_id:0})
{ "k_id" : "ka1", "b_id" : "bu1", "name" : "総務課" }
{ "k_id" : "ka2", "b_id" : "bu2", "name" : "企画課" }
{ "k_id" : "ka3", "b_id" : "bu3", "name" : "開発1課" }
{ "k_id" : "ka4", "b_id" : "bu3", "name" : "開発2課" }

役職のデータ作成

役職のデータを作成します。コレクション名はpositionです。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> db.position.insertMany([
     {p_id:"po1", name:"社長"},
     {p_id:"po2", name:"部長"},
     {p_id:"po3", name:"課長"},
     {p_id:"po4", name:"一般社員"}
 ])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("612f07d768110fe533ed9d1d"),
                ObjectId("612f07d768110fe533ed9d1e"),
                ObjectId("612f07d768110fe533ed9d1f"),
                ObjectId("612f07d768110fe533ed9d20")
        ]
}

> db.position.find({}, {_id:0})
{ "p_id" : "po1", "name" : "社長" }
{ "p_id" : "po2", "name" : "部長" }
{ "p_id" : "po3", "name" : "課長" }
{ "p_id" : "po4", "name" : "一般社員" }

従業員のデータ作成

従業員のデータを作成します。コレクション名はemployeeです。

k_idフィールドは所属する課を表し、p_idは役職を表します。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
> db.employee.insertMany([
     {e_id:"emp001", k_id:"ka1", p_id:"po1", name:"高山", age:31, salary:400000},
     {e_id:"emp002", k_id:"ka2", p_id:"po2", name:"生駒", age:37, salary:250000},
     {e_id:"emp003", k_id:"ka3", p_id:"po3", name:"嘉喜", age:23, salary:200000},
     {e_id:"emp004", k_id:"ka4", p_id:"po4", name:"与田", age:33, salary:100000},
     {e_id:"emp005", k_id:"ka3", p_id:"po4", name:"松田", age:35, salary:550000},
     {e_id:"emp006", k_id:"ka4", p_id:"po4", name:"菅井", age:45, salary:120000}
 ])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("612f07f568110fe533ed9d21"),
                ObjectId("612f07f568110fe533ed9d22"),
                ObjectId("612f07f568110fe533ed9d23"),
                ObjectId("612f07f568110fe533ed9d24"),
                ObjectId("612f07f568110fe533ed9d25"),
                ObjectId("612f07f568110fe533ed9d26")
        ]
}

> db.employee.find({}, {_id:0})
{ "e_id" : "emp001", "k_id" : "ka1", "p_id" : "po1", "name" : "高山", "age" : 31, "salary" : 400000 }
{ "e_id" : "emp002", "k_id" : "ka2", "p_id" : "po2", "name" : "生駒", "age" : 37, "salary" : 250000 }
{ "e_id" : "emp003", "k_id" : "ka3", "p_id" : "po3", "name" : "嘉喜", "age" : 23, "salary" : 200000 }
{ "e_id" : "emp004", "k_id" : "ka4", "p_id" : "po4", "name" : "与田", "age" : 33, "salary" : 100000 }
{ "e_id" : "emp005", "k_id" : "ka3", "p_id" : "po4", "name" : "松田", "age" : 35, "salary" : 550000 }
{ "e_id" : "emp006", "k_id" : "ka4", "p_id" : "po4", "name" : "菅井", "age" : 45, "salary" : 120000 }

以上で、集計動作確認用のデータの準備ができました。


次回は、簡単な集計として従業員の課ごとの給料合計を集計してみます。

MongoDB(19) - ドキュメント削除編

今回は、ドキュメントの削除を行います。

サンプルデータ

次のようなデータをcol1コレクションに設定します。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> db.col1.insertMany([{name:"白石", age:29},
                      {name:"嘉喜", age:19},
                      {name:"西野", age:28},
                      {name:"武元", age:5}])
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("612d8ecb86b5a5660ce2fd20"),
                ObjectId("612d8ecb86b5a5660ce2fd21"),
                ObjectId("612d8ecb86b5a5660ce2fd22"),
                ObjectId("612d8ecb86b5a5660ce2fd23")
        ]
}

> db.col1.find()
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd20"), "name" : "白石", "age" : 29 }
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd21"), "name" : "嘉喜", "age" : 19 }
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd22"), "name" : "西野", "age" : 28 }
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd23"), "name" : "武元", "age" : 5 }

1件削除

ドキュメントを1件削除する場合は、deleteOneを使います。

第１引数に検索条件を指定します。

[Mongoシェル]

1
2
3
4
5
6
7
> db.col1.deleteOne({name:"西野"})
{ "acknowledged" : true, "deletedCount" : 1 }

> db.col1.find()
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd20"), "name" : "白石", "age" : 29 }
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd21"), "name" : "嘉喜", "age" : 19 }
{ "_id" : ObjectId("612d8ecb86b5a5660ce2fd23"), "name" : "武元", "age" : 5 }

nameが”西野”のドキュメントだけが削除されました。

もし検索条件に複数のドキュメントが一致しても、削除されるのは1件のみとなります。

複数削除

ドキュメントを複数削除する場合は、deleteManyを使います。

第１引数に検索条件を指定します。

今回は、検索条件を指定せずに全件削除してみます。

[Mongoシェル]

1
2
3
4
5
> db.col1.deleteMany({})
{ "acknowledged" : true, "deletedCount" : 3 }

> db.col1.find()

問題なく全件削除されました。

コレクション内のドキュメントを全件削除する場合は、deleteOneや一括高速処理のBulkで削除するよりもコレクション自体を削除したほうが速いとのことなので、コレクション名.drop()の方を使いましょう。

Pythonで操作

上記の更新処理をPythonで行うと、次のようになります。

[ソースコード]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import pymongo
from pymongo import MongoClient

# MongoDB操作用のインスタンスを作成
client = MongoClient()  # [IPとポートを指定する場合] MongoClient('10.200.243.203', 27017')

# データベースの取得
db1 = client.db1

# 1件削除
db1.col1.delete_one({'name':'西野'})

# 結果表示
for doc in db1.col1.find():
    print(doc)

# 複数削除
db1.col1.delete_many({})

# 結果表示
for doc in db1.col1.find():
    print(doc)

次回は、データの集計(aggregate)を行います。