MongoDB(40) - インデックスの削除

今回は、インデックスの削除を行います。

インデックスの削除

インデックスの削除にはdropIndexを使用します。

第１引数にはインデックス名を指名します。

（インデックス名はgetIndexesで取得できるnameフィールドの値です。）

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
> db.position.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_"
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1
                },
                "name" : "name_1"
        }
]

> db.position.dropIndexes("name_1")
{ "nIndexesWas" : 2, "ok" : 1 }

> db.position.getIndexes()
[ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_" } ]

positionコレクションのname_1インデックスを削除することができました。

次回は、インデックスの再構築を行います。

MongoDB(39) - インデックス作成のオプション

今回は、インデックス作成のオプションを確認します。

インデックス作成時のオプション

インデックスを作成する時には、オプション指定することができます。

オプションの一覧は下記の通りです。

項目名説明
backgroundバックグラウンドでインデックスを作成します。
デフォルトはfalseです。
nameインデックス名を指定します。
uniquetureを指定するとユニークインデックスを作成します。
ユニークインデックスにすると、nullは入れられません。
デフォルトはfalseです。
partialFilterExpressionフィルターを作成し、フィルターに一致したドキュメントの部分インデックスを作成します。
フィルターには以下の条件を設定できます。
・等式(key:valueまたは$eq)
・$exists (trueのみ)
・$gt, $gte, $lt, $lte
・$type
・$and

インデックスに名前を付けて、バックグラウンドで作成

memberコレクションに対して、インデックス名を”index_e_id”とし、バックグラウンドでインデックスを作成すると下記のようになります。

インデックスのオプションはcreateIndexの第２引数に指定します。

[Mongoシェル]

1
2
3
4
5
6
7
> db.member.createIndex({e_id:1}, {name:'index_e_id', background:true})
{
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "createdCollectionAutomatically" : true,
        "ok" : 1
}

部分インデックスの作成

memberコレクションに対して、所属(group)が”開発1部”のドキュメントだけに対してインデックスを作成すると下記のようになります。

[Mongoシェル]

1
2
3
4
5
6
7
> db.member.createIndex({e_id:1}, {partialFilterExpression:{group:"開発1部"}})
{
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "createdCollectionAutomatically" : false,
        "ok" : 1
}

次回は、インデックスの削除を行います。

MongoDB(38) - インデックスの確認・作成

インデックスの確認と作成を行います。

インデックスの確認

memberコレクションのインデックスを確認します。

インデックスの確認にはgetIndexes()を使用します。

[Mongoシェル]

1
2
> db.member.getIndexes()
[ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_" } ]

_idフィールドに昇順(=1)のインデックスが作成されていることが分かります。

インデックス名(name)は_id_です。

これは自動的に作成されるデフォルトインデックスです。

インデックスの作成

memberコレクションにインデックスを作成します。

インデックスの作成にはcreateIndex()を使います。

引数にはフィールド名と昇順(=1)か降順(=-1)を指定します。

フィールド名はカンマ区切りで複数指定可能です。

[Mongoシェル]

1
2
3
4
5
6
> db.member.createIndex({LastName:1})
{
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "createdCollectionAutomatically" : false,
        "ok" : 1

インデックスが1つから2つに増えたことが確認できます。

“ok”が1となっているのでインデックスが1つ作成されたということになります。


作成したインデックスを確認します。

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
> db.member.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_"
        },
        {
                "v" : 2,
                "key" : {
                        "LastName" : 1
                },
                "name" : "LastName_1"
        }
]

デフォルトインデックス(_id)のほかに、LastNameフィールドにもインデックスが作成されていることが確認できます。

インデックス作成時にインデックス名を指定していなかったので、自動的に”LastName_1”というインデックス名になっています。


次回は、インデックス作成のオプションを確認します。

MongoDB(37) - インデックスの種類

MongoDBでは大量のデータを処理することが多いため、インデックスの作成は必須の設定と言えます。

今回はインデックスの種類についてまとめます。

インデックスの種類

MongoDBでは、次のようなインデックスの種類があります。

  • デフォルトインデックス
    _idフィールドに自動的に作成されるユニークなインデックスのことです。
    このデフォルトインデックスは削除することができません。
  • テキストインデックス
    文字列コンテンツに対するテキスト検索クエリーをサポートするインデックスのことです。
  • TTLインデックス
    特定の時間または特定の時刻に、自動的にドキュメントを削除することができるインデックスです。
  • ハッシュインデックス
    フィールド値のハッシュ値をインデックスします。
  • 地理的インデックス
    プレーンジオメトリを使用する2Dインデックスと、球面ジオメトリを使用する2Dsphereインデックスのことです。

インデックスをつけるべきフィールド

性能面の観点からインデックスをつけるべきフィールドは次の２つです。

  • 検索条件でよく使用するフィールド
  • コレクション結合のキーとなるフィールド

インデックスのデメリット

インデックスを作成すると検索を速くすることができますが、無駄なインデックスがあると次のようなデメリットが発生するので注意が必要です。

  1. 登録、更新、削除の処理が遅くなる。
  2. ディスクの使用量が多くなる。

ただ、このデメリット以上に検索がとても速くなるため、ほとんどのコレクションでインデックスを使うことになります。


次回は、インデックスの確認と作成を行います。

MongoDB(36) - 一括処理（Bulk）⑤一括削除

今回は、一括削除を行います。

一括削除処理(remove)

順次処理で一括削除を行います。

（並列処理で実行したい場合は、initializeOrderedBulkOp()の代わりにinitializeUnorderedBulkOp()を使います。）

処理の詳細は以下の通りです。

  1. Bulk実行タイプを設定。（1行目）
  2. removeクエリーを設定。（3～5行目）
  3. 一括実行(Bulk実行)。（7行目）

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> var bulk = db.member.initializeOrderedBulkOp()

> bulk.find({LastName:'武元'}).removeOne()
> bulk.find({LastName:'松田'}).removeOne()
> bulk.find({LastName:'加藤'}).removeOne()

> bulk.execute()
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 0,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 3,
        "upserted" : [ ]
})

