MapReduce

#ENCODING
import io
import sys
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-16')
#MONGO
from pymongo import MongoClient
client = MongoClient()
client.progzoo.authenticate('scott','tiger')
db = client['progzoo']
#PRETTY
import pprint
pp = pprint.PrettyPrinter(indent=4)

db.<collection>.map_reduce(
    map=<function>,
    reduce=<function>,
    out=<collection>
)

This example returns the population of all the continents.

In the map stage, emit(k,v) selects the fields to to turn into tuples, where k is the key and v is the value. The key will be the continents and the values will be the populations.
The reduce will sum all the values associated with each key. Finally the out specifies that the output is to be inline rather than a collection, allowing it to printed it to screen.

from bson.code import Code
pp.pprint(
    db.world.map_reduce(
        map=Code("function(){emit(this.continent, this.population)}"), 
        reduce=Code("""function(key, values){
                           var total = 0;
                           for (var i = 0; i < values.length; i++){
                               total += values[i];
                           }
                           return total;
                       }
                    """),
        out={"inline":1},
    )
)

query can be used to filter the input documents to map.

Find the GDP for each continent, but only include data from countries that start with the letter A or B.

from bson.code import Code
temp = db.world.map_reduce(
        query={"name": {"$regex":"^(A|B)"}},
        map=Code("function(){emit(this.continent, this.gdp)}"), 
        reduce=Code("""function(key, values){
                          var total = 0;
                          for (var i = 0; i < values.length; i++){
                              total += values[i];
                          }
                          return total;
                      }
                   """),
        out={"inline":1},
)

pp.pprint(
   temp["results"]
)

scope takes in a document:{} and lets you create global variables.

It's syntax is: scope={}.

Using scope, list all the countries with a higher population than Mexico.

mexico_data = db.world.find_one({"name":"Mexico"})
pp.pprint(mexico_data)

from bson.code import Code
temp = db.world.map_reduce(
        scope = {"MEXICO":mexico_data},
        map = Code("""function(){
                         if (this.population > MEXICO.population) emit(this.name, this.population)
                      }
                   """), 
        reduce=Code("function(key, values){return values}"),
        out={"inline":1},
)
pp.pprint(
   temp["results"]
)

sort and limit

Sort allows us to sort the input documents that are passed to map
Limit is self explanatory and also applies to the input documents that are passed to map

Get the five countries with the highest GDPs

from bson.code import Code
temp = db.world.map_reduce(
        query={"gdp":{"$ne":None}},
        sort={"gdp":-1},
        limit=5,
        map=Code("function(){emit(this.name, this.gdp)}"), 
        reduce=Code("function(key, values){return values}"),
        out={"inline":1},
)

pp.pprint(
   temp["results"]
)

finalize is an optional additional step that allows you to modify the data produce by reduce

Show the top 15 countries by population, then show their population as a percentage of Mexico's population.

mexico_data = db.world.find_one({"name":"Mexico"})

from bson.code import Code
temp = db.world.map_reduce(
        scope = {"MEXICO":mexico_data},
        query={"population":{"$ne":None}},
        sort={"population":-1},
        limit=15,
        map=Code("function(){emit(this.name, this.population)}"), 
        reduce=Code("function(key, values){return values}"),
        out={"inline":1},
        finalize=Code("""function(key, values){
                             return 100*(values/MEXICO.population)+"%"
                         }
                      """)
)

pp.pprint(
   temp["results"]
)

Rounding can also be performed by using JavaScript.

There are currently no round or floor aggregation operators. The lead product manager at MongoDB has created a blog post about rounding inside .aggregate() here

Show the top 15 countries by population, then show their population as a whole number percentage of Mexico's population.

mexico_data = db.world.find_one({"name":"Mexico"})

from bson.code import Code
temp = db.world.map_reduce(
        scope = {"MEXICO":mexico_data},
        query={"population":{"$ne":None}},
        sort={"population":-1},
        limit=15,
        map=Code("function(){emit(this.name, this.population)}"), 
        reduce=Code("function(key, values){return values}"),
        out={"inline":1},
        finalize=Code("""function(key, values){
                             return Math.round(100*(values/MEXICO.population))+"%"
                         }
                      """)
)

pp.pprint(
   temp["results"]
)