今回は「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

今回はMongoDBの特徴についてまとめます。

ドキュメントデータベース

JSONドのようにキーバリューの組み合わせをそのまま保存できるドキュメント形式のデータベースです。 バリューにはさまざまな型が指定でき、例えば数値、文字列はもちろん、配列やオブジェクトが保存できるのも特徴です。 また、このバリューの型は動的に変更することができますし、同一のフィールド名に複数の型を入れることもできます。 言い換えればスキーマレスのドキュメントデータベースです。

性能

性能を出すため、以下のような機能を実装しています。

• 組み込みデータモデルを利用したI/O処理の削減
• インデックスのサポート

NoSQLながら「インデックス」をサポートしているあたりはMongoDBの特徴だと思います。 「インデックス」に関連して「ユニークキー」の指定もできます。

クエリ

JSON形式で指定する特殊なクエリを利用してDBを検索します。 クエリを用いてできる操作は基本的な CRUD 操作はもちろん、以下にあげる特徴的なクエリがあります。

• 集約（Aggregation、Map-Reduce）
• "テキストインデックス" を用いた文字列検索
• 地理空間クエリ

「集約（Aggregation、Map-Reduce）」では、保存しているデータに対してさまざまな統計を行うことができます。 クエリ単体の組み立ては独特な実装なので慣れが必要ですが、処理順がパイプライン化されており、コードの見通しは良いと思います。

「地理空間クエリ」は組み込みの「GeoJSON」形式を利用して「範囲内のポイント検索」ができます。

可用性

MongoDB では レプリカセット と呼ばれる機能でレプリケーション機能を提供しています。 この レプリカセットでは 自動フェールオーバー や データ冗長性 を提供します。

水平拡張

水平拡張とは、いわゆる「マシンを増やすことで性能向上できる」という特徴です。 MongoDBではコア機能（シャーディングという仕組み）で水平拡張性を実現しています。

複数ストレージエンジンのサポート

MongoDBは複数のストレージエンジンをサポートしています。 通常利用されるファイルシステム以外にもインメモリエンジンを選択することもできます。 また、ストレージエンジンAPIを公開しているのでサードパーティーのストレージエンジンを作ることもできます。

今回はMontoDBの特徴についてまとめました。 ざっくりまとめると以下のようになります。 （ホント？と思う部分もありはしますが…公式サイトでも記載される内容ではあります。）

• ドキュメントデータベース（NoSQL）
• 特殊なクエリ
• 高性能
• 高可用性
• 水平拡張性

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

参考記事

• MongoDB - Introduction to MongoDB
• TutorialsJar - What Are The Top 10 Key Features Of MongoDB?

今回は NoSQL とは どんなものかについてまとめます。 今更といえば今更ですが…基本的なことなので改めて整理しておきます。

NoSQLとは

NoSQL とは "Not only SQL" と解釈される、非リレーショナルデータベース全般を指すものです。 非リレーショナルデータベース全般というように、リレーショナルデータベース以外のデータベースすべてを指します。

非リレーショナルデータベースのデータモデル例としては、ドキュメント、グラフ、キーバリューなどがあります。

RDB と NoSQL の違い

RDB (= リレーショナルデータベース) と NoSQL (=非リレーショナルデータベース) の特徴を表にまとめると以下のようになります。

RDBとNoSQLの間の違いはデータ構造はもちろんですが、データ整合性に対する考え方、スケーリングについても違いがあります。

NoSQL の 具体例

NoSQLを利用できる製品をいくつか以下に取り上げます。

種別	製品例
ドキュメント	https://www.mongodb.com/ http://basex.org/
キーバリュー	https://redis.io/ http://basho.com/
グラフ	https://neo4j.com/

今回はNoSQLについてまとめました。 参考になったでしょうか？

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

参考記事

• NoSQL - wikipedia
• NoSQL とは - AWS

今回は 「MongodB における インデックス の取り扱い」 についてよく使いそうなものを中心にまとめます。

MongoDB がドキュメント型データベースであるが故、ちょっと変わったインデックスが存在します。 今回はそれら RDB にないインデックスの概念も取り上げます。

MongoDB における インデックス

MongoDB では デフォルトで _id プロパティ が一意なインデックスとしてドキュメントを作成するたびに自動的に作成されます。 これで足りない場合は独自で db.collection.createIndex() を使ってインデックス作成します。 db.collection.createIndex() を用いて作られるインデックスは B-tree データ構造のインデックスです。

MongoDBでは単純なキー指定以外にもいくつかのインデックス種別をサポートしています。 具体的にサポートしているインデックス種別は以下の通りです。

• 単一キー
• 複合キー
• マルチキー
• 地理
• テキスト
• ハッシュ

「複合キー」と「マルチキー」は名称が似ていますが中身は異なります。 「複合キー」は「複数フィールドを組み合わせたキー」で、「マルチキー」は「配列を取るプロパティに対してその配列に含まれる値すべて対象とするキー」とするものです。

以下では基本となる「単一キーインデックス」「複合キーインデックス」「マルチキーインデックス」についてその具体的な使い方をサンプルコードを用いて見ていきます。

インデックス作成 の 基本

mongoシェル上で以下のコマンドを実行することで、指定されたコレクションに対してインデックスを作成することができます。

JavaScriptコード上でも関数は同じですが、第3引数にコールバックが指定できるようになる点が異なります。

構文

db.collection.createIndex(keys, options)

引数

keys

Type: string / object

値を持つフィールド名を指定します。 昇順のキーであれば 1 を、降順のキーであれば -1 を指定します。

options

Type: object

