node.jsmongodbのネストされた配列を合計します

注 ：日付の実際の処理は、実際の使用では、保存する粒度によって大きく異なる場合があります。このサンプルでは、​​日付はすべて、各「日」の開始にすでに丸められています。実際に実際の「日時」値を累積する必要がある場合は、おそらく次のような構成が必要になります。

{ "$group": {
  "_id": {
    "date": {
      "$dateFromParts": {
        "year": { "$year": "$first_level.second_level.third_level.forth_level.sales_date" },
        "month": { "$month": "$first_level.second_level.third_level.forth_level.sales_date" },
        "day": { "$dayOfMonth": "$first_level.second_level.third_level.forth_level.sales_date" }
      }
    }.
    "price": "$first_level.second_level.third_level.forth_level.price"
  }
  ...
}}

$ dateFromPartsを使用する およびその他の日付集計演算子 「日」情報を抽出し、その形式で日付を提示して蓄積します。

非正規化の開始

上記の「混乱」から明らかなことは、ネストされた配列での作業は必ずしも簡単ではないということです。このような構造は、MongoDB 3.6より前のリリースでは一般にアトミックに更新することさえできませんでした。また、それらを更新したり、基本的に配列全体を置き換えたりしたことがなくても、クエリを実行するのは簡単ではありません。これが表示されているものです。

しなければならない場所 親ドキュメント内に配列コンテンツがある場合は、通常、「フラット化」することをお勧めします。 および「非正規化」 そのような構造。これはリレーショナル思考に反しているように見えるかもしれませんが、パフォーマンス上の理由から、実際にはそのようなデータを処理するための最良の方法です：

{
  "_id": 1,
  "data": [
    {
      "first_item": "A",
      "second_item": "A",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-10-31"),
      "quantity": 1
    },

    { 
      "first_item": "A",
      "second_item": "A",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-11-01"),
      "quantity": 1
    },
    { 
      "first_item": "A",
      "second_item": "A",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-11-02"),
      "quantity": 1
    },
    { 
      "first_item": "A",
      "second_item": "A",
      "third_item": "B",
      "price": 1,
      "sales_date": new Date("2018-10-31"),
      "quantity": 1
    },
    {
     "first_item": "A",
     "second_item": "A",
     "third_item": "B",
     "price": 1,
     "sales_date": new Date("2018-11-03"),
     "quantity": 1
    },
    {
      "first_item": "A",
      "second_item": "B",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-11-03"),
      "quantity": 1
     },
  ]
},
{
  "_id": 2,
  "data": [
    {
      "first_item": "A",
      "second_item": "A",
      "third_item": "A",
      "price": 2,
      "sales_date": new Date("2018-11-03"),
      "quantity": 1
    },
    { 
      "first_item": "A",
      "second_item": "A",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-10-31"),
      "quantity": 1
    },
    { 
      "first_item": "A",
      "second_item": "A",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-11-03"),
      "quantity": 1
    }
  ]
},
{
  "_id": 3,
  "data": [
    {
      "first_item": "A",
      "second_item": "B",
      "third_item": "A",
      "price": 1,
      "sales_date": new Date("2018-11-03"),
      "quantity": 1
     }
  ]
}

これはすべて最初に表示されたものと同じデータですが、ネストではありません 実際には、すべてを各親ドキュメント内の単一のフラット化された配列に配置します。確かにこれは複製を意味します さまざまなデータポイントの違いがありますが、クエリの複雑さとパフォーマンスの違いは自明です。

db.collection.aggregate([
  { "$match": {
    "data": {
      "$elemMatch": {
        "first_item": "A",
        "second_item": "A",
        "third_item": "A",
        "sales_date": {
          "$gte": new Date("2018-11-01"),
          "$lt": new Date("2018-12-01")
        }
      }
    }
  }},
  { "$addFields": {
    "data": {
      "$filter": {
        "input": "$data",
         "cond": {
           "$and": [
             { "$eq": [ "$$this.first_item", "A" ] },
             { "$eq": [ "$$this.second_item", "A" ] },
             { "$eq": [ "$$this.third_item", "A" ] },
             { "$gte": [ "$$this.sales_date", new Date("2018-11-01") ] },
             { "$lt": [ "$$this.sales_date", new Date("2018-12-01") ] }
           ]
         }
      }
    }
  }},
  { "$unwind": "$data" },
  { "$group": {
    "_id": {
      "date": "$data.sales_date",
      "price": "$data.price",
    },
    "quantity_sold": { "$avg": "$data.quantity" }
  }},
  { "$group": {
    "_id": "$_id.date",
    "prices": {
      "$push": {
        "price": "$_id.price",
        "quantity_sold": "$quantity_sold"
      }
    },
    "quantity_sold": { "$avg": "$quantity_sold" }
  }}
])

