C# & JavaScript

今回は「MongoDB の レプリケーション」についてその概要をまとめます。

タイトルには「レプリケーション」とありますがMongoDBでの実装にあたる「レプリカセット」の概要についてまとめています。

レプリケーション

「レプリケーション」はデータを複数のデータベースサーバーへコピーすることで冗長性と可用性を提供する仕組みです。 保存するデータセンターが異なれば災害対策にもなります。 また、同一データがコピーされているので読取が多いアプリケーションでは負荷分散も行えます。

MongoDBにおけるレプリケーション

MongoDB では同一データを保持するデータベースインスタンス群を「レプリカセット」と呼ばれるひとくくりのグループとして管理します。 MongoDB ではこのレプリカセットの仕組みで冗長性と可用性を提供します。

プライマリサーバーはすべての書き込み操作を受け取るサーバーで、データに対する変更を記録してログに残します。 セカンダリサーバーはプライマリサーバーの操作ログをコピーして適用することでプライマリサーバーと同じデータの状態を作ります。 もし、プライマリサーバーが不通となった場合は適切なセカンダリサーバーがプライマリサーバーに選任されてサービスを継続します。

レプリカセットメンバー

MongoDB の レプリカセット に含まれるメンバー（サーバー）の種類は以下にあげる3種類があります。

• プライマリ
• セカンダリ
• アービター

それぞれについて以下で詳しく紹介します。

プライマリ

レプリカセット中に1台だけ存在する書き込み可能なサーバーです。 プライマリサーバーに書き込んだ操作情報はログ oplog として残り、この操作ログがセカンダリサーバーへ伝達、コピーされます。

プライマリサーバーが何かしらの理由でお亡くなりになった場合、残ったセカンダリサーバーの中から次のプライマリサーバーが投票で選任されます。

セカンダリ

プライマリサーバーの操作ログをもとにデータ更新を行う読み取り専用のサーバーです。 セカンダリサーバーを複数台用意することで大量の読み取り操作に耐えられるようにします。

クライアントからのデータ読み取りは、基本的にセカンダリサーバー優先で読みに行くようにし、即時性が求められるデータのみプライマリサーバー優先で読みに行くようにします。

セカンダリサーバーの主な設定には「優先度（Priority）」「隠し（Hidden）」「遅延（Delayed）」の３つがあります。

• 優先度（Priority）

  Priority: 0 を指定するとプライマリサーバーに昇格しません。 優先度が0より大きな値が設定されているサーバーからプライマリサーバーが選任されます。 また、優先度に高い値が設定されているサーバーが優先的にプライマリサーバーとして選任されます。

• 隠し（Hidden）

  プライマリサーバーから操作ログをコピーしてデータ最新化は行いますが、クライアントアプリケーションからは見えない設定です。 クライアントアプリケーションから見えないので、他のサーバーに比べて負荷は低くなります。 隠し設定にしたメンバーはデータ分析やバックアップなど通常業務と異なる専用端末として利用します。

• 遅延（Delayed）

  プライマリサーバーから操作ログをコピーしてデータ反映は行いますが、プライマリサーバーよりも指定時間分だけ遅延させて反映します。 プライマリサーバーよりも遅延させて反映させることで、何かしら操作ミスを起こしてしまった時のリカバリに利用できるようにします。

アービター

レプリカセットで投票権のあるサーバーを奇数台にするために追加する調整用のサーバーです。 アービターサーバー自体はデータを持たず、プライマリサーバーが亡くなった場合に行われる新しいプライマリサーバーの選任で投票を行うことが主な役割です。 自身がプライマリサーバーになることはないので Priority: 0 を指定しておきます。

レプリカセットの構成

レプリカセットには最大50台までのメンバーを含めることができ、そのうち最大7台までが投票権を持ちます。 投票権を持つサーバー台数は奇数になるよう設計します。 足りない場合はアービターを追加して調整します。

最小のレプリカセットは3台構成で、以下のような構成が想定されます。

• プライマリとセカンダリ2台
• プライマリとセカンダリ、アービター

地理的に離れたデータセンターにメンバーを配置することでより高い可用性を実現することができます。

プライマリ と セカンダリ2台

このパターンの場合、セカンダリサーバー2台ともがプライマリサーバーになれるので、より可用性が高い構成となります。

通常時は2台のセカンダリサーバーに完全なコピーが作られます。 プライマリサーバーが不通となった場合、残っている2台のセカンダリサーバーが投票を行い、どちらかがプライマリサーバーに昇格します。

プライマリ と セカンダリ、アービター

いわゆるサーバー2台構成です。 実態として動いているのはプライマリサーバーとセカンダリサーバーの2台のみで、アービターサーバーはフェールオーバー時の投票に参加するくらいです（とはいえ、セカンダリにアービター相乗りさせるのは推奨されないので、管理用サーバーなど物理的に異なる低スペックサーバーにしておきます）。

このパターンの場合、アービターサーバーにデータコピーされないので、完全なコピーはセカンダリサーバーのみとなります。 プライマリサーバーが不通となった場合、プライマリサーバーの投票は行われますが必然的に残っているセカンダリサーバーがプライマリサーバーに昇格します。

自動フェールオーバー

レプリカセットは自動フェールオーバーによって高可用性を実現します。 具体的には、プライマリサーバーが応答しなくなった際、セカンダリサーバーから次のプライマリサーバーを選任し、選任されたセカンダリサーバーがプライマリサーバーに昇格することで実現します。

各メンバーは2秒間隔でハートビート（ping）を実行します。 10秒間応答が得られなかった場合、該当サーバーを不良サーバーとしてマークします。 プライマリサーバーが不良サーバーと設定されると残ったセカンダリサーバーから次のプライマリサーバーの選任始まります。

サーバーが投票を行う際、より高い優先度（Priority）が設定されたサーバーが優先的にプライマリサーバーに選任されます。 優先度（Priority）が低いサーバーが選任されている状態で、より高い優先度（Priority）のサーバーが有効になった場合、再び優先度（Priority）が高いサーバーがプライマリサーバーとなるよう投票が行われます。

投票を行わないメンバーは優先度（Priority）を0に設定しておきます。 1つのレプリカセットで投票権は7つまでなので、それ以上のセカンダリサーバーを用記す場合は優先度（Priority）を0として投票権（votes）も0で設定したサーバーにします。

データの読み書き

データの読み込みも書き込みも MongoClient の生成時にオプションで指定できます。 書き込みに関しては w, j, wtimeout の3種類、 読み込みに関しては readPreference, readConcern.level の2種類があります。

var {MongoClient, ReadPreference}= require("mongodb");

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, {
  // 書き込み設定
  w: "majority",
  j: true,
  wtimeout: 5000,
  // 読み込み設定
  readPreference: ReadPreference.SECONDARY_PREFERRED
  readConcern: {
    level: "local"
  }
}, (client) => {
  client.close();
});

データ書き込み

書き込みは Write Concern 設定でレプリカセットに含まれるサーバーの何台目まで書き込み処理を伝搬するか指定します。

w

j

wtimeout

データ読み込み

読み込みは Read Preference 設定でどのサーバーから優先的にデータ読み込みするかを設定することができます。

readPreference

readConcern.level

どのようなデータを取得してくるかを指定します。

今回は「MongoDB の レプリケーション」についてまとめました。 ポイントは以下の通りです。

• 書き込みできるのはプライマリサーバーのみ。
• プライマリサーバーが不通となった場合、残ったセカンダリサーバーがプライマリサーバーに昇格。

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

参考記事

• MongoDB - Replication
• MongoDB - Replica Set Members
• MongoDB - Replica Set Primary
• MongoDB - Priority 0 Replica Set Members
• MongoDB - Hidden Replica Set Members
• MongoDB - Delayed Replica Set Members
• MongoDB - Replica Set Arbiter
• gihyo.jp - 第4回　MongoDBのレプリケーションを構築してみよう
• Qiita - 俺でもわかるシリーズ: MongoDBのレプリケーション
• MongoDB - Write Concern
• MongoDB - Read Preference
• MongoDB - Read Concern