インデックス作成に関するオプションを指定します。 オプション指定できるものには以下のようなものがあります（ほかにもありますがここではピックアップ）。

• unique
• collation

使用例

以下で「単一キーインデックス（Single field index）」「複合キーインデックス (Compound index)」「マルチキーインデックス (Multi-key index)」の使用例を取り上げます。

単一キー インデックス の 作成

以下のようなサンプルドキュメントに対してインデックスを作成するサンプルコードを3通り取り上げます。 MongoDB はドキュメント型データベースなので、RDBにはない「組み込みフィールド」や「組み込みドキュメント」に対するインデックス作成ができます。

{
  "score": 1034,
  "location": { pref: "Kanagawa", city: "Yokohama" }
}

単一フィールド

もっとも単純な「単一フィールド」に対するインデックス作成およびその利用のサンプルコードです。

> db.collection.createIndex({ score: 1 })

> db.collection.find({ score: 1034 })
> db.collection.find({ score: { $gt: 1000 } })

組み込みフィールド

MongoDB では プロパティ の 値 として ドキュメント を指定することもできます。 こうした場合、ドキュメントの中のフィールド（入れ子になった要素）に対してもインデックス作成することができます。

> db.collection.createIndex({ "location.pref": 1 })

> db.collection.find({ "location.pref": "Tokyo" })

組み込みドキュメント

上記の「組み込みフィールド」に似ていますが、そもそもオブジェクトを指定してしまうこともできます。 ただし、この場合はプロパティの数およびプロパティの並び順も含めて完全一致することが求められる点に要注意です。

> db.collection.createIndex({ location: 1 })

> db.collection.find({ pref: "Kanagawa", city: "Yokohama" })

複合キー インデックス の 作成

RDBにも存在する複合キーインデックスです。 MongoDB では 複数フィールド をキーとして指定することで作成できます。 MongoDB の 複合キーインデックス では「指定された 複合キー すべてに一致する」パターンだけでなく、「一部に一致する」パターンでもインデックスが効きます。

以下のサンプルデータに対して「複合キー インデックス」を作成するサンプルを見ていきます。

{
  "item": "Apple",
  "location": "xxx store",
  "stock": 4,
  "type": "cases"
}

> db.collection.createIndex({ item: 1, location: 1, stock: 1 })

> db.collection.find({ item: "Apple" })
> db.collection.find({ item: "Apple", location: "xxx store" })
> db.collection.find({ item: "Apple", location: "xxx store", stock: { $gt: 0 } })

上記の例であれば、インデックスの作成が「item → loation → stock」なので、その先頭一部となる「item」や「item → location」などもインデックスが効きます。

マルチキー インデックス の 作成

MongoDB では 配列 を値としてとるフィールドも存在します。 配列の値は「プリミティブ」もしくは「オブジェクト」のいずれでも「マルチキーインデックス」が作成できます。

以下では 配列フィールド ratings を含むコレクションに対してインデックスの作成、検索を行うサンプルを見ていきます。

{ "item": "Apple",  ratings: [ 2, 9 ] }
{ "item": "Banana", ratings: [ 4, 3 ] }

インデックスの作成は単純に ratings に対して createIndex() するだけで作成できます。

> db.collection.createIndex({ ratings: 1 })

配列フィールドに対する検索は通常 $elemMatch を利用します。 以下のサンプルでは「3以上 かつ 6以下 の ratings が1レコード以上存在するドキュメント」を抽出しています。

> db.collection.find({ ratings: { $elemMatch: { $gte: 3, $lte: 6 } } })
{ "_id" : ObjectId("5a2d24459c684f917e3ec0c2"), "item" : "XYZ", "ratings" : [ 4, 3 ] }

以下のような記載をすると「3以上 または 6以下 を満たすレコードが1件以上存在するドキュメント」を抽出するので、結果としてすべて抽出されてしまいます。

> db.collection.find({ ratings: { $gte: 3, $lte: 6 } })
{ "_id" : ObjectId("5a2d24399c684f917e3ec0c1"), "item" : "ABC", "ratings" : [ 2, 9 ] }
{ "_id" : ObjectId("5a2d24459c684f917e3ec0c2"), "item" : "XYZ", "ratings" : [ 4, 3 ] }

今回は 「MongodB における インデックス の取り扱い」 についてまとめました。 ポイントは以下の通りです。 参考になったでしょうか？

• インデックスの作成は createIndex()
• 単一キー、複合キーだけでなくマルチキーと呼ばれるインデックスが存在する

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

参考記事

• MongoDB - db.collection.createIndex()
• MongoDB - Single Field Indexes
• MongoDB - Compound Indexes
• MongoDB - Multikey Indexes

今回は「指定された文字列を含むドキュメント数を取得する方法」についてまとめます。 集計方法はいくつか考えられますが、ここではもっとも簡単な cout() を用いた方法、および、Aggregation を用いた方法についてまとめます。

サンプルとして「果物リストから "e" の文字列を含むドキュメント数を取得する方法」を例としてみていきます。

前提データ

前提データには以下のような「果物リスト」を準備します。

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("sample3").insertMany([
    { name: "melon", price: 12000 },
    { name: "watermelon", price: 3000 },
    { name: "apple", price: 200 },
    { name: "kiwi fruit", price: 120 },
    { name: "orange", price: 180 },
    { name: "banana", price: 300 }
  ], (result) => {
    db.close();
    console.log("OK");
  });
});

count() を用いた 単一フィールド の集計

もっとも簡単な集計方法は db.collection.count() を用いた集計でしょう。 ただ…次の「Aggregation を用いた 単一フィールド の集計」にも記載している通り、環境によっては不正確になる懸念があるので、実サービスでの利用はあまりオススメはできないかと思います。 あくまで実験用と思って利用するほうが良いでしょう。