これらをネストする代わりに、 $ elemMatch 同様に、 $ filterを呼び出します。 式、すべてがはるかに明確で読みやすく、処理が非常に簡単です。クエリで使用される配列内の要素のキーに実際にインデックスを付けることさえできるという別の利点があります。それはネストされたの制約でした MongoDBがそのような「マルチキーインデックス」> 配列内の配列のキー 。単一のアレイでは、これが許可され、パフォーマンスを向上させるために使用できます。

「配列コンテンツフィルタリング」以降のすべて その後、 "data.sales_date" のようなパス名だけを除いて、まったく同じままです。 長く曲がりくねった"first_level.second_level.third_level.forth_level.sales_date"とは対照的に 前の構造から。

埋め込まない場合

最後に、もう1つの大きな誤解は、すべての関係 配列内の埋め込みとして変換する必要があります。これは実際にはMongoDBの意図ではなく、「結合」ではなくデータの単一の取得を行うことを意味する場合にのみ、同じドキュメント内の「関連する」データを配列に保持することを目的としていました。

ここでの古典的な「注文/詳細」モデルは、通常、現代の世界で、顧客の住所、注文合計などの詳細を、の詳細と同じ「画面」内に表示する「注文」の「ヘッダー」を表示する場合に適用されます。 「注文」のさまざまな広告申込情報。

RDBMSの開始にさかのぼると、典型的な80文字×25行の画面では、1つの画面にそのような「ヘッダー」情報が表示され、購入したすべての詳細行は別の画面に表示されていました。したがって、当然、それらを別々のテーブルに格納するためのある程度の常識がありました。世界がそのような「画面」でより詳細に移動するにつれて、通常は全体、または少なくとも「ヘッダー」とそのような「順序」の最初の非常に多くの行を見たいと思うでしょう。

したがって、MongoDBは関連データを含む「ドキュメント」を一度に返すため、この種の配置を配列に入れることが理にかなっているのはなぜですか。個別にレンダリングされた画面を個別にリクエストする必要はなく、データはすでに「事前結合」されているため、そのようなデータに「結合」する必要もありません。

必要かどうかを検討してください-別名「完全に」非正規化

したがって、ほとんどの場合、そのような配列内のほとんどのデータを実際に処理することに関心がないことがほとんどわかっている場合は、通常、すべてを1つのコレクションにまとめ、別のプロパティを追加する方が理にかなっています。そのような「参加」が時折必要とされる場合、「親」を識別するために：

{
  "_id": 1,
  "parent_id": 1,
  "first_item": "A",
  "second_item": "A",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-10-31"),
  "quantity": 1
},
{ 
  "_id": 2,
  "parent_id": 1,
  "first_item": "A",
  "second_item": "A",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-11-01"),
  "quantity": 1
},
{ 
  "_id": 3,
  "parent_id": 1,
  "first_item": "A",
  "second_item": "A",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-11-02"),
  "quantity": 1
},
{ 
  "_id": 4,
  "parent_id": 1,
  "first_item": "A",
  "second_item": "A",
  "third_item": "B",
  "price": 1,
  "sales_date": new Date("2018-10-31"),
  "quantity": 1
},
{
  "_id": 5,
  "parent_id": 1,
  "first_item": "A",
  "second_item": "A",
  "third_item": "B",
  "price": 1,
  "sales_date": new Date("2018-11-03"),
  "quantity": 1
},
{
  "_id": 6,
  "parent_id": 1,
  "first_item": "A",
  "second_item": "B",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-11-03"),
  "quantity": 1
},
{
  "_id": 7,
  "parent_id": 2,
  "first_item": "A",
  "second_item": "A",
  "third_item": "A",
  "price": 2,
  "sales_date": new Date("2018-11-03"),
  "quantity": 1
},
{ 
  "_id": 8,
  "parent_id": 2,
  "first_item": "A",
  "second_item": "A",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-10-31"),
  "quantity": 1
},
{ 
  "_id": 9,
  "parent_id": 2,
  "first_item": "A",
  "second_item": "A",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-11-03"),
  "quantity": 1
},
{
  "_id": 10,
  "parent_id": 3,
  "first_item": "A",
  "second_item": "B",
  "third_item": "A",
  "price": 1,
  "sales_date": new Date("2018-11-03"),
  "quantity": 1
}