今回は「MongoDB で View を作成する 方法」についてまとめます。

概要

MongoDB における ビュー は Aggregation Pipeline のショートカットになります。 ビューは読み取り専用コレクションという扱いのため、書き込みを行おうとするとエラーになります。

構文

mongo コマンドで以下の構文を実行することで MongoDB の ビュー を作成することができます。

db.createView( <VIEW_NAME>, <SOURCE_COLLECION>, <PIPELINE>, [<OPTIONS>] )

サンプルコード

実際に上記構文を利用するサンプルコードを見ていきたいと思います。

今回は fruits コレクションから在庫情報だけ取り出して inventory ビューを作成してみます。 以下のコードはいずれも mongo コマンド上で実行しています。

前提データ

> db.fruits.insertMany([
  { code: "0101", name: "apple", price: 120, instock: 10 },
  { code: "0201", name: "banana", price: 180, instock: 8 },
  { code: "0301", name: "orange", price: 130, instock: 5 },
  { code: "0302", name: "grapefruit", price: 150, instock: 7 },
  { code: "0401", name: "persimmon", price: 100, instock: 6 },
  { code: "0102", name: "pear", price: 130, instock: 12 },
]);

実行コマンド

> db.createView(
  "inventory",
  "fruits",
  [ { $project: { _id: 0, name: 1, instock: 1 } } ]
);
{ "ok" : 1 }

結果確認

> db.inventory.find()
{ "name" : "apple", "instock" : 10 }
{ "name" : "banana", "instock" : 8 }
{ "name" : "orange", "instock" : 5 }
{ "name" : "grapefruit", "instock" : 7 }
{ "name" : "persimmon", "instock" : 6 }
{ "name" : "pear", "instock" : 12 }

ビューは一度作成してしまえば通常のコレクション同じように find() や aggregate() などの操作ができます。 また、不要になれば drop() で削除することもできます。

db.createView() を実行した後、show collections を行うとわかりますが、 ビューを作成すると自動的に system.views コレクションが作成され、 system.views コレクションに作成したビューの情報が格納されます。

今回は「MongoDB で View を作成する 方法」についてまとめました。 参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

参考記事

• MongoDB - db.createView()

今回は「MongoDB でドキュメント内の配列を展開する方法」についてまとめます。

MongoDBはドキュメントを保存するデータベースなので、そのドキュメントに配列が含まれることもあります。 今回はその配列を展開する方法についてまとめます。

サンプルデータ

以下のサンプルデータが入っている環境でのサンプルコードおよび実行結果を見ていきます。

> db.fruits.insertMany([
  { name: "shirt-A", size: ["S", "M", "L"] },
  { name: "shirt-B", size: ["Free"] },
  { name: "shirt-C", size: ["S"] }
]);

aggregate( $unwind )

ドキュメント内の配列を展開するには aggregate() の $unwind オペレーター を使うことで実現できます。 以下では上記サンプルデータの size フィールドを展開する方法を記載します。

コード

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("test");

  db.collection("fruits")
    .aggregate([
      { $unwind: "$size" },
      { $project: { _id: 0 } }
    ]).toArray()
    .then((docs) => {
      console.log(docs);
    }).catch((err) => {
      console.log(err);
    }).then(() => {
      client.close();
    });
});

実行 & 結果

[ { name: 'shirt-A', size: 'S' },
  { name: 'shirt-A', size: 'M' },
  { name: 'shirt-A', size: 'L' },
  { name: 'shirt-B', size: 'Free' },
  { name: 'shirt-C', size: 'S' } ]

$unwind 単体で使うことはあまりないような気がします。 集計を行う中でどうしても展開しないと集計できないようなケースのとき、$unwind で平面展開してその結果を $group で集計するような使い方になると思います。

今回は「MongoDB でドキュメント内の配列を展開する方法」についてまとめました。 参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で コレクションを結合する方法」についてまとめます。

MongoDB 3.2 以上 と 3.6 以上 で使える構文が違いますが、今回は両方共の構文を紹介します。 3.6以上であれば条件指定でコレクション結合できるのでよりRDBと似たような複雑なクエリが記載できるようになています。

前提データ

以下のデータを mongo コマンドで投入してある状態で name フィールド を displayName フィールドに変換して取得する方法を見ていきます。

> db.fruits.insertMany([
  { code: "0101", name: "apple", price: 120, instock: 10 },
  { code: "0201", name: "banana", price: 180, instock: 8 },
  { code: "0301", name: "orange", price: 130, instock: 5 },
  { code: "0302", name: "grapefruit", price: 150, instock: 7 },
  { code: "0401", name: "persimmon", price: 100, instock: 6 },
  { code: "0102", name: "pear", price: 130, instock: 12 },
]);

> db.orders.insertMany([
  { item: "apple", quantity: 2 },
  { item: "orange", quantity: 6 }
]);

結合フィールドを指定してコレクション結合

単一のフィールド同士を結合条件としてコレクション結合を行う方法です。 MongoDB 3.2 以上で利用可能な構文です。

構文

{
  $lookup: {
    from: <結合したいコレクション名>
    localField: <入力コレクションで結合条件にしたいフィールド名>
    foreignField: <結合したいコレクションで結合条件にしたいフィールド名>
    as: <結果配列の出力フィールド名>
  }
}

サンプルコード

この構文を利用したコレクション結合のサンプルとして、 orders コレクション に対して fruits コレクションを結合するサンプルコードを見ていきましょう。 SQLだと以下のようなイメージのコードをMongoDBで実装するサンプルになります。