サンプルコード

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("sample3")
    .find({ name: /e/g })
    .count((err, result) => {
      console.log(result);
    });
});

実行結果

> node .\index.js
4

Aggregation を用いた 単一フィールド の集計

シャードクラスタ環境下では count() が正しく動かないことがあるそうです。 こうした環境の場合、Aggregation を利用した以下のようなコードで正しい値を取得することができるそうです。

サンプルコード

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("sample3")
    .aggregate([
      { $match: { name: /e/g } },
      { $group: { _id: null, count: { $sum: 1 } } }
    ], (err, docs) => {
      console.log(docs[0].count);
    });
});

実行結果

> node .\index.js
4

Aggregation を用いた 複数フィールド の同時集計

例えば "e" を含むドキュメント数に加えて "l" を含むドキュメント数も同時に集計したい…といった場合に想定する集計方法です。 ここまでくるとなかなかに複雑ですが…1度で集計できてしまうのはやはり便利です。

サンプルコード

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("sample3")
    .aggregate([{
      $group: {
        _id: null,
        total: { $sum: 1 },
        count_e: { $sum: { $cond: { if: { $gte: [{ $indexOfCP: ["$name", "e"] }, 0] }, then: 1, else: 0 } } },
        count_l: { $sum: { $cond: { if: { $gte: [{ $indexOfCP: ["$name", "l"] }, 0] }, then: 1, else: 0 } } }
      }
    }, {
      $project: { _id: 0 }
    }], (err, docs) => {
      if (err) throw err;
      console.log(JSON.stringify(docs[0]));
    });
});

実行結果

> node .\index.js
{"total":6,"count_e":4,"count_l":3}

気にすべきオペレーターは $cond 、 $gte 、 $indexOfCP の3つでしょうか。 それぞれの引数と渡している値について見ていきます。

$cond は {if: <boolean-expression>, then: <true-case-expression>, else: <false-case-expression>} を引数に取るオペレーターです。 今回のサンプルでは、条件文に「"e"を含む文字列かどうか」を示す構文を入れ、true の場合は "1" を返し、 false の場合は "0" を返すように実装しています。

「"e"を含むかどうか」を示す構文は $gte と $indexOfCP を用いて記述します。

$gte は 長さ2の配列 [<target-value>, <basis-value>] を引数に取るオペレーターです。 今回のサンプルだと、第1引数に「指定された文字のインデックス（今回だと "e" のインデックス）」を指定し、それが第2引数に示す通り「0以上」であるかどうかを判定しています。

$indexOfCP は 長さ4の配列 [<target-string>, <search-string>, <start>, <end>] を引数に取るオペレーターです。 今回のサンプルでは、"$name" の文字列に含まれる "e" のインデックスを取得しています。 start と end は文字列全体を対象にするので無視しています。

これらを組み合わせると上記のサンプルコードのようになるのですが、なかなか複雑。。 ただ、この実装方法を使うと「対象を絞ってから集計（＝あらかじめ $match を利用）」や「日付単位に集計（＝$group の _id に日付を指定）」などといった応用ができるようになります。 やりたいことに応じて実装方法を使い分けるのがベストかと思います。

今回は「指定された文字列を含むドキュメント数を取得する方法」についてまとめました。 ポイントは以下の通りです。

• 集計には Aggregation を使う！

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

参考記事

• MongoDB - db.collection.count()
• MongoDB - $cond (aggregation)
• MongoDB - $gte (aggregation)
• MongoDB - $indexOfCP (aggregation)

今回は MongoDB にある集計関数の１つ Map-Reduce の使い方についてまとめます。

MongoDB で集計を行おうとすると Aggregation Pipeline を利用しますが、それだけではできないような複雑なクエリ実行するときに Map-Reduce を利用します。 今回はその Map-Reduce の簡単な使い方を見ていきます。

Map-Reduce の 動作概要

Map-Reduce を使うと MongoDB のデータに対して複雑な統計処理を行ってその結果を取得することができます。

Map-Reduce の動作は大きく2段階になっています。 最初の処理は map で コレクション をグルーピングする処理になります。 次の処理は reduce で map でグルーピングしたコレクションに対して集計を行います。

以下の図は Map-Reduce の動作例です。

上図では、コレクションに対して map 処理 で type をキーとする ドキュメント の グルーピング を行い、 reduce 処理 で グルーピングされた ドキュメント に対して 合計値 を演算する 集計処理 を行っています。

この後のサンプルコードでは上図の処理を実際に実装してみます。

Map-Reduce を使ってみる （サンプルコード）

前提データ

コマンドからでもデータの投入はできますが、以下は JavaScript コードを利用して投入するようにしています。 投入しているデータは上で図示していたサンプルコレクションと同じです。 test データベース の items コレクション に投入しています。

insert.js

var CONNECTION_URL = "mongodb://localhost:27017/test";
var moment = require("moment");
var MongoClient = require("mongodb").MongoClient;

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("items").insertMany([
    { type: "A", value: 20 },
    { type: "B", value: 30 },
    { type: "A", value: 10 },
    { type: "C", value: 40 },
    { type: "D", value: 20 },
    { type: "B", value: 10 },
    { type: "C", value: 20 },
  ], (result) => {
    db.close();
  });
});

コマンド実行

> node .\insert.js

Map-Reduce してみる

では、データ投入できたところで実際に Map-Reduce で集計を行ってみます。