繰り返しますが、これは同じデータですが、今回は完全に別のドキュメントで、別の目的で実際に必要になる可能性がある場合に備えて、親への参照が含まれています。ここでの集計はすべて親データとはまったく関係がないことに注意してください。また、別のコレクションに保存するだけで、パフォーマンスの向上と複雑さの解消がどこでもたらされるかも明らかです。

db.collection.aggregate([
  { "$match": {
    "first_item": "A",
    "second_item": "A",
    "third_item": "A",
    "sales_date": {
      "$gte": new Date("2018-11-01"),
      "$lt": new Date("2018-12-01")
    }
  }},
  { "$group": {
    "_id": {
      "date": "$sales_date",
      "price": "$price"
    },
    "quantity_sold": { "$avg": "$quantity" }
  }},
  { "$group": {
    "_id": "$_id.date",
    "prices": {
      "$push": {
        "price": "$_id.price",
        "quantity_sold": "$quantity_sold"
      }
    },
    "quantity_sold": { "$avg": "$quantity_sold" }
  }}
])

すべてがすでにドキュメントであるため、「配列をフィルタリングする」必要はありません。 または他の複雑さのいずれかを持っています。一致するドキュメントを選択して結果を集計するだけで、これまでとまったく同じ2つの最終ステップが実行されます。

最終結果を得るだけの目的で、これは上記のいずれの方法よりもはるかに優れたパフォーマンスを発揮します。問題のクエリは実際には「詳細」データのみに関係しているため、最善のアクションは、常に最高のパフォーマンス上の利点を提供するため、詳細を親から完全に分離することです。

そして、ここでの全体的なポイントは、アプリケーションの残りの部分の実際のアクセスパターンが決してないということです。 配列の内容全体を返す必要があります。そうすれば、とにかく埋め込まれるべきではなかったでしょう。どうやらほとんどの「書き込み」操作は、同様に関連する親に触れる必要がないはずです。これは、これが機能するかどうかを決定するもう1つの要因です。

結論

一般的なメッセージは、原則として、配列をネストしてはならないということです。せいぜい、関連する親ドキュメント内に部分的に非正規化されたデータを含む「単一の」配列を保持する必要があります。残りのアクセスパターンでは、親と子がまったく連携して使用されない場合は、データを実際に分離する必要があります。

「大きな」変化は、データの正規化が実際に優れていると考えるすべての理由が、そのような組み込みドキュメントシステムの敵であることが判明したことです。 「結合」を回避することは常に良いことですが、「結合された」データの外観を持つ複雑なネストされた構造を作成しても、実際にはうまくいきません。

正規化であるとあなたが「考える」ことに対処するためのコストは、通常、最終的なストレージ内の複製および非正規化データの追加のストレージとメンテナンスを超えることになります。

上記のすべてのフォームが同じ結果セットを返すことにも注意してください。簡潔にするためのサンプルデータには単一のアイテムのみが含まれている、または多くても複数の価格ポイントがある場合、「平均」は依然として 1 であるという点で、かなり派生的です。 それがとにかくすべての値が何であるかだからです。しかし、これを説明する内容はすでに非常に長いので、実際には「例として」だけです：

{
        "_id" : ISODate("2018-11-01T00:00:00Z"),
        "prices" : [
                {
                        "price" : 1,
                        "quantity_sold" : 1
                }
        ],
        "quantity_sold" : 1
}
{
        "_id" : ISODate("2018-11-02T00:00:00Z"),
        "prices" : [
                {
                        "price" : 1,
                        "quantity_sold" : 1
                }
        ],
        "quantity_sold" : 1
}
{
        "_id" : ISODate("2018-11-03T00:00:00Z"),
        "prices" : [
                {
                        "price" : 1,
                        "quantity_sold" : 1
                },
                {
                        "price" : 2,
                        "quantity_sold" : 1
                }
        ],
        "quantity_sold" : 1
}