SELECT * FROM orders LEFT JOIN fruits WHERE orders.item = fruits.name;

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("orders").aggregate([
    {
      $lookup: {
        from: "fruits",
        localField: "item",
        foreignField: "name",
        as: "inventory"
      }
    }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { _id: 5a63f919f43c88db76c72327,
    item: 'apple',
    quantity: 2,
    inventory: 
     [ { _id: 5a63f913f43c88db76c72321,
         code: '0101',
         name: 'apple',
         price: 120,
         instock: 10 } ] },
  { _id: 5a63f919f43c88db76c72328,
    item: 'orange',
    quantity: 6,
    inventory: 
     [ { _id: 5a63f913f43c88db76c72323,
         code: '0301',
         name: 'orange',
         price: 130,
         instock: 5 } ] } ]

inventory プロパティは配列で実際の実行結果は inventory[ [Object] ] で表示されます。 この状態では中身がわからないので理解しやすいよう上記の結果は中身を展開した形で記載しています。

配列フィールドを展開したい場合、$unwind ステージを利用すると展開することができます。

条件指定してコレクション結合

より複雑な条件を指定してコレクション結合を行う方法です。 こちらは MongoDb 3.6 以上で利用可能な構文になります。

構文

{
  $lookup: {
    from: <結合したいコレクション名>
    let: { <変数名1>: <値1> ... }
    pipeline: [ <Aggregateパイプライン> ]
    as: <結果配列の出力フィールド名>
  }
}

pipeline の中で入力コレクションのフィールドへ単純アクセスはできません。 あらかじめ let プロパティへ pipeline 中で利用したい入力コレクションのフィールドを指定しておき、pipeline中では $expr オペレーター を利用してアクセスします。

サンプルコード

orders コレクション に対して fruits コレクションを結合してみます。 今回は結合条件として fruits コレクションの instock が不足している orders ドキュメントのみを抽出できるようにします。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("orders").aggregate([
    {
      $lookup: {
        from: "fruits",
        let: { order_item: "$item", order_qty: "$quantity" },
        pipeline: [{
          $match: {
            $expr: {
              $and: [
                { $eq: ["$$order_item", "$name"] },
                { $gt: ["$$order_qty", "$instock"] }]
            }
          }
        }],
        as: "inventory"
      }
    }, {
      $match: { inventory: { $not: { $size: 0 } } }
    }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { _id: 5a63f919f43c88db76c72328,
    item: 'orange',
    quantity: 6,
    inventory:
     [ { _id: 5a63f913f43c88db76c72323,
         code: '0301',
         name: 'orange',
         price: 130,
         instock: 5 } ] } ]

inventory プロパティは配列で実際の実行結果は inventory[ [Object] ] で表示されます。 前述の「結合フィールドを指定してコレクション結合」の実行結果と同様に、この状態では中身がわからないので理解しやすいよう上記の結果は中身を展開した形で記載しています。

今回は「MongoDB で コレクションを結合する方法」についてまとめました。 ポイントは以下の通りです。

• 3.2以上なら単一フィールド結合
• 3.6以上ならより複雑な結合

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

参考記事

• MongoDB - $lookup (aggregation)

今回は「MongoDB で 検索結果から不要なフィールドを削除する方法」についてまとめます。 どちらかというと「_id が余計なのでこれだけ削除した結果を取得したい」ことが一番多いような気がしますが、 今回は一般化させてどんな加工（今回は削除にフォーカス）ができるのかをまとめます。

MongoDB で 検索結果を加工する場合 aggregate() の $project ステージ で行います。 基本的に削除したいフィールドは 0 指定、表示したいフィールドは 1 指定でできます。

以下で詳しく紹介します。

概要

検索結果のフィールド情報を操作したい場合、 aggregate() の $project ステージ で操作します。 表示したい場合 <フィールド名>: 1 を指定し、非表示にしたい場合は <フィールド名>: 0 を指定します。 ただし、 _id フィールド だけは特殊なフィールドで、明示的に非表示指定がない限りデフォルトで表示されるフィールドになります。

では、以下で具体的なサンプルコードを見ていきましょう。

• 前提データ
• 「削除したいフィールド」を指定する
• 「表示したいフィールド」を指定する
• 条件付きで「削除したいフィールド」を指定する(？)

前提データ

以下のデータを mongo コマンドで投入してある状態で各 fruits について結果取得をどう加工していくか見ていきます。

> db.fruits.insertMany([
  { code: "0101", name: "apple", price: 120 },
  { code: "0201", name: "banana", price: 180 },
  { code: "0301", name: "orange", price: 130 },
  { code: "0302", name: "grapefruit", price: 150 },
  { code: "0401", name: "persimmon", price: 100 },
  { code: "0102", name: "pear", price: 130 },
]);

「削除したいフィールド」を指定する

_id フィールド だけは明示的に削除することを指定しなければデフォルトで表示されるフィールドになります。 _id 以外のフィールドについては表示したくないフィールドに対して aggregate() の $project ステージで 0 を指定すると非表示にできます。

以下のサンプルコードでは _id と code フィールドを非表示にするよう指定しています。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("fruits").aggregate([
    { $project: { _id: 0, code: 0 } }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { name: 'apple', price: 120 },
  { name: 'banana', price: 180 },
  { name: 'orange', price: 130 },
  { name: 'grapefruit', price: 150 },
  { name: 'persimmon', price: 100 },
  { name: 'pear', price: 130 } ]

「表示したいフィールド」を指定する

前述の「削除したいフィールド」を指定とは逆で、「表示したいフィールド」を指定することで表示したいフィールドのみを指定することもできます。

以下のサンプルコードでは name のみを表示するよう指定しています。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("fruits").aggregate([
    { $project: { name: 1 } }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { _id: 5a5b09ccf43c88db76c7231b, name: 'apple' },
  { _id: 5a5b09ccf43c88db76c7231c, name: 'banana' },
  { _id: 5a5b09ccf43c88db76c7231d, name: 'orange' },
  { _id: 5a5b09ccf43c88db76c7231e, name: 'grapefruit' },
  { _id: 5a5b09ccf43c88db76c7231f, name: 'persimmon' },
  { _id: 5a5b09ccf43c88db76c72320, name: 'pear' } ]

実行結果を見ると分かりますが _id が表示されています。 「概要」でも触れた通り _id は明示的に指定しないとデフォルトで表示されます。 _id も表示せず name のみを返却するようにしたいのであれば $project ステージにおいて { _id: 0, name: 1 } を指定します。

条件付きで「削除したいフィールド」を指定する(？)

MongoDB では条件によってフィールドを削除するといったことができると記載があります（MongoDB - $project (aggregation) Conditionally Exclude Fields）。 これには $cond オペレーター と REMOVE グローバル変数 を利用して実現する…と。

…が、残念ながら実行すると以下のようなエラーが発生します。 mongo コマンドから実行しても MongoDB Node.js Drive から実行しても同じエラー（Use of undefined variable: REMOVE）が出ました。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("fruits").aggregate([
    {
      $project: {
        _id: 0,
        price: {
          $cond: {
            if: { $lt: ["$price", 130] },
            then: "$$REMOVE",
            else: "$price"
          }
        }
      }
    }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果（エラーメッセージ）

> node .\index.js
{ MongoError: Use of undefined variable: REMOVE
    at queryCallback (c:\work\sample\node_modules\mongodb-core\lib\cursor.js:223:25)
    at c:\work\sample\node_modules\mongodb-core\lib\connection\pool.js:541:18
    at _combinedTickCallback (internal/process/next_tick.js:73:7)
    at process._tickCallback (internal/process/next_tick.js:104:9)
  name: 'MongoError',
  message: 'Use of undefined variable: REMOVE',
  ok: 0,

「特定条件でフィールド削除する」方法はマニュアルの記載通りではうまくいかなそうなので、あきらめて「そのまま空欄出力して判定」したほうが現実的な実装になりそうです。

今回は「MongoDB で 検索結果から不要なフィールドを削除する方法」についてまとめました。 ポイントは以下の通りです。

• aggregate() の $project で表示フィールド制御
• 1で表示、0で非表示
• _id は明示的に非表示指定がなければ常に表示

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で 指定した範囲のドキュメントだけに件数を絞り込んで取得する 方法」についてまとめます。

ページング処理を実装しようとすると特定範囲のデータのみを取得したくなります。 特定範囲のデータのみを MongoDB で取得する場合、 skip と limit という関数ないしオプションを指定することで範囲指定したデータ取得ができます。 今回は「 find() を利用した方法」と「 aggregate() を利用した方法」の2種類

前提データ

以下のデータを mongo コマンドで投入してある状態で各 fruits について集計を行っていきます。

> db.fruits.insertMany([
  { code: "0101", name: "apple", price: 120 },
  { code: "0201", name: "banana", price: 180 },
  { code: "0301", name: "orange", price: 130 },
  { code: "0302", name: "grapefruit", price: 150 },
  { code: "0401", name: "persimmon", price: 100 },
  { code: "0102", name: "pear", price: 130 },
]);

find()

以下のコードは MongoDB Node.js Driver 3.0 でのサンプルコードになります。 3.0 の場合は find() のオプションでソート、スキップ、リミットを指定できます。 2.2 の場合は、 find() の後に sort() → skip() → limit() と呼び出せば同じ結果が得られます。

コードでは skip: 1 limit: 2 （1件飛ばして2件取得）となっています。 つまり、2件目と3件目を取得してくるような実装となっています。 ページング処理を実装するのであれば skip: <(ページ番号-1) × 1ページの表示件数> 、 limit: <1ページの表示件数> と指定することで実現できます。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("fruits")
    .find({}, { sort: { name: 1 }, skip: 1, limit: 2 })
    .toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { _id: 5a5b09ccf43c88db76c7231c,
    code: '0201',
    name: 'banana',
    price: 180 },
  { _id: 5a5b09ccf43c88db76c7231e,
    code: '0302',
    name: 'grapefruit',
    price: 150 } ]

aggregate([ $sort, $skip, $limit ])

得られる結果は同じですが… aggregate() を利用した場合のサンプルコードを記載します。

コード

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("fruits").aggregate([
    { $sort: { name: 1 } },
    { $skip: 1 },
    { $limit: 2 }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { _id: 5a5b09ccf43c88db76c7231c,
    code: '0201',
    name: 'banana',
    price: 180 },
  { _id: 5a5b09ccf43c88db76c7231e,
    code: '0302',
    name: 'grapefruit',
    price: 150 } ]

今回は「MongoDB で 指定した範囲のドキュメントだけに件数を絞り込んで取得する 方法」についてまとめました。 ポイントは以下の通りです。

• find() なら オプションで sort, skip, limit 指定
• aggregate() なら $sort, $skip, $limit ステージ指定

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で 検索結果 を ソートする 方法」についてまとめます。

思いつく方法としては db.collection.find() を利用するか db.collection.aggregate($sort) を利用するかどちらかかと思います。 今回はその両方をサンプルコードを準備しました。 ソート条件の指定自体はどちらの方法でも同じで、呼び出しまでの記述が少し違うだけです。

サンプルデータ

以下のサンプルデータが入っている環境でのサンプルコードおよび実行結果を見ていきます。

> db.fruits.insertMany([
  { code: "0101", name: "apple", price: 120 },
  { code: "0201", name: "banana", price: 180 },
  { code: "0301", name: "orange", price: 130 },
  { code: "0302", name: "grapefruit", price: 150 },
  { code: "0401", name: "persimmon", price: 100 },
  { code: "0102", name: "pear", price: 130 },
]);

find() + sort()

sort() はオブジェクトを引数に取り、ソートキーとソート方向（以下参照）を指定します。 キーの指定順はそのままソート優先順（第1ソートキー、第2ソートキー…）となります。 以下のサンプルコードの場合、第1ソートキー code 昇順、第2ソートキー price 昇順、第3ソートキー name 昇順となります。

ソート方向

1

昇順

-1

降順

コード

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");
  
  db.collection("orders")
    .find()
    .sort({ code: 1, price: 1, name: 1 })
    .toArray()
    .then((docs) => {
      console.log(docs);
    }).catch((err) => {
      console.log(err);
    }).then(() => {
      client.close();
    });
});

実行 & 結果

[ { _id: 5a521e9cff3735d50c439d79,
    code: '0101',
    name: 'apple',
    price: 120 },
  { _id: 5a521e9cff3735d50c439d7a,
    code: '0201',
    name: 'banana',
    price: 180 },
  { _id: 5a521e9cff3735d50c439d7b,
    code: '0301',
    name: 'orange',
    price: 130 },
  { _id: 5a521e9cff3735d50c439d7c,
    code: '0302',
    name: 'grapefruit',
    price: 150 },
  { _id: 5a521e9cff3735d50c439d7d,
    code: '0401',
    name: 'persimmon',
    price: 100 },
  { _id: 5a521e9cff3735d50c439d7e,
    code: '0102',
    name: 'pear',
    price: 130 } ]

aggregate( $sort )

基本的には find() + sort() と同じです。 ソート順やソート方向の指定方法も同じで呼び方が異なるだけです。

コード

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("fruits").aggregate([
    {
      $sort: { datetime: 1, amount: 1, item: 1 }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

[ { _id: 5a521e9cff3735d50c439d79,
    code: '0101',
    name: 'apple',
    price: 120 },
  { _id: 5a521e9cff3735d50c439d7a,
    code: '0201',
    name: 'banana',
    price: 180 },
  { _id: 5a521e9cff3735d50c439d7b,
    code: '0301',
    name: 'orange',
    price: 130 },
  { _id: 5a521e9cff3735d50c439d7c,
    code: '0302',
    name: 'grapefruit',
    price: 150 },
  { _id: 5a521e9cff3735d50c439d7d,
    code: '0401',
    name: 'persimmon',
    price: 100 },
  { _id: 5a521e9cff3735d50c439d7e,
    code: '0102',
    name: 'pear',
    price: 130 } ]

$sort ステージの性能

MongoDB のリファレンス を読んでいると、 aggregate() で利用する $sort ステージのメモリーおよびパフォーマンスについては注意点があるようなので、以下にまとめておきます。

メモリー

そもそも aggregate() を利用する時点で 100MB のメモリ制約があります。 回避するためには オプション で allowDiskUse を指定します。 また、 $sort の後に $limit が続く場合、自動的に最初の n 件 だけ処理するよう最適化されるようです。

パフォーマンス

$sort は インデックス が張られていればその恩恵にあずかることができます。 ただし、インデックスが効くのは $project 、 $unwind 、 $group などの前に $sort が実行された場合に限られます。

つまり、上記のメモリーの話とパフォーマンスの話をまとめると、 $sort → $limit → $project / $group と実行すると最適な実装となるようです。

今回は「MongoDB で 検索結果 を ソートする 方法」についてまとめました。 ポイントは以下の通りです。

• sort() も aggregate( $sort ) も同じ

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で グループごと に データの平均、標準偏差、分散 を 集計する 方法」についてまとめます。

MongoDB でグループ化に関する記事はほかにも以下のような記事がありますので参考にしていただければと思います。

• グループごとにデータ件数を集計する （ $group count ）
• グループごとにデータの合計値を集計する （ $group sum ）
• グループごとにデータの最小値/最大値を集計する （ $group min/max ）
• グループごとにデータの平均/標準偏差/分散を集計する （ $group avg/stddev/var ）　←　今回の記事

前提データ

以下のデータを mongo コマンドで投入してある状態で各 item について集計を行っていきます。

> db.orders.insertMany([
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "pen", amount: 70 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "note", amount: 40 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "eraser", amount: 100 },
  { datetime: ISODate("2017-12-12T12:00:00+09:00"), item: "note", amount: 80 },
  { datetime: ISODate("2017-12-08T12:00:00+09:00"), item: "eraser", amount: 50 },
  { datetime: ISODate("2017-11-21T12:00:00+09:00"), item: "eraser", amount: 70 },
  { datetime: ISODate("2017-11-13T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-11-02T12:00:00+09:00"), item: "pen", amount: 40 },
  { datetime: ISODate("2017-10-23T12:00:00+09:00"), item: "pen", amount: 30 },
  { datetime: ISODate("2017-10-18T12:00:00+09:00"), item: "pen", amount: 10 }
]);

グループごとに平均を集計（group avg）

平均の集計は $avg オペレーターを利用すると算出できます。 $avg オペレーターは引数を１つ（平均値を求めたいフィールド名）を指定するだけです。 単純なので早速コードを見てみましょう。

コード（index.js）

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $group: {
        _id: "$item",
        avg: { $avg: "$amount" }
      }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'note', avg: 60 },
  { _id: 'eraser', avg: 73.33333333333333 },
  { _id: 'pen', avg: 34 } ]

グループごとに標準偏差を集計（group stddev）

標準偏差には「母標準偏差」と「標本標準偏差」の2種類が存在します。 「母標準偏差」は「調査したデータと推定したいデータがすべて一致する場合（例えば、クラス全員の身長のばらつきを調べるような全量調査可能なケース）」で、 「標本標準偏差」は「調査対象データが推定対象データの一部である場合（例えば、日本中の身長のばらつきを調べるような部分的なデータしか集計できないケース」の値になります。

「母標準偏差」であれば $stdDevPop を使い、「標本標準偏差」であれば $stdDevSamp を使います。 どちらのオペレーターも集計対象としたいフィールド名を引数に１つとるものになります。

今回は「母標準偏差」をサンプルコードとして準備しました。 「標本標準偏差」で求めたい場合は $stdDevPop を $stdDevSamp へ置き換えてください。

コード（index.js）

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $group: {
        _id: "$item",
        stddev: { $stdDevPop: "$amount" }
      }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'note', stddev: 20 },
  { _id: 'eraser', stddev: 20.548046676563256 },
  { _id: 'pen', stddev: 20.591260281974 } ]

グループごとに分散を集計（group var）

標準偏差があればあまり分散を使うこともない…という前提なのか、直接分散を求めるオペレーターはないので標準偏差から元に戻すことになります。 いったん標準偏差を求めて2乗することで分散を求めます。

コード（index.js）

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $group: {
        _id: "$item",
        stddev: { $stdDevPop: "$amount" }
      }
    },
    {
      $project: {
        var: { $pow: ["$stddev", 2] }
      }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'note', var: 400 },
  { _id: 'eraser', var: 422.2222222222223 },
  { _id: 'pen', var: 424.00000000000006 } ]

今回は「MongoDB で グループごと に データの平均/標準偏差/分散 を 集計する 方法」についてまとめました。 ポイントは以下の通りです。

• 平均は { $avg: <key> }
• 標準偏差は { $stdDevPop: <key> } または { $stdDevSamp: <key> }
• 分散は標準偏差を求めて2乗

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で グループごと に データの最小値/最大値 を 集計する 方法」についてまとめます。

MongoDB でグループ化に関する記事はほかにも以下のような記事がありますので参考にしていただければと思います。

• グループごとにデータ件数を集計する （ $group count ）
• グループごとにデータの合計値を集計する （ $group sum ）
• グループごとにデータの最小値/最大値を集計する （ $group min/max ）　←　今回の記事
• グループごとにデータの平均/標準偏差/分散を集計する （ $group avg/stddev/var ）

前提データ

以下のデータを mongo コマンドで投入してある状態で各 item について集計を行っていきます。

> db.orders.insertMany([
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "pen", amount: 70 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "note", amount: 40 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "eraser", amount: 100 },
  { datetime: ISODate("2017-12-12T12:00:00+09:00"), item: "note", amount: 80 },
  { datetime: ISODate("2017-12-08T12:00:00+09:00"), item: "eraser", amount: 50 },
  { datetime: ISODate("2017-11-21T12:00:00+09:00"), item: "eraser", amount: 70 },
  { datetime: ISODate("2017-11-13T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-11-02T12:00:00+09:00"), item: "pen", amount: 40 },
  { datetime: ISODate("2017-10-23T12:00:00+09:00"), item: "pen", amount: 30 },
  { datetime: ISODate("2017-10-18T12:00:00+09:00"), item: "pen", amount: 10 }
]);

