如何在 mongodB 中对数据进行分组/聚合以进行事件

Question

我有这种格式的 mongo 数据

[
  { 
     _id:ObjectId("5f71890730a4421699b1fbff"),
    timestamp: ISODate("2020-01-12T03:07:52Z"),
    running_fig: "circle",
  },
  {
    _id:ObjectId("5f718ac330a4421699b1fc15"),
    timestamp: ISODate("2020-01-12T03:08:48Z"),
    running_fig: "circle",
  },
  {
    _id:ObjectId("5f718ac330a4421699b1fc16"),
    timestamp: ISODate("2020-01-12T03:09:32Z"),
    running_fig: "rombous",
  },
  {
    _id:ObjectId("5f718ac330a4421699b1fc14"),
    timestamp: ISODate("2020-01-12T03:10:11Z"),
    running_fig: "triangle",
  },
  {
    _id:ObjectId("5f718ac330a4421699b1fc13"),
    timestamp: ISODate("2020-01-12T03:11:52Z"),
    running_fig: "triange",
  },
  {
    _id:ObjectId("5f718ac330a4421699b1fc12"),  
    timestamp: ISODate("2020-01-12T03:15:22Z"),
    running_fig: "circle",
  },
  {
     _id:ObjectId("5f718ac330a4421699b1fc1e"),
    timestamp: ISODate("2020-01-12T03:20:52Z"),
    running_fig: "circle",
  },
  
]

** 现在我想根据运行图时间制作一个事件图表，我希望以我给出的以下表格查询结果**

[
  {
running_fig:“circle”,
from: 2020-12-21T03: 07: 52Z,
to: 2020-12-21T03: 09: 48Z,
duration: 2 min.
  },
  {
running_fig:“rombous”,
from: 2020-12-21T03: 09: 48Z,
to: 2020-12-21T03: 10: 32Z,
duration: 1 min.
  },
  {
running_fig:“triangle”,
from: 2020-12-21T03: 10: 32Z,
to: 2020-12-21T03: 15: 22Z,
duration: 5 min.
  },
  {
running_fig:“circle”,
from: 2020-12-21T03: 15: 22Z,
to: 2020-12-21T03: 25: 52Z (current time),
duration: 10 min.
  }
]

所以我想要这种格式的结果数据，这样我就可以相应地创建一个图表，在这个数据中我的图表 running_fig 圈 start_time 是自己的时间戳，它的 end_time 将是下一个 running_fig 时间戳 在我的情况下，下一个菱形即将到来，因此 running_fig 圆圈的持续时间为 (3:09 -3:07) = 2 分钟，它们组合成单个数据显示我的预期结果。 任何人请帮我实现这个查询，提前谢谢

Answer 1

这是一个有点乏味的解决方案。

说明

1. 将数据放入数组中（假设您从传感器 1 获取数据）
2. 按时间戳排序
3. 检查数组中的前索引，如果前索引 running_fig = 当前索引 running_fig 从数组中删除此数据。
4. 添加下一个索引数据。
5. 如果下一个索引时间戳为空，则添加当前时间戳

代码