index.js

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  // Map function
  var map = function () {
    emit(this.type, this.value);
  };

  // Reduce function.
  var reduce = function (key, values) {
    var sum = 0;
    for (let value of values) {
      sum += value;
    }
    return sum;
  };

  // Map-Reduce options.
  var options = {
    out: { inline: 1 }
  };

  // Execute Map-Reduce process.
  db.collection("items").mapReduce(map, reduce, options).then((docs) => {
    console.log(JSON.stringify(docs));
  });
});

collection.mapReduce() 関数は map 関数 , reduce 関数 , options オブジェクト の 3引数 をとります。 第4引数にコールバック関数を指定することができますが、指定しなければ戻り値の Promise を利用して結果を取得することができます。 上記のサンプルコードでは Promise を利用した方法で記載しています。

map 関数 中では必ず emit(key, value) を呼びます。 emit() は 2引数 をとります。 第1引数 はグルーピングするためのキーを指定します（オブジェクトも可）。 第2引数には reduce() の 第2引数 の配列要素として引き渡す値（オブジェクトも可）を指定します。 また、 map 関数 内における this は 探索中のドキュメント自身 を指すので、this.type などとすれば 値 を取得することができます。

reduce 関数 は key と values の 2引数を取ります。 第1引数の key は map 関数 でグルーピングした際に利用した キー が引き渡されます。 第2引数の values は 配列 で、map 関数 内の emit() の第2引数に渡された値またはオブジェクトが配列として渡されます。 reduce 関数 では 第2引数 で渡された配列のデータを集計した結果を戻り値として return します。

options オブジェクト にはいくつか指定ができますが…詳細は後の節に回します。 最低限 out オプションだけは指定しておかないとエラーになります。 out オプションは Map-Reduce の出力先を指定できるのですが、普通に使う（コード内で利用する）には { out: {inline: 1} } でよいかと思います。

では、実際に上記コード index.js を実行してみましょう。

コマンド実行

> node .\index.js

実行結果

[{"_id":"A","value":30},{"_id":"B","value":40},{"_id":"C","value":60},{"_id":"D","value":20}]

Map-Reduce するとグルーピングキーは _id へ入り、集計結果（reduce 関数 の戻り値）は value というプロパティの値に入ります。 reduce 関数 の戻り値にオブジェクトを指定していた場合、 value もオブジェクトになります。

Map-Reduce にもう少し踏み込んでみる

以下に挙げる内容はいずれも options オブジェクト のプロパティとして指定することで実現できます。 個別に詳細を見ていきましょう。

対象を絞り込む

{ query: <検索条件> }

query オプションを指定すると、Map-Reduce の対象とするコレクションをあらかじめ絞り込むことができます。 結果に対する絞り込みではない点には注意です。

検索条件には find で指定するときと同様のクエリを指定できます。 検索クエリで利用可能なオペレーターは mongodb - Query and Projection Operators に記載があります。

サンプル

db.collection.mapReduce(map, reduce, {
  out: { inline: 1 },
  query: { value: { $gte: 20 } }
});

対象をソートする

{ sort: <ソート条件> }

sort オプションを指定すると Map-Reduce の対象とするコレクションに対してあらかじめソートをしておくことができます。 結果に対するソートではない点が残念ですが…。。

db.collection.mapReduce(map, reduce, {
  out: { inline: 1 },
  sort: { value: 1 }
});

結果をソートする

上記の通り結果をソートするオプションは存在しないので、結果として取得される配列を単純に sort するくらいしかありません。 aggregate() には $sort があるので、aggregate で実現できないか検討しなおしてみるのも方法の１つかとは思います。

db.collection("items").mapReduce(map, reduce, options).then((docs) => {
  docs.sort((a, b) => {
    return a.value > b.value ? 1 : -1;
  })
  console.log(JSON.stringify(docs));
});

最後に処理する

{ finalize: <処理> }

各グループに対して reduce 処理 が終わった後に実施したい処理があれば finalize オプションに関数を指定して実行することができます。 …ただ、この finalize オプションで指定できる関数は指定した関数の外に対して影響するような操作ができません。 例えば、コンソールにログ出したり、スコープ外のオブジェクトを操作したりなどはできません。 しかもグループごとに呼び出されるので、reduce() の return 直前に処理を入れるのと同じです。 ちなみにすべての reduce 処理 が終わった後に何か処理したいのであれば、それはそもそも mapReduce のコールバックまたは Promise で続く処理の先頭で処理すればよいはずです。

以下にサンプルコードを記載しますが…正直このオプションは使えないオプションかと。。

db.collection.mapReduce(map, reduce, {
  out: { inline: 1 },
  finalize: function (key, reduced) {
    return {
      key: key,
      val: reduced
    };
  }
});

今回は MongoDB の Map-Reduce についてまとめました。 ポイントは以下の通りです。 参考になったでしょうか？

• map で グルーピング
• reduce で 集計

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

今回は MongoDB で 最大値 または 最小値 を取得する方法についてまとめます。

前提データ

test データベース の sample コレクション に以下のようなデータがある前提で、 price の最大値または最小値を取得するサンプルを見ていきます。

> use test
switched to db test
> db.sample.find()
{ "_id" : ObjectId("59fc8cca060ed81c5c835c7a"), "item" : "ABC", "price" : 120 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c7b"), "item" : "ABC", "price" : 120 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c7c"), "item" : "BCD", "price" : 150 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c7d"), "item" : "ABC", "price" : 120 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c7e"), "item" : "BCD", "price" : 150 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c7f"), "item" : "BCD", "price" : 150 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c80"), "item" : "ABC", "price" : 120 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c81"), "item" : "BCD", "price" : 150 }
{ "_id" : ObjectId("59fc8cca060ed81c5c835c82"), "item" : "CDE", "price" : 180 }