グループごとに最小値/最大値を集計（group min/max）

グループごとに集計するのでステージは $group を使います。 $group ステージで利用するオペレーターとしては最小値を求めるのが $min 、最大値を求めるのが $max を使います。 $group ステージで利用する $min や $max は引数を1つ（集計対象としたいフィールド名を指定する引数）しかとりません。 今回は単純なので早速コードを見てみましょう。

コード（index.js）

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $group: {
        _id: "$item",
        min: { $min: "$amount" },
        max: { $max: "$amount" }
      }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'note', min: 40, max: 80 },
  { _id: 'eraser', min: 50, max: 100 },
  { _id: 'pen', min: 10, max: 70 } ]

今回は「MongoDB で グループごと に データの最小値/最大値 を 集計する 方法」についてまとめました。 ポイントは以下の通りです。

• 最小値は { $min: <key> }
• 最大値は { $max: <key> }

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で グループごと に データの合計値 を 集計する 方法」についてまとめます。

MongoDB でグループ化に関する記事はほかにも以下のような記事がありますので参考にしていただければと思います。

• グループごとにデータ件数を集計する （ $group count ）
• グループごとにデータの合計値を集計する （ $group sum ）　←　今回の記事
• グループごとにデータの最小値/最大値を集計する （ $group min/max ）
• グループごとにデータの平均/標準偏差/分散を集計する （ $group avg/stddev/var ）

