FIND basics

2015-07-30T15:42:01Z

40082593:

FIND basics

2015-07-30T15:34:51Z

40082593:

FIND basics

2015-07-30T15:34:06Z

40082593:

2015-07-29T13:54:05Z

40082593:

<pre class="setup">
#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)
</pre>

==Working with the <code>world</code> collection of countries==
<p>This tutorial introduces NoSQL using MonogDB and PyMongo under Python3.4. We will be using the <code>find()</code> command and comparison functions on the collection '''world''' which contains details of around 250 countries of the world:</p>
[[FIND examples]] are available.

<div class=q data-lang="py3">
Observe the result of running a simple mongoDB command.
<p class=strong>FIND name, continent, population FROM world</p>
<pre class=def>
pp.pprint(list(
db.world.find({},{
"name":1,
"continent":1,
"population":1,
"_id":0
})
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({},{"name":1,"continent":1,"population":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name for the countries that have a population of at least 200 million. 200 million is 200000000, there are eight zeros.</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"population":{"$gt":200000000}},
{"name":1, "_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"population":{"$gt":200000000}},{"name":1, "_id":0})))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Give the name and the per capita GDP for those countries with a population of at least 200 million.</p>
[[AGGREGATE examples]] are available.
<div class="hint" title="How to calculate per capita GDP">per capita GDP is the GDP divided by the population GDP/population</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"population":{"$gt":200000000}}},
{"$project":{"name":1, "gdp/population":{"$divide":["$gdp","$population"]}, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gt":200000000}}},{"$project":{"name":1, "gdp/population":{"$divide":["$gdp","$population"]}, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name and population in millions for the countries of the continent 'South America'. Divide the population by 1000000 to get population in millions.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"continent":{"$eq":"South America"}}},
{"$project":{"name":1, "population in millions":{"$divide":["$population",1000000]}, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"name":1, "population in millions":{"$divide":["$population",1000000]}, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name and population for France, Germany, Italy</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":{"$in":["France", "Germany", "Italy"]}}},
{"$project":{"name":1, "population":1, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":["France", "Germany", "Italy"]}}},{"$project":{"name":1, "population":1, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the countries which have a name that includes the word 'United'</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"name":{"$regex":"\s?United\s?"}},
{"name":1, "_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"name":{"$regex":"\s?United\s?"}},{"name":1, "_id":0})))
</div>
</div>

<div class=q data-lang="py3">
Two ways to be big: A country is big if it has an area of more than 3 million sq km or it has a population of more than 250 million.
<p class=strong>Show the countries that are big by area or big by population. Show name, population and area</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"$or":[{"area":{"$gt":3000000}},{"population":{"$gt":250000000}}]},
{"name":1,"population":1,"area":1,"_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"$or":[{"area":{"$gt":3000000}},{"population":{"$gt":250000000}}]},{"name":1,"population":1,"area":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
USA and China are big in population <span class=strong>and</span> big by area. Exclude these countries.
<p class=strong>Show the countries that are big by area or big by population but not both. Show name, population and area.</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"$or":[
{"area":{"$gt":3000000},"population":{"$lt":250000000}},
{"area":{"$lt":3000000},"population":{"$gt":250000000}}
]},
{"name":1,"population":1,"area":1,"_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"$or":[{"area":{"$gt":3000000},"population":{"$lt":250000000}},{"area":{"$lt":3000000},"population":{"$gt":250000000}}]}, {"name":1,"population":1,"area":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
Show the name and population in millions and the GDP in billions for the countries of the continent 'South America'. Use the ROUND function to show the values to two decimal places.<br />
Introducing [[MapReduce]]
<div class=hint title='Millions and billions'>Divide by 1000000 (6 zeros) for millions. Divide by 1000000000 (9 zeros) for billions.</div>
<p class=strong>For South America show population in millions and GDP in billions to 2 decimal places.</p>
<pre class=def>
from bson.code import Code
temp = db.world.map_reduce(
query={"continent":"South America"},
map=Code("function(){emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),
reduce=Code("""function(key, values){ return values} """),
finalize=Code("""function(k, v){
return {
'pop in millions':Math.round(v['pop']*1000000)/1000000,
'gdp in billions':Math.round(v['gdp']*1000000000)/1000000000
};
}
"""),
out={"inline":1}
)
pp.pprint(temp['results']);
</pre>
<div class=ans>
from bson.code import Code
temp = db.world.map_reduce(query={"continent":"South America"},map=Code("function(){emit(this.name, {'gdp':this.gdp,'pop':this.population});}"),reduce=Code("""function(key, values){ return values} """),finalize=Code("""function(k, v){return {'pop in millions':Math.round(v['pop']*1000000)/1000000,'gdp in billions':Math.round(v['gdp']*1000000000)/1000000000};}"""),out={"inline":1})
pp.pprint(temp['results']);
</div>
</div>

<div class=q data-lang="py3">
Show the per-capita GDP for those countries with a GDP of at least one trillion (1000000000000; that is 12 zeros). Round this value to the nearest 1000.
<p class=strong>Show per-capita GDP for the trillion dollar countries to the nearest $1000.</p>
<pre class=def>
from bson.code import Code
temp = db.world.map_reduce(
map=Code("function(){if(this.gdp > 1000000000000)emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),
reduce=Code("""function(key, values){ return values} """),
finalize=Code("""function(k, v){
return {'per-capita GDP':Math.round((v['gdp']/v['pop'])/1000)*1000};
}
"""),
out={"inline":1}
)
pp.pprint(temp['results']);
</pre>
<div class=ans>
from bson.code import Code
temp = db.world.map_reduce(map=Code("function(){if(this.gdp > 1000000000000)emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),reduce=Code("""function(key, values){ return values} """),finalize=Code("""function(k, v){
return {'per-capita GDP':Math.round((v['gdp']/v['pop'])/1000)*1000};}"""),out={"inline":1})
pp.pprint(temp['results']);
</div>
</div>

== Harder Questions ==

<div class=q data-lang="py3">
Find out more about <code>$cond</code> at [[AGGREGATE_examples]]
<p class=strong>Show the name and the continent - but substitute Australasia for Oceania - for countries beginning with N.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":{"$regex":"^N"}}},
{"$project":{
"name":1,
"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]},
"_id":0
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
    substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
    substitute <b>America</b> - for each country in <b>North America</b> or <b>South America</b> or <b>Caribbean</b>.<br/><br/>Only show countries beginning with <b>A</b> or <b>B</b><br/>
If you're struggling you may want to experiment with <code>$and</code>,<code>$or</code>, etc.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</div>
</div>

<div class=q data-lang="py3">
Put the continents right...
<br/><br/>
    <b>Oceania</b> becomes <b>Australasia</b><br/>
    Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    <b>Caribbean</b> islands starting with '<b>B</b>' go to <b>North America</b>, other Caribbean islands go to <b>South America</b><br/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</div>
</div>

FIND from WORLD

2015-07-29T13:40:14Z

40082593:

<pre class="setup">
#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)
</pre>

==Working with the <code>world</code> collection of countries==
<p>This tutorial introduces NoSQL using MonogDB and PyMongo under Python3.4. We will be using the <code>find()</code> command and comparison functions on the collection '''world''' which contains details of around 250 countries of the world:</p>
[[FIND examples]] are available.

<div class=q data-lang="py3">
Observe the result of running a simple mongoDB command.
<p class=strong>FIND name, continent, population FROM world</p>
<pre class=def>
pp.pprint(list(
db.world.find({},{
"name":1,
"continent":1,
"population":1,
"_id":0
})
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({},{"name":1,"continent":1,"population":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name for the countries that have a population of at least 200 million. 200 million is 200000000, there are eight zeros.</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"population":{"$gt":200000000}},
{"name":1, "_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"population":{"$gt":200000000}},{"name":1, "_id":0})))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Give the name and the per capita GDP for those countries with a population of at least 200 million.</p>
[[AGGREGATE examples]] are available.
<div class="hint" title="How to calculate per capita GDP">per capita GDP is the GDP divided by the population GDP/population</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"population":{"$gt":200000000}}},
{"$project":{"name":1, "gdp/population":{"$divide":["$gdp","$population"]}, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gt":200000000}}},{"$project":{"name":1, "gdp/population":{"$divide":["$gdp","$population"]}, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name and population in millions for the countries of the continent 'South America'. Divide the population by 1000000 to get population in millions.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"continent":{"$eq":"South America"}}},
{"$project":{"name":1, "population in millions":{"$divide":["$population",1000000]}, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"name":1, "population in millions":{"$divide":["$population",1000000]}, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name and population for France, Germany, Italy</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":{"$in":["France", "Germany", "Italy"]}}},
{"$project":{"name":1, "population":1, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":["France", "Germany", "Italy"]}}},{"$project":{"name":1, "population":1, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the countries which have a name that includes the word 'United'</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"name":{"$regex":"\s?United\s?"}},
{"name":1, "_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"name":{"$regex":"\s?United\s?"}},{"name":1, "_id":0})))
</div>
</div>

<div class=q data-lang="py3">
Two ways to be big: A country is big if it has an area of more than 3 million sq km or it has a population of more than 250 million.
<p class=strong>Show the countries that are big by area or big by population. Show name, population and area</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"$or":[{"area":{"$gt":3000000}},{"population":{"$gt":250000000}}]},
{"name":1,"population":1,"area":1,"_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"$or":[{"area":{"$gt":3000000}},{"population":{"$gt":250000000}}]},{"name":1,"population":1,"area":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
USA and China are big in population <span class=strong>and</span> big by area. Exclude these countries.
<p class=strong>Show the countries that are big by area or big by population but not both. Show name, population and area.</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"$or":[
{"area":{"$gt":3000000},"population":{"$lt":250000000}},
{"area":{"$lt":3000000},"population":{"$gt":250000000}}
]},
{"name":1,"population":1,"area":1,"_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"$or":[{"area":{"$gt":3000000},"population":{"$lt":250000000}},{"area":{"$lt":3000000},"population":{"$gt":250000000}}]}, {"name":1,"population":1,"area":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
Show the name and population in millions and the GDP in billions for the countries of the continent 'South America'. Use the ROUND function to show the values to two decimal places.<br />
Introducing [[MapReduce]]
<div class=hint title='Millions and billions'>Divide by 1000000 (6 zeros) for millions. Divide by 1000000000 (9 zeros) for billions.</div>
<p class=strong>For South America show population in millions and GDP in billions to 2 decimal places.</p>
<pre class=def>
from bson.code import Code
temp = db.world.map_reduce(
query={"continent":"South America"},
map=Code("function(){emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),
reduce=Code("""function(key, values){ return values} """),
finalize=Code("""function(k, v){
return {
'pop in millions':Math.round(v['pop']*1000000)/1000000,
'gdp in billions':Math.round(v['gdp']*1000000000)/1000000000
};
}
"""),
out={"inline":1}
)
pp.pprint(temp['results']);
</pre>
<div class=ans>
from bson.code import Code
temp = db.world.map_reduce(query={"continent":"South America"},map=Code("function(){emit(this.name, {'gdp':this.gdp,'pop':this.population});}"),reduce=Code("""function(key, values){ return values} """),finalize=Code("""function(k, v){return {'pop in millions':Math.round(v['pop']*1000000)/1000000,'gdp in billions':Math.round(v['gdp']*1000000000)/1000000000};}"""),out={"inline":1})
pp.pprint(temp['results']);
</div>
</div>

<div class=q data-lang="py3">
Show the per-capita GDP for those countries with a GDP of at least one trillion (1000000000000; that is 12 zeros). Round this value to the nearest 1000.
<p class=strong>Show per-capita GDP for the trillion dollar countries to the nearest $1000.</p>
<pre class=def>
from bson.code import Code
temp = db.world.map_reduce(
map=Code("function(){if(this.gdp > 1000000000000)emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),
reduce=Code("""function(key, values){ return values} """),
finalize=Code("""function(k, v){
return {'per-capita GDP':Math.round((v['gdp']/v['pop'])/1000)*1000};
}
"""),
out={"inline":1}
)
pp.pprint(temp['results']);
</pre>
<div class=ans>
from bson.code import Code
temp = db.world.map_reduce(map=Code("function(){if(this.gdp > 1000000000000)emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),reduce=Code("""function(key, values){ return values} """),finalize=Code("""function(k, v){
return {'per-capita GDP':Math.round((v['gdp']/v['pop'])/1000)*1000};}"""),out={"inline":1})
pp.pprint(temp['results']);
</div>
</div>

== Harder Questions ==

<div class=q data-lang="py3">
Find out more about <code>$cond</code> at [[AGGREGATE_examples]]
<p class=strong>Show the name and the continent - but substitute Australasia for Oceania - for countries beginning with N.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":{"$regex":"^N"}}},
{"$project":{
"name":1,
"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Austalasia","$continent"]},
"_id":0
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Austalasia","$continent"]},"_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> for countries beginning with N - but replace the continent <b>Oceania</b> with <b>Australasia</b>.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^N"}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
    substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
    substitute <b>America</b> - for each country in <b>North America</b> or <b>South America</b> or <b>Caribbean</b>.<br/><br/>Only show countries beginning with <b>A</b> or <b>B</b><br/>
If you're struggling you may want to experiment with <code>$and</code>,<code>$or</code>, etc.
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</div>
</div>

<div class=q data-lang="py3">
Put the continents right...
<br/><br/>
    <b>Oceania</b> becomes <b>Australasia</b><br/>
    Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    <b>Caribbean</b> islands starting with '<b>B</b>' go to <b>North America</b>, other Caribbean islands go to <b>South America</b><br/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</div>
</div>

FIND from WORLD

2015-07-29T13:37:27Z

40082593:

<pre class="setup">
#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)
</pre>

==Working with the <code>world</code> collection of countries==
<p>This tutorial introduces NoSQL using MonogDB and PyMongo under Python3.4. We will be using the <code>find()</code> command and comparison functions on the collection '''world''' which contains details of around 250 countries of the world:</p>
[[FIND examples]] are available.

<div class=q data-lang="py3">
Observe the result of running a simple mongoDB command.
<p class=strong>FIND name, continent, population FROM world</p>
<pre class=def>
pp.pprint(list(
db.world.find({},{
"name":1,
"continent":1,
"population":1,
"_id":0
})
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({},{"name":1,"continent":1,"population":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name for the countries that have a population of at least 200 million. 200 million is 200000000, there are eight zeros.</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"population":{"$gt":200000000}},
{"name":1, "_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"population":{"$gt":200000000}},{"name":1, "_id":0})))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Give the name and the per capita GDP for those countries with a population of at least 200 million.</p>
[[AGGREGATE examples]] are available.
<div class="hint" title="How to calculate per capita GDP">per capita GDP is the GDP divided by the population GDP/population</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"population":{"$gt":200000000}}},
{"$project":{"name":1, "gdp/population":{"$divide":["$gdp","$population"]}, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gt":200000000}}},{"$project":{"name":1, "gdp/population":{"$divide":["$gdp","$population"]}, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name and population in millions for the countries of the continent 'South America'. Divide the population by 1000000 to get population in millions.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"continent":{"$eq":"South America"}}},
{"$project":{"name":1, "population in millions":{"$divide":["$population",1000000]}, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"name":1, "population in millions":{"$divide":["$population",1000000]}, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the name and population for France, Germany, Italy</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":{"$in":["France", "Germany", "Italy"]}}},
{"$project":{"name":1, "population":1, "_id":0}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":["France", "Germany", "Italy"]}}},{"$project":{"name":1, "population":1, "_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
<p class=strong>Show the countries which have a name that includes the word 'United'</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"name":{"$regex":"\s?United\s?"}},
{"name":1, "_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"name":{"$regex":"\s?United\s?"}},{"name":1, "_id":0})))
</div>
</div>

<div class=q data-lang="py3">
Two ways to be big: A country is big if it has an area of more than 3 million sq km or it has a population of more than 250 million.
<p class=strong>Show the countries that are big by area or big by population. Show name, population and area</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"$or":[{"area":{"$gt":3000000}},{"population":{"$gt":250000000}}]},
{"name":1,"population":1,"area":1,"_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"$or":[{"area":{"$gt":3000000}},{"population":{"$gt":250000000}}]},{"name":1,"population":1,"area":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
USA and China are big in population <span class=strong>and</span> big by area. Exclude these countries.
<p class=strong>Show the countries that are big by area or big by population but not both. Show name, population and area.</p>
<pre class=def>
pp.pprint(list(
db.world.find(
{"$or":[
{"area":{"$gt":3000000},"population":{"$lt":250000000}},
{"area":{"$lt":3000000},"population":{"$gt":250000000}}
]},
{"name":1,"population":1,"area":1,"_id":0}
)
))
</pre>
<div class=ans>
pp.pprint(list(db.world.find({"$or":[{"area":{"$gt":3000000},"population":{"$lt":250000000}},{"area":{"$lt":3000000},"population":{"$gt":250000000}}]}, {"name":1,"population":1,"area":1,"_id":0})))
</div>
</div>

<div class=q data-lang="py3">
Show the name and population in millions and the GDP in billions for the countries of the continent 'South America'. Use the ROUND function to show the values to two decimal places.<br />
Introducing [[MapReduce]]
<div class=hint title='Millions and billions'>Divide by 1000000 (6 zeros) for millions. Divide by 1000000000 (9 zeros) for billions.</div>
<p class=strong>For South America show population in millions and GDP in billions to 2 decimal places.</p>
<pre class=def>
from bson.code import Code
temp = db.world.map_reduce(
query={"continent":"South America"},
map=Code("function(){emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),
reduce=Code("""function(key, values){ return values} """),
finalize=Code("""function(k, v){
return {
'pop in millions':Math.round(v['pop']*1000000)/1000000,
'gdp in billions':Math.round(v['gdp']*1000000000)/1000000000
};
}
"""),
out={"inline":1}
)
pp.pprint(temp['results']);
</pre>
<div class=ans>
from bson.code import Code
temp = db.world.map_reduce(query={"continent":"South America"},map=Code("function(){emit(this.name, {'gdp':this.gdp,'pop':this.population});}"),reduce=Code("""function(key, values){ return values} """),finalize=Code("""function(k, v){return {'pop in millions':Math.round(v['pop']*1000000)/1000000,'gdp in billions':Math.round(v['gdp']*1000000000)/1000000000};}"""),out={"inline":1})
pp.pprint(temp['results']);
</div>
</div>

<div class=q data-lang="py3">
Show the per-capita GDP for those countries with a GDP of at least one trillion (1000000000000; that is 12 zeros). Round this value to the nearest 1000.
<p class=strong>Show per-capita GDP for the trillion dollar countries to the nearest $1000.</p>
<pre class=def>
from bson.code import Code
temp = db.world.map_reduce(
map=Code("function(){if(this.gdp > 1000000000000)emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),
reduce=Code("""function(key, values){ return values} """),
finalize=Code("""function(k, v){
return {'per-capita GDP':Math.round((v['gdp']/v['pop'])/1000)*1000};
}
"""),
out={"inline":1}
)
pp.pprint(temp['results']);
</pre>
<div class=ans>
from bson.code import Code
temp = db.world.map_reduce(map=Code("function(){if(this.gdp > 1000000000000)emit(this.name,{'gdp':this.gdp,'pop':this.population});}"),reduce=Code("""function(key, values){ return values} """),finalize=Code("""function(k, v){
return {'per-capita GDP':Math.round((v['gdp']/v['pop'])/1000)*1000};}"""),out={"inline":1})
pp.pprint(temp['results']);
</div>
</div>

== Harder Questions ==

<div class=q data-lang="py3">
Find out more about <code>$cond</code> at [[AGGREGATE_examples]]
<p class=strong>Show the name and the continent - but substitute Australasia for Oceania - for countries beginning with N.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":{"$regex":"^N"}}},
{"$project":{
"name":1,
"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Austalasia","$continent"]},
"_id":0
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Austalasia","$continent"]},"_id":0}}])))
</div>
</div>

FIND from WORLD

2015-07-29T12:44:43Z

40082593:

<pre class=setup>
#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)
</pre>

==Country Profile==
For these questions you should use <code>aggregate([])</code> on the collection <code>world</code>
<div class='extra_space' style='width:1em; height:6em;'></div>
<div class=q data-lang="py3">
Give the <code>name</code> and the <code>per capita GDP</code> for those countries with a <code>population</code> of at least 200 million.
<div class="hint" title="How to calculate per capita GDP">
per capita GDP is the GDP divided by the population.
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"population":{"$gte":250000000}
}},
{"$project":{
"_id":0,
"name":1,
"per capita GDP": {"$divide": ["$gdp",1000000]}
}}
])
))
</pre>
<div class=ans>pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Give the <code>name</code> and the <code>population density</code> of all countries. Ignore results where the density is "None".
<div class="hint" title="How to calculate population density">
population density is the population divided by the area
</div>
<div class="hint" title="Division by 0 error?">
Use a <code>$match</code>. <code>{"area":{"$ne":0}}</code>
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"density": {"$divide": ["$population","$area"]}
}},
{"$match":{
"density": {"$ne":None}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"density":{"$divide":["$population","$area"]}}},{"$match":{"density":{"$ne":None}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population</code> in millions for the countries of the continent <b>South America</b>. Divide the population by 1000000 to get population in millions.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{

}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population density</code> for <b>France</b>, <b>Germany</b>, and <b>Italy</b>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name": {"$in":['United Kingdom','United States','Brazil']},
"population": {"$ne": None},
"area": {"$ne": 0}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":['France','Germany','Italy']},"population":{"$ne":None},"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"population density":{"$divide":["$population","$area"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Order the <code>continents</code> by <code>area</code> from most to least.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$name",
"area":{"$max": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$continent",
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</div>
</div>

==Harder Questions==
<div class=q data-lang="py3">
Print a list of names for countries in the continent of "North America" change United States to USA
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"continent":"North America"
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":"North America"}},{"$project":{"_id":0,"name":{"$cond": [{"$eq":["$name","United States"]},"USA","$name"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Combine <b>North America</b> and <b>South America</b> to <b>America</b>, and then list the continents by area. Biggest first.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":{
"$cond": [{"$eq":["$continent","North America"]},"America",
{"$cond": [{"$eq":["$continent","Asia"]},"The East","$continent"]}]
},
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{"_id":{"$cond":[{"$eq":["$continent","South America"]},"America",{"$cond":[{"$eq":["$continent","North America"]},"America","$continent"]}]},"area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> - but substitute <b>Australasia</b> for <b>Oceania</b> - for countries beginning with N.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^N"}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
    substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
    substitute <b>America</b> - for each country in <b>North America</b> or <b>South America</b> or <b>Caribbean</b>.<br/><br/>Only show countries beginning with <b>A</b> or <b>B</b><br/>
If you're struggling you may want to experiment with <code>$and</code>,<code>$or</code>, etc.
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</div>
</div>

<div class=q data-lang="py3">
Put the continents right...
<br/><br/>
    <b>Oceania</b> becomes <b>Australasia</b><br/>
    Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    <b>Caribbean</b> islands starting with '<b>B</b>' go to <b>North America</b>, other Caribbean islands go to <b>South America</b><br/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</div>
</div>

AGGREGATE world

2015-07-28T11:50:11Z

40082593:

<pre class=setup>
#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)
</pre>

==Country Profile==
For these questions you should use <code>aggregate([])</code> on the collection <code>world</code>
<div class='extra_space' style='width:1em; height:6em;'></div>
<div class=q data-lang="py3">
Give the <code>name</code> and the <code>per capita GDP</code> for those countries with a <code>population</code> of at least 200 million.
<div class="hint" title="How to calculate per capita GDP">
per capita GDP is the GDP divided by the population.
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"population":{"$gte":250000000}
}},
{"$project":{
"_id":0,
"name":1,
"per capita GDP": {"$divide": ["$gdp",1000000]}
}}
])
))
</pre>
<div class=ans>pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Give the <code>name</code> and the <code>population density</code> of all countries. Ignore results where the density is "None".
<div class="hint" title="How to calculate population density">
population density is the population divided by the area
</div>
<div class="hint" title="Division by 0 error?">
Use a <code>$match</code>. <code>{"area":{"$ne":0}}</code>
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"density": {"$divide": ["$population","$area"]}
}},
{"$match":{
"density": {"$ne":None}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"density":{"$divide":["$population","$area"]}}},{"$match":{"density":{"$ne":None}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population</code> in millions for the countries of the continent <b>South America</b>. Divide the population by 1000000 to get population in millions.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{

}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population density</code> for <b>France</b>, <b>Germany</b>, and <b>Italy</b>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name": {"$in":['United Kingdom','United States','Brazil']},
"population": {"$ne": None},
"area": {"$ne": 0}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":['France','Germany','Italy']},"population":{"$ne":None},"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"population density":{"$divide":["$population","$area"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Order the <code>continents</code> by <code>area</code> from most to least.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$name",
"area":{"$max": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$continent",
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</div>
</div>

==Harder Questions==
<div class=q data-lang="py3">
Print a list of names for countries in the continent of "North America" change United States to USA
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"continent":"North America"}},
{"$project":{
"_id":0,
"name":1
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":"North America"}},{"$project":{"_id":0,"name":{"$cond": [{"$eq":["$name","United States"]},"USA","$name"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Combine <b>North America</b> and <b>South America</b> to <b>America</b>, and then list the continents by area. Biggest first.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":{
"$cond": [{"$eq":["$continent","North America"]},"America",
{"$cond": [{"$eq":["$continent","Asia"]},"The East","$continent"]}]
},
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{"_id":{"$cond":[{"$eq":["$continent","South America"]},"America",{"$cond":[{"$eq":["$continent","North America"]},"America","$continent"]}]},"area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> - but substitute <b>Australasia</b> for <b>Oceania</b> - for countries beginning with N.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^N"}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
    substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
    substitute <b>America</b> - for each country in <b>North America</b> or <b>South America</b> or <b>Caribbean</b>.<br/><br/>Only show countries beginning with <b>A</b> or <b>B</b><br/>
If you're struggling you may want to experiment with <code>$and</code>,<code>$or</code>, etc.
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</div>
</div>

<div class=q data-lang="py3">
Put the continents right...
<br/><br/>
    <b>Oceania</b> becomes <b>Australasia</b><br/>
    Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    <b>Caribbean</b> islands starting with '<b>B</b>' go to <b>North America</b>, other Caribbean islands go to <b>South America</b><br/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</div>
</div>

AGGREGATE world

2015-07-28T11:41:49Z

40082593: /* Harder Questions */

<pre class=setup>
#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)
</pre>

==Country Profile==
For these questions you should use <code>aggregate([])</code> on the collection <code>world</code>
<div class='extra_space' style='width:1em; height:6em;'></div>
<div class=q data-lang="py3">
Give the <code>name</code> and the <code>per capita GDP</code> for those countries with a <code>population</code> of at least 200 million.
<div class="hint" title="How to calculate per capita GDP">
per capita GDP is the GDP divided by the population.
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"population":{"$gte":250000000}
}},
{"$project":{
"_id":0,
"name":1,
"per capita GDP": {"$divide": ["$gdp",1000000]}
}}
])
))
</pre>
<div class=ans>pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Give the <code>name</code> and the <code>population density</code> of all countries. Ignore results where the density is "None".
<div class="hint" title="How to calculate population density">
population density is the population divided by the area
</div>
<div class="hint" title="Division by 0 error?">
Use a <code>$match</code>. <code>{"area":{"$ne":0}}</code>
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"density": {"$divide": ["$population","$area"]}
}},
{"$match":{
"density": {"$ne":None}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"density":{"$divide":["$population","$area"]}}},{"$match":{"density":{"$ne":None}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population</code> in millions for the countries of the continent <b>South America</b>. Divide the population by 1000000 to get population in millions.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{

}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population density</code> for <b>France</b>, <b>Germany</b>, and <b>Italy</b>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name": {"$in":['United Kingdom','United States','Brazil']},
"population": {"$ne": None},
"area": {"$ne": 0}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":['France','Germany','Italy']},"population":{"$ne":None},"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"population density":{"$divide":["$population","$area"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Order the <code>continents</code> by <code>area</code> from most to least.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$name",
"area":{"$max": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$continent",
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</div>
</div>

==Harder Questions==
<div class=q data-lang="py3">
Print a list of names for countries in the continent of "North America" change United States to USA
<pre class=def>
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":"North America"}},{"$project":{"_id":0,"name" :{"$cond": [{"$eq":["$name","United States"]},"USA","$name"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Combine <b>North America</b> and <b>South America</b> to <b>America</b>, and then list the continents by area. Biggest first.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":{
"$cond": [{"$eq":["$continent","North America"]},"America",
{"$cond": [{"$eq":["$continent","Asia"]},"The East","$continent"]}]
},
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{"_id":{"$cond":[{"$eq":["$continent","South America"]},"America",{"$cond":[{"$eq":["$continent","North America"]},"America","$continent"]}]},"area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> - but substitute <b>Australasia</b> for <b>Oceania</b> - for countries beginning with N.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^N"}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
    substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
    substitute <b>America</b> - for each country in <b>North America</b> or <b>South America</b> or <b>Caribbean</b>.<br/><br/>Only show countries beginning with <b>A</b> or <b>B</b><br/>
If you're struggling you may want to experiment with <code>$and</code>,<code>$or</code>, etc.
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</div>
</div>

<div class=q data-lang="py3">
Put the continents right...
<br/><br/>
    <b>Oceania</b> becomes <b>Australasia</b><br/>
    Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    <b>Caribbean</b> islands starting with '<b>B</b>' go to <b>North America</b>, other Caribbean islands go to <b>South America</b><br/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</div>
</div>

AGGREGATE examples

2015-07-28T11:06:01Z

40082593:

<pre class=setup>
#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)
</pre>

==Introducing the aggregation framework==
These examples introduce the aggregation framework and its operators. Again we will be using the collection <code>world</code>
<div class='extra_space' style='width:1em; height:6em;'></div>

<div class=q data-lang="py3">
<code>$match</code> performs queries in a similar way to <code>find()</code>
<p class=strong>Show all the details for France</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"name":"France"}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":"France"}}])))
</div>
</div>

<div class=q data-lang="py3"><code>limit</code> sets the amount of documents to be handed to the next stage in the pipeline.
<p class=strong>Return the first document</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$limit":1}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$limit":1}])))
</div>
</div>

<div class=q data-lang="py3">
<code>$project</code> selects what fields to display.<br/>
It can also has the ability to create new fields and to compare fields against each other without using <code>$where</code>
<p class=strong>Show the name and population density of all Asian countries. (population/area)</p>
Note that "density" is a new field, made from the result of dividing two existing fields, and that <code>$divide</code> is an aggregate function.
<div class=hint title="Dealing with division by 0">
To avoid diving by 0 insert a <code>$match</code> to remove any countries with 0 area (Vatican City), then pipe these results through to <code>$project</code><br/>
There is no need to check if values are <code>null</code>, MongoDB will ignore these documents.
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"area":{"$ne":0},"continent":"Asia"}},
{"$project":{
"_id":0,
"name":1,
"density": {"$divide": ["$population","$area"]}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"area":{"$ne":0},"continent":"Asia"}},{"$project":{"_id":0,"name":1,"density":{"$divide":["$population","$area"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Because aggregate is a pipeline stages may be repeated, and stages don't have to be used in a specific order.
<p class=strong>Show the name of Asian countries with a density that's over 500 people per km<sup>2</sup>. (population/area)</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{"area":{"$ne":0},"continent":"Asia"}},
{"$project":{
"_id":0,
"name":1,
"density": {"$divide": ["$population","$area"]}
}},
{"$match":{"density":{"$gt":500}}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"area":{"$ne":0},"continent":"Asia"}},{"$project":{"_id":0,"name":1,"density":{"$divide":["$population","$area"]}}},{"$match":{"density":{"$gt":500}}}])))
</div>
</div>

<div class=q data-lang="py3">
<code>$sort</code> allows ordering of the results set, where 1 is ascending and -1 is descending.<br/>
Note that not including <code>$match</code> is the same as <code>{"$match":{}}</code>
<p class=strong>Show the name of all countries in descending order.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
}},
{"$sort":{
"name":-1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$project":{"_id":0,"name":1,}},{"$sort":{"name":-1}}])))
</div>
</div>

==Grouping==
Grouping provides accumulator operations such as <code>$sum</code><br />
All groups must have an <code>_id</code>. To see why this is useful imagine the following:<br/><br/>

So far you've been using the collection <code>world</code><br/>As every country has a continent, it would make sense to have countries as a nested document inside continents: e.g:

<pre>
[
{"name":"Africa",
"countries":[
{"name":"Algeria", "capital":"Algiers", ...},
{"name":"Angola", "capital":"Luanda", ...},
{"name":"Benin", "capital":"Porto-Novo",...}.
{...},
...
]},
{"name":"Asia",
"countries":[
{"name":"Afghanistan","capital":"Kabul", ...},
{"name":"Azerbaijan", "capital":"Baku", ...},
{"name":"Bahrain", "capital":"Manama",...},
{...},
...
]},
{...},
...
]
</pre>

The <code>world</code> collection isn't like this however. It uses the following structure, which has a redundancy where <code>continent</code> is repeated for each country.

<pre>
[
{"name":"Afghanistan","capital":"Kabul", "continent":"Asia", ...},
{"name":"Albania", "capital":"Tirana", "continent":"Europe, ...},
{"name":"Algeria", "capital":"Algiers","contiennt":"Africa",...},
{...},
...
]
</pre>
The code to group by continent is <code> "_id":"$continent"</code><br/>
If instead the question was to group by country the code would be <code>"_id":"$name"</code>.<br/>
To operate over the whole document (which would have the same effect as <code>"_id":"$name"</code>) <code>"_id":"null"</code> or <code>"_id":None</code> can be used.
<div class=q data-lang="py3">
<code>$max</code> and <code>$min</code> can be used to get the largest and smallest values in a group.
<p class=strong>Get the smallest and largest GDPs of each continent.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
'_id':'$continent',
'min':{"$min":"$gdp"},
'max':{"$max":"$gdp"}
}},
{"$project":{
"_id":1,
"min":1,
"max":1
}},
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{'_id':'$continent','min':{"$min":"$gdp"},'max':{"$max":"$gdp"}}},{"$project":{"_id":1,"min":1,"max":1}},])))
</div>
</div>

<div class=q data-lang="py3">
Some other useful aggregate functions to know are <code>$sum</code> and average: <code>$avg</code><br/>
This example combines all the material in these examples.
<p class=strong>Order the continents in descending order by total GDP, Include the average GDP for each country.</p>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{}},
{"$group":{
"_id":"$continent",
"Total GDP": {"$sum": "$gdp"},
"Average GDP": {"$avg": "$gdp"}
}},
{"$sort":{
"Total GDP":-1
}},
{"$project":{
"Area":"$_id",
"Total GDP": 1,
"Average GDP":1,
"_id":0
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{"_id":"$continent","Total GDP":{"$sum":"$gdp"},"Average GDP":{"$avg":"$gdp"}}},{"$sort":{"Total GDP":-1}},{"$project":{"Area":"$_id","Total GDP":1,"Average GDP":1,"_id":0}}])))
</div>
</div>

<div class=q data-lang="py3">
Using Conditions<br/><br/>
<code>$cond</code> is similar to a <code>CASE</code> statement in other languages.<br/>
It has the form <code>"$cond": [{<comparison> :[<field or value>,<field or value>]},<true case>,<false case>]</code><br/><br/>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":{
"$cond": [{"$eq":["$continent","Eurasia"]},"Europe","$continent"]
},
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))

AGGREGATE world

2015-07-28T10:40:28Z

40082593:

<pre class=setup>
#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)
</pre>

==Country Profile==
For these questions you should use <code>aggregate([])</code> on the collection <code>world</code>
<div class='extra_space' style='width:1em; height:6em;'></div>
<div class=q data-lang="py3">
Give the <code>name</code> and the <code>per capita GDP</code> for those countries with a <code>population</code> of at least 200 million.
<div class="hint" title="How to calculate per capita GDP">
per capita GDP is the GDP divided by the population.
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"population":{"$gte":250000000}
}},
{"$project":{
"_id":0,
"name":1,
"per capita GDP": {"$divide": ["$gdp",1000000]}
}}
])
))
</pre>
<div class=ans>pp.pprint(list(db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Give the <code>name</code> and the <code>population density</code> of all countries. Ignore results where the density is "None".
<div class="hint" title="How to calculate population density">
population density is the population divided by the area
</div>
<div class="hint" title="Division by 0 error?">
Use a <code>$match</code>. <code>{"area":{"$ne":0}}</code>
</div>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"density": {"$divide": ["$population","$area"]}
}},
{"$match":{
"density": {"$ne":None}
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"density":{"$divide":["$population","$area"]}}},{"$match":{"density":{"$ne":None}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population</code> in millions for the countries of the continent <b>South America</b>. Divide the population by 1000000 to get population in millions.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{

}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <code>name</code> and <code>population density</code> for <b>France</b>, <b>Germany</b>, and <b>Italy</b>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name": {"$in":['United Kingdom','United States','Brazil']},
"population": {"$ne": None},
"area": {"$ne": 0}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$in":['France','Germany','Italy']},"population":{"$ne":None},"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"population density":{"$divide":["$population","$area"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Order the <code>continents</code> by <code>area</code> from most to least.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$name",
"area":{"$max": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":"$continent",
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</div>
</div>

==Harder Questions==
<div class=q data-lang="py3">
Using Conditions<br/><br/>
<code>$cond</code> is similar to a <code>CASE</code> statement in other languages.<br/>
It has the form <code>"$cond": [{<comparison> :[<field or value>,<field or value>]},<true case>,<false case>]</code><br/><br/>
Using <code>$cond</code>, reattempt the above question but change <b>Eurasia</b> to <b>Europe</b>
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":{
"$cond": [{"$eq":["$continent","Eurasia"]},"Europe","$continent"]
},
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))

</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{"_id":{"$cond":[{"$eq":["$continent","Eurasia"]},"Europe","$continent"]},"area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}])))
</div>
</div>

<div class=q data-lang="py3">
Combine <b>North America</b> and <b>South America</b> to <b>America</b>, and then list the continents by area. Biggest first.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$group":{
"_id":{
"$cond": [{"$eq":["$continent","North America"]},"America",
{"$cond": [{"$eq":["$continent","Asia"]},"The East","$continent"]}]
},
"area":{"$sum": "$area"}
}},
{"$sort":{
"area": -1
}},
{"$project":{
"_id":1,
"area":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$group":{"_id":{"$cond":[{"$eq":["$continent","South America"]},"America",{"$cond":[{"$eq":["$continent","North America"]},"America","$continent"]}]},"area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> - but substitute <b>Australasia</b> for <b>Oceania</b> - for countries beginning with N.
<pre class=def>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^N"}
}},
{"$project":{
"_id":0,
"name":1
}}
])
))
</pre>
<div class=ans>
pp.pprint(list(db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])))
</div>
</div>

<div class=q data-lang="py3">
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
    substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
    substitute <b>America</b> - for each country in <b>North America</b> or <b>South America</b> or <b>Caribbean</b>.<br/><br/>Only show countries beginning with <b>A</b> or <b>B</b><br/>
If you're struggling you may want to experiment with <code>$and</code>,<code>$or</code>, etc.
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$match":{
"name":{"$regex":"^A|^B"}
}},
{"$project":{
"_id":0,
"name":1,
"continent": {
"$cond": [{
"$or":[
{"$eq":["$continent","Europe"]},
{"$eq":["$continent","Asia"]}
]},"Eurasia",{
"$cond": [
{"$or":[
{"$eq":["$continent","North America"]},
{"$eq":["$continent","South America"]},
{"$eq":["$continent","Caribbean"]}
]},"America","$continent"]}
]}
}}
])
))
</div>
</div>

<div class=q data-lang="py3">
Put the continents right...
<br/><br/>
    <b>Oceania</b> becomes <b>Australasia</b><br/>
    Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    <b>Caribbean</b> islands starting with '<b>B</b>' go to <b>North America</b>, other Caribbean islands go to <b>South America</b><br/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def></pre>
<div class=ans>
pp.pprint(list(
db.world.aggregate([
{"$project":{
"_id":0,
"name":1,
"original": "$continent",
"new": {
"$cond": [
{"$or":[
{"$eq":["$continent","Eurasia"]},
{"$eq":["$name","Turkey"]}
]},"Europe/Asia",{
"$cond":[
{"$eq":["$continent","Oceania"]},"Australasia",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$eq":[{"$substr":["$name",0,1]}, "B"]}
]},"North America",{
"$cond":[
{"$and":[
{"$eq":["$continent","Caribbean"]},
{"$ne":[{"$substr":["$name",0,1]}, "B"]}
]},"South America","$continent"
]
}
]
}
]
}
]
}
}}
])
))
</div>
</div>

Sum and Count

2015-07-28T09:23:15Z

40082593:

FIND basics

2015-07-28T08:40:44Z

40082593: