查询mongoDB获取一些图表数据 - 我的管道似乎令人费解

时间：2017-06-19 10:09:53

标签： mongodb charts aggregation-framework chart.js

这是一个很长的问题。如果你打扰回答，我将非常感激。

我有一些时间序列数据，我试图查询以创建各种图表。数据格式并不是最简单的，但我认为我的聚合管道有点失控。我打算使用 charts.js 来可视化客户端上的数据。

我将在下面发布我的数据样本以及我的管道，并提供所需的输出。

我的问题分为两部分 - 回答任何一个问题都可以解决问题。

  1. charts.js是否接受每行数字数组以外的数据格式？这意味着我的管道可以尝试减少工作量。
  2. 我的管道并没有达到我需要的结果。 您能否推荐任何改动以从我的管道获得正确的结果？是否有更简单的方法来获得我想要的输出格式？

    3. 样本数据

    这是一个真实的数据样本 - 一个拥有一个Facebook帐户和一个Twitter帐户的品牌。 6月份的某些日期有一些数据。省略了许多空日和月字段。

    品牌

      [{
    "_id": "5943f427e7c11ac3ad3652b0",
    "name": "Brand1",
    "facebookAccounts": [
      "5943f427e7c11ac3ad3652ac",
    ],
    "twitterAccounts": [
        "5943f427e7c11ac3ad3652aa",
    ],
  }]

    FacebookAccounts 

    [
      {
        "_id" : "5943f427e7c11ac3ad3652ac"
        "name": "Brand 1 Name",
        "years": [
          {
            "date": "2017-01-01T00:00:00.000Z",
            "months": [
              {
                "date": "2017-06-01T00:00:00.000Z",
                "days": [
                  {
                    "date": "2017-06-16T00:00:00.000Z",
                    "likes": 904025,
                  },
                  {
                    "date": "2017-06-17T00:00:00.000Z",
                    "likes": null,
                  },
                  {
                    "date": "2017-06-18T00:00:00.000Z",
                    "likes": 904345,
                  },
                ],
              },
            ],
          }
        ]
      }
    ]

    Twitter帐户

    [
      {
        "_id": "5943f427e7c11ac3ad3652aa",
        "name": "Brand 1 Name",
        "vendorId": "twitterhandle",
        "years": [
          {
            "date": "2017-01-01T00:00:00.000Z",
            "months": [
              {
                "date": "2017-06-01T00:00:00.000Z",
                "days": [
                  {
                    "date": "2017-06-16T00:00:00.000Z",
                    "followers": 69390,
                  },
                  {
                    "date": "2017-06-17T00:00:00.000Z",
                    "followers": 69397,
                  {
                    "date": "2017-06-18T00:00:00.000Z",
                    "followers": 69428,
                  },
                  {
                    "date": "2017-06-19T00:00:00.000Z",
                    "followers": 69457,
                  },
                ]
              },
            ],
          }
        ]
      }
    ]

    查询

    对于这个例子，对于每个品牌，我想要在6月16日到6月18日之间每天记录一下facebook喜欢和推特粉丝。所以在这里，所需的格式是：

    {
  brand: Brand1,
  date: ["2017-06-16T00:00:00.000Z", "2017-06-17T00:00:00.000Z", "2017-06-18T00:00:00.000Z"],
  stat: [973415, 69397, 973773]
}

    管道

    由于人口众多，管道似乎更复杂，但我接受这种复杂性并且这是必要的。以下是步骤：

    db.getCollection('brands').aggregate([
{ $match: { _id: { $in: [ObjectId("5943f427e7c11ac3ad3652b0") ] } } },


// Unwind all relevant account types. Make one row per account
{ $project: { 
    accounts: { $setUnion: [ '$facebookAccounts', '$twitterAccounts' ] } ,
    name: '$name'
    }
 },
{ $unwind: '$accounts' },


// populate the accounts. 
// These transform the arrays of facebookAccount ObjectIds into the objects described above. 
{ $lookup: { from: 'facebookaccounts', localField: 'accounts', foreignField: '_id', as: 'facebookAccounts' } },
{ $lookup: { from: 'twitteraccounts', localField: 'accounts', foreignField: '_id', as: 'twitterAccounts' } },

// unwind the populated accounts. Back to one record per account.
{ $unwind: { path: '$facebookAccounts', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$twitterAccounts', preserveNullAndEmptyArrays: true } },


// unwind to the granularity we want. Here it is one record per day per account per brand.
{ $unwind: { path: '$facebookAccounts.years', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$facebookAccounts.years.months', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$facebookAccounts.years.months.days', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$facebookAccounts.years.months.days', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$twitterAccounts.years', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$twitterAccounts.years.months', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$twitterAccounts.years.months.days', preserveNullAndEmptyArrays: true } },
{ $unwind: { path: '$twitterAccounts.years.months.days', preserveNullAndEmptyArrays: true } },


// Filter each one between dates
{ $match: { $or: [
    { $and: [
        { 'facebookAccounts.years.months.days.date': { $gte: new Date('2017-06-16') } } ,
        { 'facebookAccounts.years.months.days.date': { $lte: new Date('2017-06-18') } } 
    ]},
    { $and: [
        { 'twitterAccounts.years.months.days.date': { $gte: new Date('2017-06-16') } } ,
        { 'twitterAccounts.years.months.days.date': { $lte: new Date('2017-06-18') } } 
     ]}
] }},    


// Build stats and date arrays for each account
{ $group: {
    _id: '$accounts',
    brandId: { $first: '$_id' },
    brandName: { $first: '$name' },
    stat: { 
         $push: { 
             $sum: { 
                 $add: [
                    { $ifNull: ['$facebookAccounts.years.months.days.likes', 0] },
                    { $ifNull: ['$twitterAccounts.years.months.days.followers', 0] }
                 ] 
             } 
         } 
     },
     date: { $push: { $ifNull: ['$facebookAccounts.years.months.days.date', '$twitterAccounts.years.months.days.date'] } } ,
}}


])

    这给了我输出格式

    [{
  _id: accountId, // facebook
  brandName: 'Brand1'
  date: ["2017-06-16T00:00:00.000Z", "2017-06-17T00:00:00.000Z", "2017-06-18T00:00:00.000Z"],
  stat: [904025, null, 904345]
},
{
  _id: accountId // twitter
  brandName: 'Brand1',
  date: ["2017-06-16T00:00:00.000Z", "2017-06-17T00:00:00.000Z", "2017-06-18T00:00:00.000Z"],
  stat: [69457, 69390, 69397]
}]

    所以我现在需要在我的stat属性上执行逐列添加。然后我被卡住了 - 我觉得应该有一个更加管道友好的方式来对这些进行求和而不是按列添加。< / p>

    注意我接受了人们所需的额外工作，并对此感到满意。大多数重复都是以编程方式完成的。

    如果你已经走到这一步，谢谢你。

1 个答案:

答案 0 :(得分：1)

我可以修剪掉很多这样的东西并保持它与MongoDB 3.2（你必须至少使用preserveNullAndEmptyArrays）可用的操作符兼容，只需几个简单的操作。主要是通过简单地在$lookup,之后立即加入数组，这是最好的地方：

短优化

db.brands.aggregate([
  { "$lookup": {
    "from": "facebookaccounts",
    "localField": "facebookAccounts",
    "foreignField": "_id",
    "as": "facebookAccounts"
  }},
  { "$lookup": {
    "from": "twitteraccounts",
    "localField": "twitterAccounts",
    "foreignField": "_id",
    "as": "twitterAccounts"
  }},
  { "$project": {
    "name": 1,
    "all": {
      "$concatArrays": [ "$facebookAccounts", "$twitterAccounts" ]
    }
  }},
  { "$match": {
    "all.years.months.days.date": {
      "$gte": new Date("2017-06-16"), "$lte": new Date("2017-06-18")
    }
  }},
  { "$unwind": "$all" },
  { "$unwind": "$all.years" },
  { "$unwind": "$all.years.months" },
  { "$unwind": "$all.years.months.days" },
  { "$match": {
    "all.years.months.days.date": {
      "$gte": new Date("2017-06-16"), "$lte": new Date("2017-06-18")
    }
  }},
  { "$group": {
    "_id": {
      "brand": "$name",
      "date": "$all.years.months.days.date"
    },
    "total": { 
      "$sum": { 
        "$sum": [
          { "$ifNull": [ "$all.years.months.days.likes", 0 ] },
          { "$ifNull": [ "$all.years.months.days.followers", 0 ] }
        ]
      }
    }
  }},
  { "$sort": { "_id": 1 } },
  { "$group": {
    "_id":  "$_id.brand",
    "date": { "$push": "$_id.date" },
    "stat": { "$push": "$total" }
  }}
])

这给出了结果：

{
        "_id" : "Brand1",
        "date" : [
                ISODate("2017-06-16T00:00:00Z"),
                ISODate("2017-06-17T00:00:00Z"),
                ISODate("2017-06-18T00:00:00Z")
        ],
        "stat" : [
                973415,
                69397,
                973773
        ]
}

使用MongoDB 3.4，我们可能会加快速度，而且＃34;更多的是通过过滤数组并在最终$unwind之前将它们分解为跨文档，或者甚至不担心如果＆＃34; name＆＃34;来自＆＃34;品牌＆＃34;是独特的。管道操作压缩阵列＆＃34;到位＆＃34;虽然代码非常繁琐，但如果一个小小的＆＃34;性能更好。

你似乎正在做这个＆＃34;每个品牌＆＃34;或者对于一个小样本，所以它可能没什么影响。

至于chartjs数据格式，我似乎无法在这里得到我认为与数组格式不同的数据格式，但这又应该没有什么影响。

我看到的主要观点是，我们可以轻松地摆脱以前的分离＆＃34; facebook＆＃34;和＆＃34; twitter＆＃34;数据，简单地按日期汇总将所有数据一起移动到＆＃34;之前＆＃34;数组是构造的。

然后，最后一点不再需要进一步的＆＃34;复杂的＆＃34;尝试＆＃34;合并＆＃34;这两个文件和阵列产生了。

替代优化

作为一种替代方法，实际上这不会在文档中聚合，那么您基本上可以执行＆＃34;过滤＆＃34;在数组上，然后简单地对客户端代码中的结果进行求和和重新整形。

db.brands.aggregate([
  { "$lookup": {
    "from": "facebookaccounts",
    "localField": "facebookAccounts",
    "foreignField": "_id",
    "as": "facebookAccounts"
  }},
  { "$lookup": {
    "from": "twitteraccounts",
    "localField": "twitterAccounts",
    "foreignField": "_id",
    "as": "twitterAccounts"
  }},
  { "$project": {
    "name": 1,
    "all": {
      "$map": {
        "input": { "$concatArrays": [ "$facebookAccounts", "$twitterAccounts" ] },
        "as": "all",
        "in": {
          "years": {
            "$map": {
              "input": "$$all.years",
              "as": "year",
              "in": {
                "months": {
                  "$map": {
                    "input": "$$year.months",
                    "as": "month",
                    "in": {
                      "days": {
                        "$filter": {
                          "input": "$$month.days",
                          "as": "day",
                          "cond": {
                            "$and": [
                              { "$gte": [ "$$day.date", new Date("2017-06-16") ] },
                              { "$lte": [ "$$day.date", new Date("2017-06-18") ] }
                            ]
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }}
]).map(doc => {
  doc.all = [].concat.apply([],[].concat.apply([],[].concat.apply([],doc.all.map(d => d.years)).map(d => d.months)).map(d => d.days));
  doc.all = doc.all.reduce((a,b) => {
    if ( a.findIndex( d => d.date.valueOf() == b.date.valueOf() ) != -1 ) {
      a[a.findIndex( d => d.date.valueOf() == b.date.valueOf() )].stat += (b.hasOwnProperty('likes')) ? (b.likes || 0) : (b.followers || 0);
    } else {
      a = a.concat([{ date: b.date, stat: (b.hasOwnProperty('likes')) ? (b.likes || 0) : (b.followers || 0) }]);
    }
    return a;
  },[]);

  doc.date = doc.all.map(d => d.date);
  doc.stat = doc.all.map(d => d.stat);
  delete doc.all;
  return doc;
})

这确实留下了所有需要的东西＆＃34;发生在服务器上，服务器上。然后，这是一个相当简单的任务，以平稳＆＃34;数组和过程到＆＃34;总结＆＃34;并重塑它。这意味着服务器上的负载会减少，并且每个文档返回的数据实际上并没有那么多。

当然得到相同的结果：

[
        {
                "_id" : ObjectId("5943f427e7c11ac3ad3652b0"),
                "name" : "Brand1",
                "date" : [
                        ISODate("2017-06-16T00:00:00Z"),
                        ISODate("2017-06-17T00:00:00Z"),
                        ISODate("2017-06-18T00:00:00Z")
                ],
                "stat" : [
                        973415,
                        69397,
                        973773
                ]
        }
]

致力于饮食

您真正遇到的最大问题是多个集合和重度嵌套的文档。这些都没有给你带来任何好处，并且会有更大的结果导致真正的性能问题。

特别是嵌套是完全没有必要的，也不是很容易维护，因为更新＆＃34;你有嵌套数组的地方。请参阅位置$运算符文档以及有关此内容的许多帖子。

相反，你真的想要一个包含所有这些＆＃34;天＆＃34;其中的条目。您始终可以轻松地使用该源进行查询以及聚合，它应该如下所示：

{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac38097"),
        "date" : ISODate("2017-06-16T00:00:00Z"),
        "likes" : 904025,
        "__t" : "Facebook",
        "account" : ObjectId("5943f427e7c11ac3ad3652ac")
}
{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac38098"),
        "date" : ISODate("2017-06-17T00:00:00Z"),
        "likes" : null,
        "__t" : "Facebook",
        "account" : ObjectId("5943f427e7c11ac3ad3652ac")
}
{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac38099"),
        "date" : ISODate("2017-06-18T00:00:00Z"),
        "likes" : 904345,
        "__t" : "Facebook",
        "account" : ObjectId("5943f427e7c11ac3ad3652ac")
}
{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac3809a"),
        "date" : ISODate("2017-06-16T00:00:00Z"),
        "followers" : 69390,
        "__t" : "Twitter",
        "account" : ObjectId("5943f427e7c11ac3ad3652aa")
}
{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac3809b"),
        "date" : ISODate("2017-06-17T00:00:00Z"),
        "followers" : 69397,
        "__t" : "Twitter",
        "account" : ObjectId("5943f427e7c11ac3ad3652aa")
}
{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac3809c"),
        "date" : ISODate("2017-06-18T00:00:00Z"),
        "followers" : 69428,
        "__t" : "Twitter",
        "account" : ObjectId("5943f427e7c11ac3ad3652aa")
}
{
        "_id" : ObjectId("5948cd5cd6eb0b7d6ac3809d"),
        "date" : ISODate("2017-06-19T00:00:00Z"),
        "followers" : 69457,
        "__t" : "Twitter",
        "account" : ObjectId("5943f427e7c11ac3ad3652aa")
}

结合品牌系列中引用的那些：

{
        "_id" : ObjectId("5943f427e7c11ac3ad3652b0"),
        "name" : "Brand1",
        "accounts" : [
                ObjectId("5943f427e7c11ac3ad3652ac"),
                ObjectId("5943f427e7c11ac3ad3652aa")
        ]
}

然后你只需这样聚合：

db.brands.aggregate([
  { "$lookup": {
    "from": "social",
    "localField": "accounts",
    "foreignField": "account",
    "as": "accounts"
  }},
  { "$unwind": "$accounts" },
  { "$match": {
    "accounts.date": {
      "$gte": new Date("2017-06-16"), "$lte": new Date("2017-06-18")
    }
  }},
  { "$group": {
    "_id": {
      "brand": "$name",
      "date": "$accounts.date"
    },
    "stat": {
      "$sum": {
        "$sum": [
          { "$ifNull": [ "$accounts.likes", 0 ] },
          { "$ifNull": [ "$accounts.followers", 0 ] }
        ]
      }
    }
  }},
  { "$sort": { "_id": 1 } },
  { "$group": {
    "_id": "$_id.brand",
    "date": { "$push": "$_id.date" },
    "stat": { "$push": "$stat" }
  }}
])

这实际上是您可以做的最有效的事情，而且主要是因为服务器上实际发生的事情。我们需要看看＆＃34;解释＆＃34;输出以查看管道发生了什么：

{
    "$lookup" : {
      "from" : "social",
      "as" : "accounts",
      "localField" : "accounts",
      "foreignField" : "account",
        "unwinding" : {
          "preserveNullAndEmptyArrays" : false
        },
        "matching" : {
           "$and" : [
             {
               "date" : {
                 "$gte" : ISODate("2017-06-16T00:00:00Z")
               }
             },
             {
               "date" : {
                 "$lte" : ISODate("2017-06-18T00:00:00Z")
               }
             }
           ]
        }
    }
}

当您发送$lookup - ＆gt;时会发生这种情况。 $unwind - ＆gt; $match到服务器，因为后两个阶段是＆＃34;悬挂＆＃34;进入$lookup本身。这减少了实际＆＃34;查询中的结果。在要加入的集合上运行。

如果没有这个序列，那么$lookup可能会吸引大量数据＆＃34;没有约束，并且在大多数正常负载下会破坏16MB的BSON限制。

因此，不仅改变形式的过程更简单，它实际上＆＃34;缩放＆＃34;目前的结构不会。这是你应该认真考虑的事情。

相关问题
最新问题