前提データ

以下のデータを mongo コマンドで投入してある状態で各 item について集計を行っていきます。

> db.orders.insertMany([
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "pen", amount: 70 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "note", amount: 40 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "eraser", amount: 100 },
  { datetime: ISODate("2017-12-12T12:00:00+09:00"), item: "note", amount: 80 },
  { datetime: ISODate("2017-12-08T12:00:00+09:00"), item: "eraser", amount: 50 },
  { datetime: ISODate("2017-11-21T12:00:00+09:00"), item: "eraser", amount: 70 },
  { datetime: ISODate("2017-11-13T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-11-02T12:00:00+09:00"), item: "pen", amount: 40 },
  { datetime: ISODate("2017-10-23T12:00:00+09:00"), item: "pen", amount: 30 },
  { datetime: ISODate("2017-10-18T12:00:00+09:00"), item: "pen", amount: 10 }
]);

グループごとに値を集計（group sum）

グループごとに件数をカウントするものと近いですが、こちらはグループごとに集計を行っています。 item ごとに amount の合計を算出するサンプルコードです。

件数カウントの場合は { $sum: 1 } と固定値を指定していましたが、特定のプロパティ値を合計する場合 { $sum: <key> } のように合計したいプロパティ名をキーに指定します。

コード（index.js）

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $group: {
        _id: "$item",
        total: { $sum: "$amount" }
      }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(()=>{
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'note', total: 120 },
  { _id: 'eraser', total: 220 },
  { _id: 'pen', total: 170 } ]

今回は「MongoDB で グループごと に 集計する 方法」についてまとめました。 ポイントは以下の通りです。

• 合計は { $sum: <key> }

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で グループごと に データ件数 を 集計する 方法」についてまとめます。 MongoDB でグループ化を行う基本と簡単な集計（件数取得）のサンプルコードを見ていきます。

MongoDB でグループ化に関する記事はほかにも以下のような記事がありますので参考にしていただければと思います。

• グループごとにデータ件数を集計する （ $group count ）　←　今回の記事
• グループごとにデータの合計値を集計する （ $group sum ）
• グループごとにデータの最小値/最大値を集計する （ $group min/max ）
• グループごとにデータの平均/標準偏差/分散を集計する （ $group avg/stddev/var ）

前提データ

以下のデータを mongo コマンドで投入してある状態で各 item について集計を行っていきます。

> db.orders.insertMany([
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "pen", amount: 70 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "note", amount: 40 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "eraser", amount: 100 },
  { datetime: ISODate("2017-12-12T12:00:00+09:00"), item: "note", amount: 80 },
  { datetime: ISODate("2017-12-08T12:00:00+09:00"), item: "eraser", amount: 50 },
  { datetime: ISODate("2017-11-21T12:00:00+09:00"), item: "eraser", amount: 70 },
  { datetime: ISODate("2017-11-13T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-11-02T12:00:00+09:00"), item: "pen", amount: 40 },
  { datetime: ISODate("2017-10-23T12:00:00+09:00"), item: "pen", amount: 30 },
  { datetime: ISODate("2017-10-18T12:00:00+09:00"), item: "pen", amount: 10 }
]);

グループ化キー

グループ化は aggregate() の $group を利用して実現します。 $group を使ってグループ化する際、グループ化キーは _id で指定します。

単純な文字列プロパティをキーとする場合は以下のようになります。

{
  $group: {
    _id: "$item"
  }
}

日付単位でグループ化したい場合は年月日などに分解したオブジェクトがキーとなるように指定します。

{
  $group: {
    _id: {
      yyyy: { $year: "$datetime" },
      mm: { $month: "$datetime" },
      dd: { $dayOfMonth: "$datetime" }
    }
  }
}

_id に null が指定された場合はグループ化せずすべてのドキュメントを対象に統計を取ることができます。

{
  $group: {
    _id: null
  }
}

グループごとに件数を集計（group count）

では、さっそく重複しているデータの件数をカウントするような集計を行うサンプルを見ていきます。 item でグループ化して item ごとに何件あるかカウントするサンプルです。

