Htykuut

TL;DR

Is there a mongo array operator that can detect if an array contains at least one entry that's larger than the previous? eg

 [1,1,1,2,2,2] -> true

 [1,1,1,0,0,0] -> false

We're using mongo to track network activity, where the relative field packets is the running sum of activity over time. This is best illustrated by example:

[0,0,0,0] -> no packets

[5,5,5,5] -> 5 packets continuous

[0,0,5,5] -> No packets and then a single event of 5

[0,0,5,10] -> two events, each increasing total packets by 5

Our goal is to identify records where there has been activity (ie. the number of packets changes). At first, this seems straightforward using the $addToSet operator and then taking sets where count > 1. EG:

[0,0,0,0] -> [0] -> false

[5,5,5,5] -> [5] -> false

[0,0,5,5] -> [0,5] -> true

[0,0,5,10] -> [0,5,10] -> true

However, we then learned of an additional constraint. When activity goes to 0, that is considered a reset and should not count as activity eg,

[5,5,0,0] -> false (a reset event)

[0,0,5,5] -> true (a network event)

[5,0,5,0] -> true (a reset event followed be a network event followed by a reset - but because there was a network event this is true)

Activity will ALWAYS increase except for when going to zero (ie [5,5,0,0] is possible but [5,5,4,4] is not).

Thus, we need to find out if the data contains a single entry whose value is larger than the prior. Is there a mongo operator that can sweep through an array and return true if any element is larger than its prior?

Thanks

You can take advantage of $reduce operator to scan the array and keep previous value to compare it with current one.

For sample data like:

db.col.save({ data: [1,1,1,2,2,2] })

db.col.save({ data: [1,1,1,0,0,0] })

you can run:

db.col.aggregate([

    {

        $project: {

            result: {

                $reduce: {

                    input: "$data",

                    initialValue: {

                        previous: { $arrayElemAt: [ "$data", 0 ] },

                        decision: false

                    },

                    in: {

                        previous: "$$this",

                        decision: {

                            $or: [

                                "$$value.decision",

                                { $gt: [ "$$this", "$$value.previous" ] }

                            ]

                        }

                    }

                }

            }

        }

    },

    {

        $project: {

            _id: 0,

            result: "$result.decision"

        }

    }

])

outputs:

{ "result" : true }

{ "result" : false }

Basically you are traversing with $reduce using current and previous values and comparing

db.collection.aggregate([

  { "$addFields": {

    "result": {

      "$reduce": {

        "input": {

          "$range": [ 1, { "$size": "$source_array" } ]

        },

        "initialValue": false,

        "in": {

          "$or": [

            "$$value",

            { "$gt": [

              { "$arrayElemAt": [ "$source_array", "$$this" ]},

              { "$arrayElemAt": [

                "$source_array",

                { "$subtract": [ "$$this", 1 ] }

              ]}

            ]}

          ]

        }

      }

    }

  }}

]);

Given data like:

{ "source_array" : [ 0, 0, 0, 0 ], "expect" : false }

{ "source_array" : [ 5, 5, 5, 5 ], "expect" : false }

{ "source_array" : [ 0, 0, 5, 5 ], "expect" : true }

{ "source_array" : [ 5, 5, 0, 0 ], "expect" : false }

{ "source_array" : [ 5, 0, 5, 0 ], "expect" : true }

{ "source_array" : [ 5, 0, 5, 5 ], "expect" : true }

{ "source_array" : [ 5, 5, 4, 4 ], "expect" : false }

Returns:

[

  {

    "source_array": [

      0,

      0,

      0,

      0

    ],

    "expect": false,

    "result": false

  },

  {

    "source_array": [

      5,

      5,

      5,

      5

    ],

    "expect": false,

    "result": false

  },

  {

    "source_array": [

      0,

      0,

      5,

      5

    ],

    "expect": true,

    "result": true

  },

  {

    "source_array": [

      5,

      5,

      0,

      0

    ],

    "expect": false,

    "result": false

  },

  {

    "source_array": [

      5,

      0,

      5,

      0

    ],

    "expect": true,

    "result": true

  },

  {

    "source_array": [

      5,

      0,

      5,

      5

    ],

    "expect": true,

    "result": true

  },

  {

    "source_array": [

      5,

      5,

      4,

      4

    ],

    "expect": false,

    "result": false

  }

]

All this is done by using $arrayElemAt with the index values from the array. Using $range to generate the indexes from 1..length and comparing n with n-1 for current and previous respectively.

The logic says that no further comparison is needed when a true result is obtained.