> db.member.find()
{ "_id" : ObjectId("613e8ff0d1340480894d324d"), "LastName" : "伊藤", "age" : 43 }

３件のドキュメントを一括で削除することができました。

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
from pymongo import DeleteOne
from pymongo.errors import BulkWriteError

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

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

# 一括入れ替え
requests = [
    DeleteOne({'LastName': '武元'}),
    DeleteOne({'LastName': '松田'}),
    DeleteOne({'LastName': '加藤'})
]

try:
    db1.member.bulk_write(requests)                   # 順次処理
    # db.member.bulk_write(requests, ordered=False)   # 並列処理
except BulkWriteError as bwe:
    pprint(bwe.details)

# 入れ替え内容の確認
docs = db1.member.find()
for doc in docs:
    print(doc)

次回からは、検索を高速化するためのインデックに関する操作を行います。

MongoDB(35) - 一括処理（Bulk）④一括登録／一括更新処理(upsert)

今回は、一括登録／一括更新処理(upsert)を行います。

一括登録／一括更新処理(upsert)

順次処理で一括登録／一括更新処理(upsert)を行います。

upsert処理では該当するデータが存在する場合は更新を行い、該当するデータがない場合は登録を行います。

（並列処理で実行したい場合は、initializeOrderedBulkOp()の代わりにinitializeUnorderedBulkOp()を使います。）

処理の詳細は以下の通りです。

  1. Bulk実行タイプを設定。（1行目）
  2. upsertクエリーを設定。（3～6行目）
    前半の3件が更新処理で、最後の1件が登録処理になります。
  3. 一括実行(Bulk実行)。（8行目）