件数カウントしたい場合 { $sum: 1 } とすることでカウントできます。

コード（index.js）

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $group: {
        _id: "$item",
        count: { $sum: 1 }
      }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(()=>{
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'note', count: 2 },
  { _id: 'eraser', count: 3 },
  { _id: 'pen', count: 5 } ]

今回は「MongoDB で グループごと に 集計する 方法」についてまとめました。 ポイントは以下の通りです。

• グループ化は aggregate() の $group を使う
• グループ化キーは _id で指定
• 件数集計は { $sum: 1 }

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で 条件に合致する ドキュメント 件数 を取得する方法」についてまとめます。

集計方法は 「find() + count()」 で行う方法と「aggregate([ $match + $count ])」 で行う方法の2種類が考えられます。 単純に集計するだけであれば「find() + count()」で良いですが、グループ化や統計、コレクションの結合などを含めて実行する場合は「aggregate([ $match + $count ]) 」で行うことになります。

以下ではそれぞれについてサンプルコードを交えながら見ていきます。

前提データ

以下のデータを mongo コマンドで投入してある状態で 2017/12/15 の オーダー総件数 を集計するサンプルコードを見ていきます。

> db.orders.insertMany([
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "pen", amount: 70 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "note", amount: 80 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "eraser", amount: 100 },
  { datetime: ISODate("2017-11-13T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-11-02T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-10-23T12:00:00+09:00"), item: "pen", amount: 30 },
  { datetime: ISODate("2017-10-18T12:00:00+09:00"), item: "pen", amount: 10 }
]);

find() + count() で集計する方法

単独コレクションに対する単純な集計であればこの方法で間に合うと思います。 find() でフィルターされた結果に対して count() で件数取得します。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").find({
    datetime: {
      $gte: new Date("2017-12-15T00:00:00+09:00"),
      $lt: new Date("2017-12-16T00:00:00+09:00")
    }
  }).count().then((result) => {
    console.log(result);
    client.close();
  }).catch((err) => {
    console.log(err);
    client.close();
  });
});

実行 & 結果

> node .\index.js
3

aggregate([ $match + $count ]) で集計する方法

以下のサンプルコードでは複雑な集計を行っていませんが、グループ化や特定条件に合致するドキュメントのみ集計するなのなど複雑な集計処理を行う場合は aggregate() を利用します。

$match に指定する条件式は find() + count() で行ったものと同じになります。 得られる結果形式が find() + count() の形とは異なるので注意です。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    client.close();
    return;
  }

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $match: {
        datetime: {
          $gte: new Date("2017-12-15T00:00:00+09:00"),
          $lt: new Date("2017-12-16T00:00:00+09:00")
        }
      }
    },
    { $count: "total" }
  ]).toArray().then((result) => {
    console.log(result);
    client.close();
  }).catch((err) => {
    console.log(err);
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { total: 3 } ]

今回は「MongoDB で 条件に合致する ドキュメント 件数 を取得する方法」についてまとめました。 ポイントは以下の通りです。

• 単純な集計なら find() + count()
• 複雑な集計になりそうなら aggregate()

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB における 集計 (Aggregation) の基本」についてまとめます。 あまり細かいところは触れませんが、大まかな概略はつかめるようにまとめました。

集計手続き（Aggregation Pipeline）

一般に「集計を行う」となると「さまざまな処理を経て目的とする値を取得する」ようになっていると思います。

例えば、「今月売れた商品を売れた数順に取得する」のであれば「売上データを対象に今月の売り上げで絞り込み→商品ごとに売り上げ個数を集計→数が多い順にソート」といった流れで処理します。

これはRDBだと複数のサブクエリを作成して実現しているかと思いますが、 MongoDB だと aggregate([<stages>]) のように個別処理（ステージ）を配列にして aggregate() へ渡すことで実現します。

前述のサンプル（「今月売れた商品を売れた数順に取得する」）を実際に実行するコードと動作イメージは以下のようになります。

db.orderes.aggregate([
  { $match: { datetime: /2017-12/g } },
  { $group: { _id: "$item", total: { $sum: "$amount" } } }
  { $sort: { total: -1 } }
]);

MongoDB における統計処理は上記の通り「ステージ」を連結して必要な情報を集めることで実現します（上記の例だと「ステージ」は $match, $group, $sort）。 また、集計する際の各「ステージ」ではより複雑な処理を行うため、子要素に「オペレーター」と呼ばれる補助関数を使用することができます（上記の例だと「オペレーター」は $sum）。

以下では、よく使いそうな「ステージ」と「オペレーター」をピックアップして詳しく見ていきます。

ステージ

さて、上記の通り MongoDB における集計処理の要は「ステージ」にあります。 どのような「ステージ」があるかを知っておくことで様々な集計ができるようになります。

ここでは MongoDB で利用可能な ステージ のうち利用頻度が高そうなものをピックアップして紹介します。

ステージの記述方法は基本的に { <stage> : { <expression> } } というようにオブジェクトを引数に取るような形で記述します。

{ $count: "total" }

{
  $group: {
    _id: "$item",
    total: { $sum: "$amount" }
  }
}

{ $limit: 15 }

{ $skip: 5 }

{ $sort: { total: -1 } }

{ $match: { datetime: /2017-12/g } }

{
  $project: {
    _id: 0, item: 1, amount: 1
  }
}

オペレーター

その名の通り各種演算です。 各ステージで行う集計処理でより複雑な処理を行いたいときに利用します。 SQL と同じく1つの言語 (MongoDB 処理用の言語) と思ってみたほうが良い気がします。

オペレーターの記述方法は基本的に { <operator> : [ <arguments> ] } というように配列で引数を取るような形で記述します。 ステージを含めた記述だと { <stage> : { <operator> : [ <arguments> ] } } という形になります。 オペレーターの引数として渡すドキュメントのプロパティはプロパティ名の接頭辞に $ つけて指定します。

• 関係演算子
• 論理演算子
• 算術演算子
• 統計関数
• 日付
• 文字列
• 文

関係演算子

{ $eq: [ "$amount", 250 ] }

{ $ne: [ "$amount", 250 ] }

{ $gt: [ "$amount", 250 ] }

{ $gte: [ "$amount", 250 ] }

{ $lt: [ "$amount", 250 ] }

{ $lte: [ "$amount", 250 ] }

論理演算子

{ $and: [ { $gte: [ "$amount", 5 ] }, { $lt: [ "$amount", 10 ] } ] }

{ $or: [ { $lt: [ "$amount", 5 ] }, { $gte: [ "$amount", 10 ] } ] }

{ $not: [ { $gt: [ "$qty", 250 ] } ] }

算術演算子

{ $add: [ "$price", "$fee" ] }

{ $subtract: [ "$price", "$discount" ] }

{ $multiply: [ "$price", "$quantity" ] }

{ $divide: [ "$hours", 8 ] }

{ $mod: [ "$hours", "$tasks" ] }

{ $ceil: "$value" }

{ $floor: "$value" }

{ $pow: [ { $stdDevPop: "$scores.score" }, 2 ] } }

{
  $sqrt: {
    $add: [
      { $pow: [ { $subtract: [ "$p2.y", "$p1.y" ] }, 2 ] },
      { $pow: [ { $subtract: [ "$p2.x", "$p1.x" ] }, 2 ] }
    ]
  }
}

{ $abs: { $subtract: [ "$start", "$end" ] } }

統計関数

{ $min: "$amount" }

{ $max: "$amount" }

{ $avg: "$amount" }

{ $sum: "$amount" }

{ $stdDevPop: "$score" }

日付

{ $year: "$date" }

{ $month: "$date" }

{ $dayOfMonth: "$date" }

{ $dayOfWeek: "$date" }

{ $hour: "$date" }

{ $minute: "$date" }

{ $second: "$date" }

文字列

{ $strLenBytes: "description" }

