Discover the longest data length within the key values of the collection

Question

Discover the longest data length within the key values of the collection

{
  "_id" : ObjectId("59786a62a96166007d7e364dsadasfafsdfsdgdfgfd"),
  "someotherdata" : {
    "place1" : "lwekjfrhweriufesdfwergfwr",
    "place2" : "sgfertgryrctshyctrhysdthc ",
    "place3" : "sdfsdgfrdgfvk",
    "place4" : "asdfkjaseeeeeeeeeeeeeeeeefjnhwklegvds."
  }
}

I have a vast array of similar records in my collection. My task is to sift through all the someotherdata entries and perform the following actions:

Verify if specific fields are present (for example, place1 might be available in certain records while place4 may not)
Determine the longest string record among them

The desired output should display the character count for the lengthiest entry as shown below:

{   
  place1: 123,
  place2: 12,
  place3: 17
  place4: 445
}

Given that I am utilizing Mongodb version 3.2.9, which lacks the latest aggregate functions, my approach involves leveraging the Mongodb shell.

EDIT: To clarify further, the goal is to identify the longest record across all documents in the collection. Even though there could be thousands of documents, the result should showcase the longest string length for each field throughout the entire collection.

javascript mongodb mapreduce

Answer 1

Answer №1

To reduce down to the largest values for each key, you can use the .mapReduce() method:

db.collection.mapReduce(
  function() {
    emit(null,
      Object.keys(this.someotherdata).map(k => ({ [k]: this.someotherdata[k].length }))
       .reduce((acc,curr) => Object.assign(acc,curr),{})
    );
  },
  function(key,values) {
    var result = {};
    values.forEach(value => {
      Object.keys(value).forEach(k => {
        if (!result.hasOwnProperty(k))
          result[k] = 0;
        if ( value[k] > result[k] )
          result[k] = value[k];
      });
    });
    return result;
  },
  { 
    "out": { "inline": 1 },
    "query": { "someotherdata": { "$exists": true } }
  }
)

This process emits the "length" of each key in the sub-document path for every document. In the reduction phase, only the largest "length" for each key is returned.

In mapReduce, maintaining the same structure in both emit and reduce functions is important. It helps with handling a large number of documents by reducing them in gradual batches.

The output for the sample document provided in the question will be like this. The results represent the maximum values across all the documents in the collection, especially when dealing with more entries:

   {
        "_id" : null,
        "value" : {
            "place1" : 25.0,
            "place2" : 26.0,
            "place3" : 13.0,
            "place4" : 38.0
        }
    }

If using MongoDB 3.4 or later versions, you can achieve the same outcome using the .aggregate() method:

db.collection.aggregate([
  { "$match": { "someotherdata": { "$exists": true } } },
  { "$project": {
    "_id": 0,
    "someotherdata": {
      "$map": { 
        "input": { "$objectToArray": "$someotherdata" },
        "as": "s",
        "in": { "k": "$$s.k", "v": { "$strLenCP": "$$s.v" } }
      }
    }
  }},
  { "$unwind": "$someotherdata" },
  { "$group": {
     "_id": "$someotherdata.k",
     "v": { "$max": "$someotherdata.v" }    
  }},
  { "$sort": { "_id": 1 } },
  { "$group": {
    "_id": null,
    "data": {
      "$push": { "k": "$_id", "v": "$v" }
    }    
  }},
  { "$replaceRoot": {
    "newRoot": {
      "$arrayToObject": "$data"   
    } 
  }}
])

This code snippet produces similar results:

{
    "place1" : 25,
    "place2" : 26,
    "place3" : 13,
    "place4" : 38
}

Answer 2

To reduce down to the largest values for each key, you can use the .mapReduce() method:

db.collection.mapReduce(
  function() {
    emit(null,
      Object.keys(this.someotherdata).map(k => ({ [k]: this.someotherdata[k].length }))
       .reduce((acc,curr) => Object.assign(acc,curr),{})
    );
  },
  function(key,values) {
    var result = {};
    values.forEach(value => {
      Object.keys(value).forEach(k => {
        if (!result.hasOwnProperty(k))
          result[k] = 0;
        if ( value[k] > result[k] )
          result[k] = value[k];
      });
    });
    return result;
  },
  { 
    "out": { "inline": 1 },
    "query": { "someotherdata": { "$exists": true } }
  }
)

This process emits the "length" of each key in the sub-document path for every document. In the reduction phase, only the largest "length" for each key is returned.

In mapReduce, maintaining the same structure in both emit and reduce functions is important. It helps with handling a large number of documents by reducing them in gradual batches.

The output for the sample document provided in the question will be like this. The results represent the maximum values across all the documents in the collection, especially when dealing with more entries:

   {
        "_id" : null,
        "value" : {
            "place1" : 25.0,
            "place2" : 26.0,
            "place3" : 13.0,
            "place4" : 38.0
        }
    }

If using MongoDB 3.4 or later versions, you can achieve the same outcome using the .aggregate() method:

db.collection.aggregate([
  { "$match": { "someotherdata": { "$exists": true } } },
  { "$project": {
    "_id": 0,
    "someotherdata": {
      "$map": { 
        "input": { "$objectToArray": "$someotherdata" },
        "as": "s",
        "in": { "k": "$$s.k", "v": { "$strLenCP": "$$s.v" } }
      }
    }
  }},
  { "$unwind": "$someotherdata" },
  { "$group": {
     "_id": "$someotherdata.k",
     "v": { "$max": "$someotherdata.v" }    
  }},
  { "$sort": { "_id": 1 } },
  { "$group": {
    "_id": null,
    "data": {
      "$push": { "k": "$_id", "v": "$v" }
    }    
  }},
  { "$replaceRoot": {
    "newRoot": {
      "$arrayToObject": "$data"   
    } 
  }}
])

This code snippet produces similar results:

{
    "place1" : 25,
    "place2" : 26,
    "place3" : 13,
    "place4" : 38
}

Answer 3

Answer №2

Utilize cursor.forEach to cycle through the dataset. Maintain a record of the highest numerical values (initially set at -1, then updated when a higher value is discovered). Display these values using either print() or printjson()

Answer 4

Utilize cursor.forEach to cycle through the dataset. Maintain a record of the highest numerical values (initially set at -1, then updated when a higher value is discovered). Display these values using either print() or printjson()

Discover the longest data length within the key values of the collection

Answer №1

Answer №2

Similar questions

Using a background image in a React component

Navigating to new location following the final iteration in a loop of asynchronous updates in MongoDB

Issues presenting themselves with Material UI Icons

Is there a way to remove a row when fetching data in ReactJS?

Edit an unspecified property within a Mongoose schema and then proceed to save the changes

Aggregation in Mongodb - the power of processing data efficiently

using localStorage to store multiple keys

Vue's animation happens without any delay or duration

Unable to establish a hyperlink to specific section of page using MUI 5 Drawer

Execute a jQuery function every time the class of the parent container div changes

Mastering browser console manipulation using a script

What are the steps to fetch JSON data from a different domain server using AJAX?

Using a global variable in Vue and noticing that it does not update computed variables?

Using Framework7 and AngularJS to efficiently load pages

Switching variables using jQuery tabs

Conflicting Angular components: Sorting tables and dragging/dropping table rows

Adjust the color of a selected edge in Three.js

Transform the text area in preparation for a GET request

Encountering an issue with vue-mention where the error message states that "this.$scopedSlots.default is

Creating two separate canvas elements with their own unique JavaScript code can be achieved by first defining each