最大値を取得するサンプルコード

複雑なことはする必要がありません。 昇順にソート (L.8) して最初の1件 (L.10) を取得すれば、最大値が取得できます。 サンプルコードでは最後に $project を行っていますが、取得されるデータ量が少なければあえて実行する必要はないかもしれません。

サンプルコード

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

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("sample").aggregate([{
    $sort: { price: -1 }
  }, {
    $limit: 1
  }, {
    $project: { _id: 0, price: 1 }
  }]).toArray((err, docs) => {
    if (err) throw err;
    console.log(JSON.stringify(docs));
  });
});

実行結果

[{"price":180}]

最小値を取得するサンプルコード

上記の「最大値を取得するサンプルコード」において $sort: { price: -1 } を { price: 1 } とすれば最小値を取得できます。 要するにソート順を変更するだけです。

サンプルコード

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

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("sample").aggregate([{
    $sort: { price: 1 }
  }, {
    $limit: 1
  }, {
    $project: { _id: 0, price: 1 }
  }]).toArray((err, docs) => {
    if (err) throw err;
    console.log(JSON.stringify(docs));
  });
});

実行結果

[{"price":120}]

今回は MongoDB で 最大値 または 最小値 を取得する方法 についてまとめました。 ポイントは「sort → limit」で取得することです。 参考になったでしょうか？

本記事がお役に立つと嬉しいです！！

MongoDB において 日付ごとにレコード数や総数、最小、最大、平均などを集計する方法をまとめます。

前提データ

以下のコードを利用して前提データを投入し、投入された db.figures に対して集計を行うサンプルを見ていきます。 キーとなる日付 datetime は Date型 で入れてあるものを前提に集計方法を見ていきます。

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

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  var bulk = db.collection("figures").initializeOrderedBulkOp();

  bulk.insert({ datetime: moment("2017/10/29", "YYYY/M/D").toDate(), item: "ABC", price: 120 });
  bulk.insert({ datetime: moment("2017/10/29", "YYYY/M/D").toDate(), item: "ABC", price: 120 });
  bulk.insert({ datetime: moment("2017/10/29", "YYYY/M/D").toDate(), item: "BCD", price: 150 });
  bulk.insert({ datetime: moment("2017/10/30", "YYYY/M/D").toDate(), item: "ABC", price: 120 });
  bulk.insert({ datetime: moment("2017/10/30", "YYYY/M/D").toDate(), item: "BCD", price: 150 });
  bulk.insert({ datetime: moment("2017/11/1", "YYYY/M/D").toDate(), item: "BCD", price: 150 });
  bulk.insert({ datetime: moment("2017/11/2", "YYYY/M/D").toDate(), item: "ABC", price: 120 });
  bulk.insert({ datetime: moment("2017/11/2", "YYYY/M/D").toDate(), item: "BCD", price: 150 });
  bulk.insert({ datetime: moment("2017/11/2", "YYYY/M/D").toDate(), item: "CDE", price: 180 });
  
  bulk.execute().then((result) => {
    db.close();
  });
});

集計コード

集計には db.collection.aggregate() の $group コマンドを利用します。

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

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  db.collection("figures").aggregate([
    {
      $group: {
        _id: {
          yyyy: { $year: "$datetime" },
          mm: { $month: "$datetime" },
          dd: { $dayOfMonth: "$datetime" }
        },
        datetime: { $first: "$datetime" },
        total: { $sum: "$price" },
        min: { $min: "$price" },
        max: { $max: "$price" },
        average: { $avg: "$price" },
        count: { $sum: 1 }
      }
    }, {
      $project: {
        _id: 0, datetime: 1, total: 1, min: 1, max: 1, average: 1, count: 1
      }
    }, {
      $sort: {
        datetime: 1
      }
    }
  ], (err, results) => {
    console.log(JSON.stringify(results));
  });
});

日付ごとに集計する場合、 _id に日時を分解して入れるのがポイントになります。 グループ化する際のキーとなる日付に対して、Date型 から年月日を取り出すオペレーターは $year, $month, $dayOfMonth になります。 また、集計に利用できるコマンドとしては $sum(合計値計算), $min(最小値), $max(最大値), $avg(平均値) などがあります。 その他サブコマンドについては Group Accumulator Operators - MongoDB を参照してください。

aggregate() パイプラインの2番目の $project では 返却するドキュメントで不要な _id を削除しています。

パイプライン3番目の $sort では日付の昇順に並び替えをしています。 何も指定していないと順番は適当な順になってしまいます。

集計結果

上記「集計コード」を実行した結果は以下のようになります。

[
  {"datetime":"2017-10-28T15:00:00.000Z","total":390,"min":120,"max":150,"average":130,"count":3},
  {"datetime":"2017-10-29T15:00:00.000Z","total":270,"min":120,"max":150,"average":135,"count":2},
  {"datetime":"2017-10-31T15:00:00.000Z","total":150,"min":150,"max":150,"average":150,"count":1},
  {"datetime":"2017-11-01T15:00:00.000Z","total":450,"min":120,"max":180,"average":150,"count":3}
]

必要な集計結果が得られていることが確認できるかと思います。

datetime に入っている日時は要注意です。 データ投入時は「日本時間（+09:00）」で投入していますが、取り出す際は「グリニッジ標準時間（+00:00）」で取り出しているので、日時がずれたように見えます。 この時差は moment.js などを利用して日本時間に直して利用したほうがわかりやすくなると思います。