{ $indexOfBytes: [ "$item", "e" ] }

{ $concat: [ "$item", " - ", "$description" ] }

{ $substrBytes: [ "$description", 0, 2 ] }

{ $split: ["$city", ","] }

{ $toLower: "$description" }

{ $toUpper: "$description" }

文

{ $cond: { if: { $gte: [ "$amount", 10 ] }, then: 1, else: 0 } }

{ $cond: [ { $gte: [ "$amount", 10 ] }, 1, 0 ] }

{
  $switch: {
    branches: [
      { case: { $gt: [ "$amount", 0 ] }, then: "> 0" },
      { case: { $gt: [ "$amount", 5 ] }, then: "> 5" }
    ],
    default: "Did not match"
  }
}

今回は「MongoDB における 集計 (Aggregation) の基本」についてまとめました。 ポイントは「ステージ」と「オペレーター」にあります。 これらをどれだけ知っているかが MongoDB を使いこなせるかどうかにつながります。 独特な書き方ですが本記事を足掛かりに知識を深められればと思います。

本記事がお役に立っていると嬉しいです！！

参考記事

• MongoDB - Aggregation
• MongoDB - Aggregation Pipeline Quick Reference
• MongoDB - Aggregation Pipeline Stages
• MongoDB - Aggregation Pipeline Operators

今回は「MongoDB で 検索結果のフィールド名 を 変更する 方法」についてまとめます。 SQL で言うところの AS のような実装を MongoDB で実現する方法です。

前提データ

以下のデータを mongo コマンドで投入してある状態で name フィールド を displayName フィールドに変換して取得する方法を見ていきます。

> db.fruits.insertMany([
  { code: "0101", name: "apple", price: 120 },
  { code: "0201", name: "banana", price: 180 },
  { code: "0301", name: "orange", price: 130 },
  { code: "0302", name: "grapefruit", price: 150 },
  { code: "0401", name: "persimmon", price: 100 },
  { code: "0102", name: "pear", price: 130 },
]);

フィールド名を変更する方法

基本的に aggregate() の $project ステージ で書き換えることになります。

以下のサンプルコードでは name を displayName に書き換えて取得しています。 単純に displayName を出力指定して、値を name からとってくるように指定することで書き換えと同じことを実現しています。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;

var URL = "mongodb://localhost:27017/test";

MongoClient.connect(URL, (err, client) => {
  var db = client.db("test");
  db.collection("fruits").aggregate([
    { $project: { _id: 0, displayName: "$name", price: 1 } }
  ]).toArray()
    .then((docs) => {
      console.log(docs);
    })
    .catch((err) => {
      console.log(err);
    })
    .then(() => {
      client.close();
    });
});

実行 & 結果

> node .\index.js
[ { price: 120, displayName: 'apple' },
  { price: 180, displayName: 'banana' },
  { price: 130, displayName: 'orange' },
  { price: 150, displayName: 'grapefruit' },
  { price: 100, displayName: 'persimmon' },
  { price: 130, displayName: 'pear' } ]

今回は「MongoDB で 検索結果のフィールド名 を 変更する 方法」についてまとめました。 ポイントは以下の通りです。

• aggregate() の $project ステージで書き換え

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は「MongoDB で 自動インクリメント シーケンス を 作成する 方法」についてまとめます。

MongoDB は デフォルト で シーケンス が存在しないので、今回のサンプルのように自作することになります。 今回は簡単なサンプルとして2通りの方法を紹介します。

概要

基本的に MongoDB では多数のドキュメントを扱うため任意のフィールドにインクリメントを行うようなことは行いません。 デフォルトで _id に ObjectId のユニークキーが生成されるのでこちらを使います。

とはいえ、システム上ユニークな連番が必要なこともあるかと思います。 今回はユニークな番号を発番する方法を2通り紹介します。

いずれの方法においても以下のようなドキュメントで userid にシーケンスを発番する方法をサンプルコードとして載せます。

カウンターコレクションを利用する方法

{key: string, seq: number} のフォーマットとなる counters コレクションを作っておき、 シーケンスが必要なドキュメントを挿入する際にこの counters ドキュメントから最大値を取得したうえで更新することで自動インクリメントを実現する方法です。

前提

counters コレクションを作成します。 以下のサンプルは mongo コマンドから実行しています。

> db.counters.createIndex({ key: 1 }, { unique: true })
> db.counters.insertOne({ key: "userid", seq: 0 })

作成結果は以下のようになります。

> db.counters.find({}, { _id: 0 })
{ "key" : "userid", "seq" : 0 }

ソース (index.js)

var MongoClient = require("mongodb").MongoClient;

const CONNECTION_STRING = "mongodb://localhost:27017/test";

// シーケンス用コレクションを利用したシーケンス発番
var insertUser = function (userinfo, callback) {
  MongoClient.connect(CONNECTION_STRING).then((db) => {
    // カウンターコレクションからシーケンスを取得
    db.collection("counters").findOneAndUpdate(
      { key: "userid" },
      { $inc: { seq: 1 } },
      { upsert: true, returnOriginal: true },
      (err, doc) => {
        // シーケンス番号を設定
        userinfo.userid = doc.value.seq;

        // ドキュメントの挿入
        db.collection("users").insertOne(userinfo, (err, res) => {
          callback && callback(err, res);
        });
      });
  }).catch((err) => {
    console.log(err.message);
  });
};

// 実際に挿入を行う
insertUser({
  name: "Tsuyoshi Tanaka"
});

insertUser({
  name: "Subaru Osawa"
});

実行

> node ./index.js

結果

> db.users.find({},{_id:0})
{ "name" : "Subaru Natsuki", "userid" : 0 }
{ "name" : "Tsuyoshi Tanaka", "userid" : 1 }

ループ処理を利用する方法

シーケンス用のコレクションを準備しない代わりに現在挿入されているデータから最大値を取得して次の番号を取得するようにします。

ソース (index.js)

var MongoClient = require("mongodb").MongoClient;

const CONNECTION_STRING = "mongodb://localhost:27017/test";

// 繰り返し処理を利用したシーケンス発番
var insertUser = function (userinfo, callback) {
  MongoClient.connect(CONNECTION_STRING).then((db) => {

    // 繰り返し処理
    var loop = function () {
      db.collection("users")
        .find({}, { _id: 0, userid: 1 })
        .sort({ userid: -1 })
        .limit(1)
        .toArray((err, docs) => {
          if (err) {
            callback && callback(err, null);
            return;
          }

          // シーケンスの生成
          var seq = docs.length > 0 ? docs[0].userid + 1 : 0;

          // シーケンスの設定
          userinfo.userid = seq;

          // ドキュメントの挿入
          db.collection("users").insertOne(userinfo, (err, res) => {
            // シーケンス番号が被った場合は再帰実行
            if (err && err.code === 11000) {
              loop();

              return;
            }
            callback && callback(err, res);
          });
        });
    };

    // 繰り返し処理の初回実行
    loop();
  });
};

// 実際に挿入を行う
insertUser({
  name: "Tsuyoshi Tanaka"
});

insertUser({
  name: "Subaru Natsuki"
});

利用

> node ./index.js

結果

> db.users.find({}, { _id: 0 })
{ "name" : "Subaru Natsuki", "userid" : 0 }
{ "name" : "Tsuyoshi Tanaka", "userid" : 1 }

今回は「MongoDB で 自動インクリメント シーケンス を 作成する 方法」についてまとめました。 参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

参考記事

• MongoDB - Create an Auto-Incrementing Sequence Field

今回は「MongoDB で 重複データを抽出 / 削除する方法」についてまとめます。

createIndex() で 一意制約（ユニークキー制約） をかけようとしたとき、重複データがあるとかけられません。 今回はそんなときに必要となる「重複データを抽出して削除する具体的な方法」についてまとめました。

前提データ