[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
28
29
> var bulk = db.member.initializeOrderedBulkOp()

> bulk.find({LastName:'武元'}).upsert().updateOne({$set:{age:12}})  // 更新
> bulk.find({LastName:'松田'}).upsert().updateOne({$set:{age:23}})  // 更新
> bulk.find({LastName:'加藤'}).upsert().updateOne({$set:{age:33}})  // 更新
> bulk.find({LastName:'伊藤'}).upsert().updateOne({$set:{age:43}})  // 追加

> bulk.execute()
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 0,
        "nUpserted" : 1,
        "nMatched" : 3,
        "nModified" : 3,
        "nRemoved" : 0,
        "upserted" : [
                {
                        "index" : 3,
                        "_id" : ObjectId("613e8ff0d1340480894d324d")
                }
        ]
})

> db.member.find()
{ "_id" : ObjectId("613e8e9a0fb0f3e6cf9e2b87"), "LastName" : "武元", "FirstName" : "ゆい", "age" : 12 }
{ "_id" : ObjectId("613e8e9a0fb0f3e6cf9e2b88"), "LastName" : "松田", "FirstName" : "りな", "age" : 23 }
{ "_id" : ObjectId("613e8e9a0fb0f3e6cf9e2b89"), "LastName" : "加藤", "FirstName" : "しほ", "age" : 33 }
{ "_id" : ObjectId("613e8ff0d1340480894d324d"), "LastName" : "伊藤", "age" : 43 }

前半の3ドキュメントに関してはデータが存在していたので、既存データにageフィールドが追加されています。

最後の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
import pymongo
from pymongo import MongoClient
from pymongo import UpdateOne
from pymongo.errors import BulkWriteError

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

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

# 一括入れ替え
requests = [
    UpdateOne({'LastName': '武元'},{'$set':{'age':12}}, upsert=True),
    UpdateOne({'LastName': '松田'},{'$set':{'age':23}}, upsert=True),
    UpdateOne({'LastName': '加藤'},{'$set':{'age':33}}, upsert=True),
    UpdateOne({'LastName': '伊藤'},{'$set':{'age':43}}, upsert=True)
]

try:
    db1.member.bulk_write(requests)                   # 順次処理
    # db.member.bulk_write(requests, ordered=False)   # 並列処理
except BulkWriteError as bwe:
    pprint(bwe.details)

# 入れ替え内容の確認
docs = db1.member.find()
for doc in docs:
    print(doc)

Pythonでupsert処理を行う場合は、UpdateOneを使ってupsert=Trueオプションを追加します。


次回は、一括削除処理(remove)を行います。

MongoDB(34) - 一括処理（Bulk）③一括入れ替え

今回は、一括入れ替え処理を行います。

一括入れ替え

順次処理で一括入れ替えを行います。

（並列処理で実行したい場合は、initializeOrderedBulkOp()の代わりにinitializeUnorderedBulkOp()を使います。）

処理の詳細は以下の通りです。

  1. Bulk実行タイプを設定。（1行目）
  2. replaceクエリーを設定。（3～5行目）
  3. 一括実行(Bulk実行)。（7行目）

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> var bulk = db.member.initializeOrderedBulkOp()

> bulk.find({name:"武元"}).replaceOne({LastName:"武元", FirstName:"ゆい"})
> bulk.find({name:"松田"}).replaceOne({LastName:"松田", FirstName:"りな"})
> bulk.find({name:"加藤"}).replaceOne({LastName:"加藤", FirstName:"しほ"})

> bulk.execute()
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 0,
        "nUpserted" : 0,
        "nMatched" : 3,
        "nModified" : 3,
        "nRemoved" : 0,
        "upserted" : [ ]
})
> db.member.find()
{ "_id" : ObjectId("613e8e9a0fb0f3e6cf9e2b87"), "LastName" : "武元", "FirstName" : "ゆい" }
{ "_id" : ObjectId("613e8e9a0fb0f3e6cf9e2b88"), "LastName" : "松田", "FirstName" : "りな" }
{ "_id" : ObjectId("613e8e9a0fb0f3e6cf9e2b89"), "LastName" : "加藤", "FirstName" : "しほ" }

問題なく３つのドキュメントの入れ替えを行うことができました。

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
from pymongo import ReplaceOne
from pymongo.errors import BulkWriteError

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

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