今回の記事は参考になったでしょうか。 MongoDB の aggregation はいろいろとできるようなので、今後も面白そうなネタがあれば取り上げていきたいと思います！！

MongoDB に 文字列 で入れてしまった 日時 を Date オブジェクトへ変換する方法にについてサンプルコードを作成しました。

前提条件

書き換えを行いたいデータは以下のようなものを想定します。 このデータの datetime フィールドを書き換える方法を以下で見ていきます。

データベース

test

コレクション

sample

フィールド

datetime

> use test
> db.sample.find()
{ "_id": ObjectId("xxxxxxxxxxxxxxxxxx"), "datetime": "2017/11/3" }

文字列から日付へ変換するサンプルコード

利用モジュール

サンプルコード最初の2行でわかると思いますが、このサンプルコードでは以下の2モジュールを利用しています。 あらかじめインストールしてから上記サンプルコードを利用してください。

• mongodb
• moment

サンプルコード (index.js)

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

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

MongoClient.connect(CONNECTION_URL).then((db) => {
  var collection = db.collection("sample");

  // Get bulk insert operation.
  var bulk = collection.initializeUnorderedBulkOp();

  // Update properties.
  collection.find({ datetime: { $exists: true, $type: 2 } }).forEach((doc) => {
    bulk.find({ _id: doc._id })
      .updateOne({ $set: { datetime: moment(doc.datetime, "YYYY/MM/DD").toDate() } });
  }, (err) => {
    bulk.execute((err, result) => {
      db.close();
      console.log("OK");
    });
  });
});

サンプルコード解説

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

MongoDBへの接続文字列を設定します。 ここでは localhost の test データベースへ接続しています。 任意に読み替えてください。 ちなみに認証が必要な時は "mongodb://username:password@localhost:27107/database" になります。

  var bulk = collection.initializeUnorderedBulkOp();

