Как я могу агрегировать даты, отформатированные как startOf минута в MongoDB? [Дубликат]

Мне нравится другой ответ здесь, и в основном для использования математики даты вместо операторов даты агрегации, которые, хотя полезно, также могут быть немного неясными.

Единственное, что я хочу добавить здесь, это то, что вы также можете вернуть объект Date из структуры агрегации таким подходом, в отличие от «числовой» метки времени. Это лишь небольшая дополнительная математика на тех же принципах, используя $add :

db.collection.aggregate([
    { "$group": {
        "_id": {
            "$add": [
                { "$subtract": [
                    { "$subtract": [ "$current_date", new Date(0) ] },
                    { "$mod": [ 
                        { "$subtract": [ "$current_date", new Date(0) ] },
                        1000 * 60 * 15
                    ]}
                ] },
                new Date(0)
            ]
        },
        "count": { "$sum": 1 }
    }}
])

Контексты Date(0) в JavaScript здесь представляют ту же самую «эпоху» в более короткая форма, так как 0 миллисекунд от эпохи - эпоха. Но главное, что когда «добавление» к другому объекту даты BSON выполняется с числовым идентификатором, тогда обратное к описанному условию истинно, и конечный результат на самом деле теперь является Date.

Все драйверы вернут родной тип Date на свой язык с помощью этого подхода.

Существует несколько способов сделать это.

Первый из них - Операторы агрегирования даты , которые позволяют вам анализировать значения «даты» в документах. В частности, для «группировки» в качестве основного намерения:

db.collection.aggregate([
  { "$group": {
    "_id": {
      "year": { "$year": "$created_at" },
      "dayOfYear": { "$dayOfYear": "$created_at" },
      "hour": { "$hour": "$created_at" },
      "interval": {
        "$subtract": [ 
          { "$minute": "$created_at" },
          { "$mod": [{ "$minute": "$created_at"}, 15] }
        ]
      }
    }},
    "count": { "$sum": 1 }
  }}
])

Второй способ заключается в использовании небольшого трюка, когда объект даты вычитается (или другая прямая математическая операция) из другого объекта даты, тогда результатом является числовое значение, представляющее миллисекунду времени между двумя объектами. Таким образом, просто используя дату эпохи, вы получаете представление в миллисекундах эпохи. Затем используйте математику даты для интервала:

db.collection.aggregate([
    { "$group": {
        "_id": {
            "$subtract": [
                { "$subtract": [ "$created_at", new Date("1970-01-01") ] },
                { "$mod": [ 
                    { "$subtract": [ "$created_at", new Date("1970-01-01") ] },
                    1000 * 60 * 15
                ]}
            ]
        },
        "count": { "$sum": 1 }
    }}
])

. Это зависит от того, какой формат вывода вы хотите для интервала группировки. Оба они в основном представляют одно и то же и имеют достаточные данные для повторной конструкции в качестве объекта «даты» в вашем коде.

Вы можете поместить все что угодно в разделе «оператор группировки» после группировки _id. Я просто использую основной пример «подсчета» вместо любого реального заявления от себя относительно того, что вы действительно хотите сделать.

MongoDB 4.x и Upwards

Были некоторые дополнения к операторам агрегирования даты с момента написания оригинала, но из MongoDB 4.0 будет фактическое «реальное литье типов» в отличие от основных математических приемов, сделанных здесь с преобразованием даты BSON.

Для Например, мы можем использовать $toLong и $toDate в качестве новых помощников:

db.collection.aggregate([
  { "$group": {
    "_id": {
      "$toDate": {
        "$subtract": [
          { "$toLong": "$created_at" },
          { "$mod": [ { "$toLong": "$created_at" }, 1000 * 60 * 15 ] }
        ]
      }
    },
    "count": { "$sum": 1 }
  }}
])

Это немного короче и не требует определения внешняя BSON Дата для значения «epoch» как константа при определении конвейера, поэтому она вполне согласуется для всех языковых реализаций.

Это всего лишь два из «вспомогательных» методов преобразования типов, которые все привязываются к метод $convert , который является «более длинной» формой реализации, позволяющей выполнять пользовательскую обработку на null или ошибку в преобразовании.

Это возможно даже при таком литье получить информацию о Date из ObjectId первичного ключа, так как это было бы надежным источником даты создания:

db.collection.aggregate([
  { "$group": {
    "_id": {
      "$toDate": {
        "$subtract": [
          { "$toLong": { "$toDate": "$_id" }  },
          { "$mod": [ { "$toLong": { "$toDate": "_id" } }, 1000 * 60 * 15 ] }
        ]
      }
    },
    "count": { "$sum": 1 }
  }}
])

Таким образом, «типы литья» с таким преобразованием могут быть довольно мощным инструментом.

Еще один полезный способ:

db.collection.aggregate([
  {$group: {
    _id: { 
      overallTime: { 
        $dateToString: { format: "%Y-%m-%dT%H", date: "$created_at" } 
      },
      interval: { $trunc: { $divide: [{ $minute: "$created_at" }, 15 ]}}
    },
  }},
])

И проще в секундах min , hour , day :

var format = "%Y-%m-%dT%H:%M"; // 1 min
var format = "%Y-%m-%dT%H"; // 1 hour
var format = "%Y-%m-%d"; // 1 day

db.collection.aggregate([
  {$group: {
    _id: { $dateToString: { format: format, date: "$created_at" } },
  }},
])

Немного красивее для mongodb.version () 3.0

db.collection.aggregate([
    {$match: {created_at:{$exists:1}}},
    {$group: {
        _id: {$add:[
            {$dayOfYear: "$created_at" },
            {$multiply: [{$year: "$created_at"}, 1000]}
        ]},
        count: {$sum: 1 }
    }},
    {$sort:{_id:-1}}
])