# 一括入れ替え
requests = [
    ReplaceOne({'name': '武元'},{'LastName':'武元', 'FirstName':'ゆい'}),
    ReplaceOne({'name': '松田'},{'LastName':'松田', 'FirstName':'りな'}),
    ReplaceOne({'name': '加藤'},{'LastName':'加藤', 'FirstName':'しほ'})
]

try:
    db1.member.bulk_write(requests)                   # 順次処理
    # db.member.bulk_write(requests, ordered=False)   # 並列処理
except BulkWriteError as bwe:
    pprint(bwe.details)

# 入れ替え内容の確認
docs = db1.member.find()
for doc in docs:
    print(doc)

ReplaceOneの第１引数には検索条件を指定し、第２引数には入れ替えるドキュメントの内容を設定します。

次回は、一括登録／一括更新処理(upsert)を行います。

MongoDB(33) - 一括処理（Bulk）②一括更新

今回は、一括更新(Bulk)に関する操作を行います。

一括更新

順次処理で一括更新を行います。

（並列処理で実行したい場合は、initializeOrderedBulkOp()の代わりにinitializeUnorderedBulkOp()を使います。）

処理の詳細は以下の通りです。

  1. Bulk実行タイプを設定。（1行目）
  2. updateクエリーを設定。（3～5行目）
  3. 一括実行(Bulk実行)。（7行目）

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
> var bulk = db.member.initializeOrderedBulkOp()    //順次処理

> bulk.find({name:'武元'}).updateOne({$set:{age:11}})
> bulk.find({name:'松田'}).updateOne({$set:{age:21}})
> bulk.find({name:'加藤'}).updateOne({$set:{age:31}})

> bulk.execute()
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 0,
        "nUpserted" : 0,
        "nMatched" : 3,
        "nModified" : 3,
        "nRemoved" : 0,
        "upserted" : [ ]
})

> db.member.find()
{ "_id" : ObjectId("613e8c820fb0f3e6cf9e2b81"), "name" : "武元", "age" : 11 }
{ "_id" : ObjectId("613e8c820fb0f3e6cf9e2b82"), "name" : "松田", "age" : 21 }
{ "_id" : ObjectId("613e8c820fb0f3e6cf9e2b83"), "name" : "加藤", "age" : 31 }

問題なく３つのドキュメントの年齢(age)を更新することができました。

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
from pymongo import UpdateOne
from pymongo.errors import BulkWriteError

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

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

# 一括更新
requests = [
    UpdateOne({'name':'武元'}, {'$set':{'age':11}}),
    UpdateOne({'name':'松田'}, {'$set':{'age':21}}),
    UpdateOne({'name':'加藤'}, {'$set':{'age':31}})
]

try:
    db1.member.bulk_write(requests)                   # 順次処理
    # db.member.bulk_write(requests, ordered=False)   # 並列処理
except BulkWriteError as bwe:
    pprint(bwe.details)

# 更新内容の確認
docs = db1.member.find()
for doc in docs:
    print(doc)

次回は、一括入れ替え処理を行います。

MongoDB(32) - 一括処理（Bulk）①一括登録

今回から、一括処理(Bulk)に関する操作を行っていきます。

一括処理(Bulk)とは

大量にinsertやupdateを行う場合、一括処理(Bulk)を使うとまとめて処理を行うことができるため速く実行することができます

一括処理(Bulk)には、下記の２種類があります。

  1. 順次処理
    登録の順番に意味がある場合に使用します。
    前の処理が終わってから次の処理を行うため、2.並列処理よりも処理は遅くなります、
  2. 並列処理
    順番に関係なく処理を行います。
    そのため1.順次処理よりも速く処理が終了します。

一括登録

順次処理で一括登録を行います。

（並列処理で実行したい場合は、initializeOrderedBulkOp()ではなくinitializeUnorderedBulkOp()を使います。）

処理の詳細は以下の通りです。

  1. Bulk実行タイプを設定。（1行目）
  2. insertクエリーを設定。（3～5行目）
  3. 一括実行(Bulk実行)。（7行目）

[Mongoシェル]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
> var bulk = db.member.initializeOrderedBulkOp()  //順次処理