db.collection.aggregate([
  /** group by machine name*/
  {
    "$group": {
      "_id": "$sensor",
      docs: {
        $push: "$$ROOT"
      }
    },
    
  },
  /** sort by date to make event list*/
  {
    $sort: {
      "docs.timestamp": -1
    }
  },
  /** get pre data*/
  {
    $project: {
      docs: {
        /** transform the "docs" field*/
        $map: {
          /** into something*/
          input: {
            $range: [
              0,
              {
                $size: "$docs"
              }
            ]
          },
          /** an array from 0 to n - 1 where n is the number of documents*/
          as: "this",
          /** which shall be accessible using "$$this"*/
          in: {
            $mergeObjects: [
              /** we join two documents*/
              {
                $arrayElemAt: [
                  "$docs",
                  "$$this"
                ]
              },
              /** one is the nth document in our "docs" array*/
              {
                "pre_index": {
                  $cond: [
                    {
                      "$gte": [
                        {
                          "$subtract": [
                            "$$this",
                            1
                          ]
                        },
                        0
                      ]
                    },
                    {
                      "$arrayElemAt": [
                        "$docs",
                        {
                          "$subtract": [
                            "$$this",
                            1
                          ]
                        },
                        
                      ]
                    },
                    null
                  ]
                },
                index: "$$this"
              }/** and the second document is the one with our "index" field*/
              
            ]
          }
        }
      }
    }
  },
  /**remove same state data*/
  {
    $project: {
      _id: "$_id",
      noDuplicateArray: {
        $filter: {
          input: "$docs",
          as: "a",
          cond: {
            $ne: [
              "$$a.running_fig",
              "$$a.pre_index.running_fig"
            ]
          }
        }
      }
    }
  },
  /**add next data*/
  {
    $project: {
      docs: {
        /** transform the "docs" field*/
        $map: {
          /** into something*/
          input: {
            $range: [
              0,
              {
                $size: "$noDuplicateArray"
              }
            ]
          },
          /** an array from 0 to n - 1 where n is the number of documents*/
          as: "this",
          /** which shall be accessible using "$$this"*/
          in: {
            $mergeObjects: [
              /** we join two documents*/
              {
                $arrayElemAt: [
                  "$noDuplicateArray",
                  "$$this"
                ]
              },
              /** one is the nth document in our "docs" array*/
              {
                "to": {
                  "$arrayElemAt": [
                    "$noDuplicateArray",
                    {
                      $add: [
                        "$$this",
                        1
                      ]
                    },
                    
                  ]
                },
                index: "$$this"
              }/** and the second document is the one with our "index" field*/
              
            ]
          }
        }
      }
    }
  },
  {
    "$unwind": "$docs"
  },
  {
    "$project": {
      _id: "$docs._id",
      sensor: "$_id",
      from: "$docs.timestamp",
      to: {
        "$ifNull": [
          "$docs.to.timestamp",
          "$$NOW"
        ]
      },
      running_fig: "$docs.running_fig",
      duration: {
        $concat: [
          {
            $toString: {
              $round: [
                {
                  $divide: [
                    {
                      $subtract: [
                        {
                          "$ifNull": [
                            "$docs.to.timestamp",
                            "$$NOW"
                          ]
                        },
                        "$docs.timestamp"
                      ]
                    },
                    60000
                  ]
                },
                1
              ]
            }
          },
          " min"
        ]
      }
    }
  }
])

Mongo 游乐场：https://mongoplayground.net/p/CxHNdO6vLop

Answer 2

如前所述，您的示例数据与预期结果不符，因此很难理解逻辑。但是这个聚合应该显示它可能的方向。

使用$reduce的版本：

db.collection.aggregate([
   { $sort: { timestamp: -1 } },
   // Transform documents to array
   { $group: { _id: null, data: { $push: "$$ROOT" } } },
   // combine timestamp with previous timestamp
   {
      $set: {
         data: {
            $reduce: {
               input: "$data",
               initialValue: [],
               in: {
                  $concatArrays: ["$$value",
                     [{
                        running_fig: "$$this.running_fig",
                        from: "$$this.timestamp",
                        to: { $ifNull: [{ $last: "$$value.from" }, "$$NOW"] }
                     }]
                  ]
               }
            }
         }
      }
   },
   { $unwind: "$data" },
   { $sort: { "data.from": 1 } },
   { $group: { _id: null, data: { $push: "$$ROOT.data" } } },
   // find consequtive running_fig
   {
      $set: {
         data: {
            $reduce: {
               input: "$data",
               initialValue: [],
               in: {
                  $concatArrays: ["$$value",
                     [{
                        $cond: {
                           if: { $ne: [{ $last: "$$value.running_fig" }, "$$this.running_fig"] },
                           then: "$$this",
                           else: null
                        }
                     }]
                  ]
               }
            }
         }
      }
   },
   // remove null values from array
   { $set: { data: { $filter: { input: "$data", cond: { $ne: ["$$this", null] } } } } },
   { $unwind: "$data" }
   { $replaceRoot: { newRoot: "$data" } }
])

使用$map 和$range 的版本：

db.collection.aggregate([
   { $sort: { timestamp: 1 } },
   { $group: { _id: null, data: { $push: "$$ROOT" } } },
   {
      $set: {
         data: {
            $map: {
               input: { $range: [0, { $size: "$data" }] },
               as: "idx",
               in:
                  {
                     $cond: {
                        if: {
                           $ne: [
                              { $arrayElemAt: ["$data.running_fig", "$$idx"] },
                              { $arrayElemAt: ["$data.running_fig", { $add: ["$$idx", 1] }] }
                           ]
                        },
                        then: {
                           running_fig: { $arrayElemAt: ["$data.running_fig", "$$idx"] },
                           from: { $arrayElemAt: ["$data.timestamp", "$$idx"] },
                           to: { $ifNull: [{ $arrayElemAt: ["$data.timestamp", { $add: ["$$idx", 1] }] }, "$$NOW"] }
                        },
                        else: null
                     }
                  }
            }
         }
      }
   },
   { $set: { data: { $filter: { input: "$data", cond: { $ne: ["$$this", null] } } } } },
   { $unwind: "$data" },
   { $replaceRoot: { newRoot: "$data" } }
]);