データ書き換え量が多いときは Bulk を使ったほうが早いので、 initializeUnorderedBulkOp() で Bulk を生成しています。

  collection.find({ datetime: { $exists: true, $type: 2 } }).forEach((doc) => {

書き換え対象の選定処理です。 フィールド名が datetime で 文字列 の場合に置き換えを行う対象としています。 $type: 2 が 「文字列であること」 を意味しています。 その他の型については $type - MongoDB Manual を参照してください。

      .updateOne({ $set: { datetime: moment(doc.datetime, "YYYY/MM/DD").toDate() } });

日付文字列 を Date型 へ変換する際、必ずしも標準的な文字列になっているとは限らないので、 moment.js を利用してフォーマット指定のパースを行います。 moment をそのまま入れてしまうと余計なデータを保存してしまうので、必ず .toDate() を利用して Date オブジェクトのみ保存するようにします。

以上が MongoDB で 日付文字列 を 日付型 へ変換する方法になります。 参考になりましたでしょうか。 参考までにですが…量があまりに多いときは部分コミットするなどの工夫をしたほうが良いかもしれません。

Node.js + Express + MongoDB を使った「検索」機能のサンプルを作ってみます。 今回はサンプルとして「店舗検索」を行うような機能を実装してみます。

概要

店舗検索として、検索条件入力で入力した条件にマッチする店舗一覧が表示されるような機能を作ります。 検索結果画面には検索結果総数、ページネーション（ページング）を実装します。

以下、基本設計…とまではいきませんが、本記事で作ろうとしている機能の概要をまとめます。

画面

「検索条件入力」画面と「検索結果出力」画面の2画面を作成します。 以下には画面ごとに作成する項目もあわせて記載しています。

• 検索条件入力 (/search/index.ejs)

  

  • 検索テキスト
  • 検索ボタン

• 検索結果出力 (/search/result-list.ejs)

  

  • 検索テキスト
  • 検索ボタン
  • 検索結果総数
  • 検索結果リスト
    • 店舗名
    • 店舗所在地
    • 店舗電話番号
  • ページネーション

データベース

以下のようなドキュメントスキーマを想定します。

test

shops

shop = {
  name:     { type: string },
  location: { type: string },
  tel:      { type: string }
}

何はともあれ試すにはデータが必要なので、以下のコードをコピペして MongoDB に追加しておきます。

db.shops.insert({name: "abc shop1", location: "shibuya", tel: "0120-111-1111"});
db.shops.insert({name: "bcd shop2", location: "shinagawa", tel: "0120-111-2222"});
db.shops.insert({name: "cde shop3", location: "shinjuku", tel: "0120-111-3333"});
db.shops.insert({name: "def shop4", location: "ikebukuro", tel: "0120-111-4444"});
db.shops.insert({name: "efg shop5", location: "akihabara", tel: "0120-111-5555"});

実装

それでは、Node.js + Express + MongoDB を使って実装を行っていきます。 作成するファイルおよび実装は以下の通りです。 ファイルごとに実装の内容を見ていきます。

• /app.js
• /search/index.ejs
• /search/result-list.ejs
• /search/result-item.ejs

/app.js

var express = require("express");
var bodyParser = require("body-parser");
var MongoClient = require("mongodb").MongoClient;

// expressインスタンス生成
var app = express();

// テンプレートエンジンの設定
app.set("views", "./views");
app.set("view engine", "ejs");

// ミドルウエアの設定
app.use("/public", express.static("public"));
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

// ルーティング設定
app.use("/shop", (function () {
  var router = express.Router();

  // GET: /shop/search
  router.get("/search", function (request, response) {
    var URL = "mongodb://localhost:27017/test";
    var MAX_ITEMS_PER_PAGE = 1;
    var query = request.query.q;
    var page =request.query.pg ? parseInt(request.query.pg) : 1;

    // 検索クエリがない場合、初期表示
    if (!query) {
      return response.render("./search/index.ejs");
    }

    // 検索クエリがある場合、データベースを検索して結果リストを表示
    MongoClient.connect(URL).then((db) => {
      return Promise.all([
        // 検索総ヒット数
        db.collection("shops").find({
          name: new RegExp(`.*${query}.*`)
        }).count(),
        // 現在ページに表示する内容
        db.collection("shops").find({
          name: new RegExp(`.*${query}.*`)
        }).skip((page - 1) * MAX_ITEMS_PER_PAGE).limit(MAX_ITEMS_PER_PAGE).toArray()
      ]);
    }).then((results) => {
      // ビューへ渡すデータを整形
      var data = {
        count: results[0],
        list: results[1],
        pagination: {
          max: Math.ceil(results[0] / MAX_ITEMS_PER_PAGE),
          current: page,
          isFirst: page === 1,
          isLast: page === Math.ceil(results[0] / MAX_ITEMS_PER_PAGE)
        },
        query: query
      };
      // ビューを表示
      return response.render("./search/result-list.ejs", data);
    }).catch((reason) => {
      // エラー処理
      console.log(reason);
    });

  return router;
})());

// サーバー起動
app.listen(3000);

メインとなる処理です。 Node.js、Express、MongoDB の基本的な処理についてはここでは割愛します。

L.29-31: 検索クエリの有無はクエリパラメーター q に値が設定されているかどうかで判定しています。 値が設定されていなければ初期表示を行います。 全件策したいところですが…データが多くなった時に応答時間が長くなりそうなので止めておきます。。

L35-44: データベースから取得する情報は「検索結果総数」と「現在ページに表示する内容」の2種類です。 それぞれのデータは非同期で取得するので Promise.all() を使ってすべての処理が完了するのを保証します。

L47-57: ビューへ渡すデータを整形します。 ページネーション（ページング）に必要な情報はここで整形しておきます。 ページネーションを作るにはループで作成するので、「ページ総数 (max)」と「現在ページ番号 (current)」は最低でも準備しておきます。

/views/search/index.ejs

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>search</title>
  </head>
  <body>
    <h1>検索</h1>
    <form action="/shop/search" method="GET">
      <input type="text" id="q" name="q" />
      <input type="submit" value="検索" />
    </form>
  </body>
</html>

検索条件入力画面の初期表示ページ。 結果はないので検索条件を入力するだけの単純なページです。 検索条件クエリ―の有無で表示ページを出しわけしているので、フォームのメソッドは GET としています。

/views/search/result-list.ejs

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>search</title>
    <style>
      .result-item { border: 1px solid #666; margin: 0.5em 1em; }
      .pagination { list-style: none; display: flex; }
      .pagination li { display: inline-block; width: 2em; }
    </style>
  </head>
  <body>
    <h1>検索</h1>
    <form action="/shop/search" method="GET">
      <input type="text" id="q" name="q" value="<%= query %>"/>
      <input type="submit" value="検索" />
    </form>
    <p>結果：<%= count %>件</p>
    <p>
<% for(var i = 0; i < list.length; i++) {%>
<%- include("result-item.ejs", list[i]); %>
<% }%>
    </p>
    <p>
      <ul class="pagination">
<% for (var i = 1; i <= pagination.max; i++) {%>
<%   if (i !== pagination.current) {%>
        <li><a href="/shop/search?q=<%= query %>&pg=<%= i %>"><%= i %></a></li>
<%   } else {%>
        <li><%= i %></li>
<% }}%>
      </ul>
    </p>
  </body>
</html>

検索結果表示画面。 リストの外枠だけを記述して個別検索結果は include で読み込むようにします。

L18: 検索結果総数の表示は count に保持しているのでそれを表示します。

L20-22: 検索結果リストを for でループしながら include に値を入れて表示を行います。 具体的な表示内容はこの後の result-item.ejs を確認してください。 include を利用するときは <%- include("VIEW_FILEPATH") %> と記述する点に注意です。

L26-31: ページネーション（ページング）の表示です。 表示する「ページ総数」と「現在ページ」はサーバー側 (app.js) で算出しているので、それらを利用して表示を行います。

/views/search/result-item.ejs

<div>
  <table class="result-item">
    <tr>
      <th>name</th>
      <td><%= name%></td>
    </tr>
    <tr>
      <th>location</th>
      <td><%= location%></td>
    </tr>
    <tr>
      <th>tel</th>
      <td><%= tel%></td>
    </tr>
  </table>
</div>

検索結果の各項目を定義しています。 MongoDB から取得した値がそのまま流れてきているので、表示したいデータを埋め込んでいきます。

テスト

上記の実装がすべて終われば動作するはずなので、動作確認を行います。

• 検索条件入力

  

• 検索結果出力

  

スタイルの実装を最低限としたので、最初の 概要 のイメージとは少しデザインが異なりますが…機能としては必要なものが盛り込まれているかと思います。

今回の記事は参考になったでしょうか？ 一般的な検索ページの作成をテーマに Node.js + Express でどのように実装するかをまとめてみました。 本記事（検索ページ作成）のポイントは以下の通りです。

• 検索リクエストは GET
• 検索結果画面には「検索入力」、「検索結果総数」、「検索結果」、「ページネーション」を表示
• MongoDB への複数リクエストは Promise.all() で非同期ですべて取得
• 「ページネーション」に必要な値はサーバー側で準備

今回は、データベースサーバー操作で基本となる バックアップ / リカバリ についてまとめます。 MongoDB 3.0.0 から サーバー を起動しておき、 MongoDB サーバー へ接続しないとバックアップが取れないように修正されました。 アクセス制御を有効化している場合は接続するユーザーのロールと対象とするデータベースに気を付けます。

バックアップ

アクセス制御がない場合

MongoDB サーバーにおいて以下のコマンドを実行すると BSON ファイル で指定した場所にバックアップが取得できます。 アクセス制御がなければすべてのデータベースを対象にバックアップ & リストアができます。

mongodump -o <PATH>

アクセス制御が有効な場合

すべてのデータベースを読み取れるユーザーが存在しない限り（←こんなユーザーがいたらアクセス制御の意味がない。。）、データベース単位での バックアップ & リストア になります。 MongoDB サーバー が認証を有効にしている場合、「認証先データベース名」、「ユーザー名」、「パスワード」、「バックアップ対象データベース名」を指定する必要があります。 また、バックアップを実行できるユーザーは「read」ロールを持っているユーザーになります。 「dbAdmin」ロールだけではバックアップできません。

構文

mongodump --authenticationDatabase <DATABASENAME> -u <USERNAME> -p <PASSWORD> -d <TARGET>

オプション

サンプルコード

mongodb --authenticationDatabase test -u user1 -p user1 -d test -o "./dump/20170114"

リストア

アクセス制御がない場合

mongodump で出力先指定したパス (-o オプションで指定したパス)を指定してリストアします。 アクセス制御がなければ自由にバックアップ & リストアできるので、すべてのデータベースを対象にリストアもできます。 -d オプションを指定しなければすべてのデータベースを対象にリストアします。

mongorestore <PATH>

アクセス制御が有効な場合

バックアップと同じく基本的にはデータベース単位での作業になります。 「認証先データベース名」「ユーザー名」「パスワード」「リストア先データベース名」「リストアするBSONファイルがあるパス」を指定してリストアします。

構文

mongorestore --authenticationDatabase <DATABASENAME> -u <USERNAME> -p <PASSWORD> -d <TARGET> <PATH>

オプション

サンプルコード

mongodb --authenticationDatabase test -u user1 -p user1 -d test -o "./dump/20170114/test"

サンプルコード (まとめ)

基本的なことは上までに記載しましたが…、バックアップとリストアを通してどのように行うのか見えづらいので、以下にパターン別でまとめます。

アクセス制御なし MongoDB で すべてのデータベース を バックアップ・リストア

mongodump -o "./dump"

mongorestore "./dump"

アクセス制御がある MongoDB で 特定のデータベース を バックアップ・リストア

mongodump --authenticationDatabase test -u readRoleUser -p password -d test -o "./dump"

mongorestore --authenticationDatabase test -u readWriteRoleUser -p password -d test "./dump/test"

参考記事

• MongoDB - Back Up and Restore with MongoDB Tools
• MongoDB - mongodump
• MongoDB - mongorestore
• Qiita - MongoDBでデータをバックアップ/リストアする
• 渋谷ではたらくマー君の技術とかブログ。 - 【MongoDB】バックアップのmongodumpとリストアのmongorestoreコマンド

MongoDB で アクセス制御を有効化 するとユーザー管理が必要になってきます。 ここでは MongoDB で使う ユーザーに関する操作として ユーザーの追加、一覧表示、変更、削除 といった一連の方法についてまとめました。 ユーザー情報の変更ではよく使いそうな パスワード変更、ロール追加、ロール削除のみ扱っています。

ユーザー の 作成

新規ユーザーは db.createUser() メソッドで作成できます。 ユーザー名は「データベース名＋ユーザー名」の組み合わせで一意になっているようなので、登録する際は接続先データベース名に注意してください。

構文

db.createUser({
    user: "<username>",
    pwd: "<password>",
    roles: [{
        role: "<role>",
        db: "<database>"
    }]
})

サンプルコード

user test
db.createUser({
    user: "tanaka",
    pwd: "qwerty",
    roles: [{
        role: "readWrite",
        db: "test"
    }]
})

ユーザー の 一覧表示

db.getUsers() メソッドで現在接続中のデータベースに登録されているユーザー一覧が表示できます。

構文

db.getUsers()

サンプルコード

use test
db.getUsers()

ユーザー情報 の 変更

ユーザー情報の変更として「パスワード変更」「ロール追加」「ロール削除」についてまとめます。

パスワード変更

db.changeUserPassword() メソッドを利用すると、指定したユーザーのパスワードを更新できます。

構文

db.changeUserPassword("<username>", "<password>")

サンプルコード

use test
db.changeUserPasword("tanaka", "password")

ロール 追加

db.grantRolesToUser() メソッドで指定したユーザーにロールを追加することができます。 ロールの指定方法はユーザー作成 db.createUser() でロール指定する方法と同じです。

構文

db.grantRolesToUsre("<username>", ["<roles>"]})

サンプルコード

use products
db.grantRolesToUsre(
    "tanaka",
    ["readWrite", {role: "read", db: "stock"}]
)

ロール 削除

db.revokeRolesFromUser() メソッドで指定したユーザーからロールを削除することができます。 ロールの指定方法はユーザー作成 db.createUser() でロール指定する方法と同じです。

構文

db.revokeRolesFromUsre("<username>", ["<roles>"]})

サンプルコード

use products
db.revokeRolesFromUsre(
    "tanaka",
    [{role: "read", db: "stock"}]
)

ユーザー の 削除

db.dropUser() で指定したユーザーを削除できます。 db.removeUser() というメソッドも存在しますが、こちらは 2.6以降 非推奨となっています。

構文

db.dropUser("<username>")

サンプルコード

use test
db.dropUser("tanaka")