> bulk.insert({name:"武元", age:10})
> bulk.insert({name:"松田", age:20})
> bulk.insert({name:"加藤", age:30})

> bulk.execute()
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 3,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})

> db.member.find()
{ "_id" : ObjectId("613e728c0fb0f3e6cf9e2b7e"), "name" : "武元", "age" : 10 }
{ "_id" : ObjectId("613e728c0fb0f3e6cf9e2b7f"), "name" : "松田", "age" : 20 }
{ "_id" : ObjectId("613e728c0fb0f3e6cf9e2b80"), "name" : "加藤", "age" : 30 }

問題なく３つのドキュメントを追加することができました。

Pythonで操作

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

3～4行目に新たにimport文を追加していますのでご注意下さい。

[ソースコード]

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
from pymongo import InsertOne
from pymongo.errors import BulkWriteError

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

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

# 一括更新
requests = [
    InsertOne({'name':'武元', 'age':10}),
    InsertOne({'name':'松田', 'age':20}),
    InsertOne({'name':'加藤', 'age':30})
]

try:
    db1.member.bulk_write(requests)                    # 順次処理
    # db.member.bulk_write(requests, ordered=False)   # 並列処理
except BulkWriteError as bwe:
    pprint(bwe.details)

# 登録内容の確認
docs = db1.member.find()
for doc in docs:
    print(doc)

次回は、一括更新処理を行います。

MongoDB(31) - 集計処理（aggregate）⑫集計結果のソート／表示件数制限／取得開始位置の指定

今回は、集計結果のソート／表示件数制限／取得開始位置の指定を行います。

サンプルデータ

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

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

集計結果のソート

集計結果をソートしてみます。

集計結果のソートには$sortを使います。

[Mongoシェル]

1
2
3
4
5
6
7
8
> db.employee.aggregate([
     {$group:{_id:"$k_id", max_salary:{$max: "$salary"}}},
     {$sort:{max_salary:1}}  // 1:昇順  -1:降順
 ])
{ "_id" : "ka4", "max_salary" : 120000 }
{ "_id" : "ka2", "max_salary" : 250000 }
{ "_id" : "ka1", "max_salary" : 400000 }
{ "_id" : "ka3", "max_salary" : 550000 }

課ごとの最大給料に関して、昇順でソートすることができました。

集計結果の表示件数制限

集計結果の表示件数を制限します。

集計結果の表示件数制限には$limitを使います。

[Mongoシェル]

1
2
3
4
5
6
> db.employee.aggregate([
     {$group:{_id:"$k_id", max_salary:{$max: "$salary"}}},
     {$sort:{max_salary:1}},
     {$limit: 1}
 ])
{ "_id" : "ka4", "max_salary" : 120000 }

課ごとの最大給料に関して、表示件数を１件に制限することができました。

集計結果の取得開始位置の指定

集計結果の取得開始位置を指定します。

集計結果の表示開始位置を指定するためには$skipを使用します。

[Mongoシェル]

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

課ごとの最大給料に関して、表示開始位置を２つめからとすることができました。

$skipに指定するインデックスは0から始まりますので、1を指定した場合は２つめの集計結果から表示されることになります。


$sort、$limit、$skip は組み合わせて実行することが可能ですが、上から順番に実行されるので順番には気を付ける必要があります。

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
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', 'max_salary':{'$max': '$salary'}}},
             {'$sort':{'max_salary':1}}  # 1:昇順  -1:降順
            ])
for doc in docs:
    print(doc)

# 集計結果の表示件数制限
docs = db1.employee.aggregate([
             {'$group':{'_id':'$k_id', 'max_salary':{'$max': '$salary'}}},
             {'$sort':{'max_salary':1}},
             {'$limit': 1}
           ])
for doc in docs:
    print(doc)


# 集計結果の取得開始位置の指定
docs = db1.employee.aggregate([
              {'$group':{'_id':'$k_id', 'max_salary':{'$max': '$salary'}}},
              {'$sort':{'max_salary':1}},
              {'$skip': 1}
           ])
for doc in docs:
    print(doc)

次回からは、一括高速処理(Bulk)を行います。