以下のデータを mongo コマンドで投入してある状態で重複しているデータ（ { item: "pen" } ）の削除を見ていきます。

> db.orders.insertMany([
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "pen", amount: 70 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "note", amount: 80 },
  { datetime: ISODate("2017-12-15T12:00:00+09:00"), item: "eraser", amount: 100 },
  { datetime: ISODate("2017-11-13T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-11-02T12:00:00+09:00"), item: "pen", amount: 20 },
  { datetime: ISODate("2017-10-23T12:00:00+09:00"), item: "pen", amount: 30 },
  { datetime: ISODate("2017-10-18T12:00:00+09:00"), item: "pen", amount: 10 }
]);

重複データを抽出する

重複データの抽出だけであれば aggregate() の $group を用いて抽出できます。 抽出する際、 $$ROOT を利用することで元データをそのまま items 配列へ push することができます。

なお、aggregate() の制約でオンメモリ操作は 100MB までとなっているので、これを超えるデータを一度に扱う場合はオプション allowDiskUse を指定します。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    console.log(err);
    return;
  };

  var db = client.db("sample");

  db.collection("orders").aggregate([
    // 重複データの抽出
    {
      $group: {
        _id: "$item",
        items: { $push: "$$ROOT" },
        count: { $sum: 1 }
      }
    },
    {
      $match: { count: { $gt: 1 } }
    }
  ]).toArray().then((docs) => {
    console.log(docs);
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
[ { _id: 'pen',
    items: [ [Object], [Object], [Object], [Object], [Object] ],
    count: 5 } ]

実行結果は [Object] と表示されていますが、デバッグで止めて確認するか JSON.stringify() を利用すると中身を確認できます。

重複データを削除する

重複データを削除…とは言ったものの1件データは残すので、どういったデータを残してそれ以外を削除できるようにするのかについて、 ここでは2通りの方法を紹介します。

• 先頭データを決め打ちで残す
• ObjectId指定で残す

先頭データを決め打ちで残す

最初にソートしておくことで「ある値がもっとも大きな（or もっとも小さな）データを残す」ようにする方法です。

サンプルコードの L.14 でソートを行い、L.30 で最初の1件を取り除いてから削除しています。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    console.log(err);
    return;
  };

  var db = client.db("sample");

  db.collection("orders").aggregate([
    {
      $sort: { amount: -1 }
    },
    {
      $group: {
        _id: "$item",
        targets: { $push: "$_id" },
        count: { $sum: 1 }
      }
    },
    {
      $match: { count: { $gt: 1 } }
    },
  ]).toArray().then((docs) => {
    console.log(JSON.stringify(docs));
    var procs = [];
    for (var doc of docs) {
      doc.targets.shift();
      procs[procs.length] = db.collection("orders").deleteMany({
        _id: { $in: doc.targets }
      });
    }
    return Promise.all(procs);
  }).then((results) => {
    console.log("Remove dupulicate data.");
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
Remove dupulicate data.

ObjectId指定で残す

どちらかというとデータ確認したうえで残したいデータを指定してそれ以外を削除や退避といった作業が通常な気がします。 こちらの方法では、残したいデータの ObjectId を指定してそれ以外を削除するようにする方法になっています。 除外データの指定は以下のサンプルコード L.32 にある配列へカンマ区切りで追加することで指定できます。

コード (index.js)

var MongoClient = require("mongodb").MongoClient;
var ObjectId = require("mongodb").ObjectId;
var URL = "mongodb://localhost:27017";

MongoClient.connect(URL, (err, client) => {
  if (err) {
    console.log(err);
    return;
  };

  var db = client.db("sample");

  db.collection("orders").aggregate([
    // 重複データの抽出
    {
      $group: {
        _id: "$item",
        items: { $push: "$$ROOT" },
        count: { $sum: 1 }
      }
    },
    {
      $match: { count: { $gt: 1 } }
    },
    // 重複データのみを展開
    {
      $unwind: "$items"
    },
    // 残したいデータを削除対象から除去
    {
      $match: {
        "items._id": { $nin: [new ObjectId("5a5091c4ff3735d50c439d41")] }
      }
    },
    // 削除対象のObjectIdをまとめる
    {
      $group: {
        _id: null,
        targets: { $push: "$items._id" }
      }
    }
  ]).toArray().then((docs) => {
    console.log(JSON.stringify(docs));
    var procs = [];
    for (var doc of docs) {
      procs[procs.length] = db.collection("orders").deleteMany({
        _id: { $in: doc.targets }
      });
    }
    return Promise.all(procs);
  }).then((results) => {
    console.log("Remove dupulicate data.");
  }).catch((err) => {
    console.log(err);
  }).then(() => {
    client.close();
  });
});

実行 & 結果

> node .\index.js
Remove dupulicate data.

今回は「MongoDB で 重複データを抽出 / 削除する方法」についてまとめました。 ポイントは以下の通りです。

• 抽出は aggregate() の $group
• 削除は aggregate() した後 deleteMany()

参考になったでしょうか？ 本記事がお役に立っていると嬉しいです！！

今回は 「MongoDB において 一意制約 (ユニーク制約) をかける方法」 についてまとめます。

一意制約 (ユニーク制約) の 適用

MongoDB で 一意制約 をかけるには インデックス作成時 createIndex() のオプション unique に true を指定することで実現できます。

以下では「単一キーインデックス」の場合と「複合キーインデックス」の場合についてサンプルコードを見ていきます。

単一キーインデックス

単一キーインデックスであれば単純に以下のようなコードを mongo シェル上で実行すれば作成できます。

> db.members.createIndex({ userId: 1 }, { unique: true })

複合キーインデックス

複合キーインデックスの場合であっても単一キーインデックスとコードは変わりません。

> db.members.createIndex({ firstname: 1, lastname: 1 }, { unique: true })

複合キーインデックスの場合、複合キーの組み合わせで一意になればよいので、以下のいずれでも問題なく挿入できます。

> db.members.insert({ firstname: "Tsuyoshi", lastname: "Tanaka" })
> db.members.insert({ firstname: "Satoshi", lastname: "Tanaka" })
> db.members.insert({ firstname: "Tsuyoshi" })

一意制約 (ユニーク制約) の 動作制限

RDB の場合とも似ていますが、すでに重複データが入ってしまったコレクションに対して一意制約をかけることはできません。 まぁ、すでに重複してしまっている状態では当然といえば当然かと思いますが…

また、ハッシュインデックスに対して一意制約を行うことは推奨されないようです。 （Hashed Indexes の Considerations ）

一意制約 キー に 値 が 設定されない場合 の 挙動

上記「複合キーインデックス」で一意制約を行うパターンのデータ挿入例にもありましたが、値がないフィールドが存在する場合、内部的には null が指定されたものとして処理されます。

例えば、以下のようにフィールド x に対する一意制約があるコレクションがある場合において、

> db.collection.createIndex({ x: 1 }, { unique: true })

フィールド x を指定しないデータを挿入したとします。

> db.collection.insert({ y: 1 })
WriteResult({ "nInserted" : 1 })

初回は x: null として入るので正常に挿入できます。 続けて再度 フィールド x が存在しない別のデータを挿入するとどうでしょうか。

> db.collection.insert({ z: 1 })
WriteResult({
    "nInserted" : 0,
    "writeError" : {
        "code" : 11000,
        "errmsg" : "E11000 duplicate key error collection: test.collection index: x_1 dup key: { : null }"
    }
})

エラーが発生して挿入できないことがわかります。 また、エラーメッセージからも指定がなければ null が挿入されていたことがわかります。

今回は 「MongoDB において 一意制約 (ユニーク制約) をかける方法」 についてまとめました。 ポイントは以下の通りです。 参考になったでしょうか？

• createIndex() で { unique: true } オプションを指定すると一意制約が作成できる

本記事がお役に立っていると嬉しいです！！

参考記事

• MongoDB - Unique Indexes