Actions

AGGREGATE Tutorial: Difference between revisions

From NoSQLZoo

Created page with "==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;'>..."
 
 
(42 intermediate revisions by 2 users not shown)
Line 1: Line 1:
==Country Profile==
==Country Profile==
For these questions you should use <code>aggregate([])</code> on the collection <code>world</code>
For these questions you should use <code>aggregate([])</code> on the collection <code>world</code>
You may find these [[AGGREGATE examples]] useful.
<div class='extra_space' style='width:1em; height:6em;'></div>
<div class='extra_space' style='width:1em; height:6em;'></div>
<div class=q data-lang="mongo">
==$group on continent==
<div class="q" data-lang="mongo">
The aggregate method allows a <code>$group</code> - you must specify the <code>_id</code> and you can use aggregating functions such as <code>$sum</code> <code>$min</code> <code>$max</code> <code>$push</code>
 
The sample code shows the total population of each continent.
<div class='imper'>Show the number of countries in each continent.</div>
<pre class="def"><nowiki>
db.world.aggregate({
  $group: {
    _id: '$continent',
    res: {
      $sum: '$population'
    }
  }
});</nowiki></pre>
<pre class="ans"><nowiki>db.world.aggregate({
  $group: {
    _id: '$continent',
    res: {
      $sum: 1
    }
  }
});
</nowiki></pre>
</div>
 
==Per Capita GDP==
<div class="q" data-lang="mongo">
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.
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">
<div class="hint" title="How to calculate per capita GDP">
per capita GDP is the GDP divided by the population.
per capita GDP is the GDP divided by the population.
</div>
</div>
<pre class=def>
<pre class="def"><nowiki>
db.world.aggregate([
db.world.aggregate([
     {$match:{
     {$match: {
         population:{$gte:250000000}
         population: {$gte: 250000000}
     }},
     }},
     {$project:{
     {$project: {
         _id:0,
         _id: 0,
         name:1,
         name: 1,
         "per capita GDP": {$divide: [$gdp,1000000]}
         "per capita GDP": {$divide: ['$gdp', 1000000]}
     }}
     }}
]).pretty()
]);</nowiki></pre>
</pre>
<pre class="ans"><nowiki>db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}]);</nowiki></pre>
<div class=ans>db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}])
</div>
</div>
</div>


<div class=q data-lang="py3">
==Population Density in South America==
Give the <code>name</code> and the <code>population density</code> of all countries. Ignore results where the density is "None".
<div class="q" data-lang="mongo">
Give the <code>name</code> and the <code>population density</code> of all countries in South America.
<div class="hint" title="How to calculate population density">
<div class="hint" title="How to calculate population density">
population density is the population divided by the area
population density is the population divided by the area
Line 31: Line 59:
Use a <code>$match</code>. <code>{"area":{"$ne":0}}</code>
Use a <code>$match</code>. <code>{"area":{"$ne":0}}</code>
</div>
</div>
<pre class=def>
<pre class="def"><nowiki>
pp.pprint(list(
db.world.aggregate([
    db.world.aggregate([
    {$match: {continent: 'Asia'}},
        {"$project":{
    {$project: {
            "_id":0,
        _id: 0,
            "name":1,
        name: 1,
            "density": {"$divide": ["$population","$area"]}
        density: {$divide: ["$population", "$area"]}
        }},
    }}
        {"$match":{
]);</nowiki></pre>
            "density": {"$ne":None}
<pre class="ans"><nowiki>db.world.aggregate([{$match:{continent:'South America'}},{$project:{_id:0,name:1,density:{$divide:["$population","$area"]}}}]);</nowiki></pre>
        }}
</div>
    ])
==Population Density for "V"==
))
<div class="q" data-lang="mongo">
Give the <code>name</code> and the <code>population density</code> of all countries with name after V in the alphabet.
<p>Note that because Vatican City (with area 0) is in Europe you will get a divide by zero error unless you filter first.
</p>
<div class="hint" title="Division by 0 error?">
Use a <code>$match</code>.
<pre>
{
  $match: {
    area: {
      "$ne": 0
    }
  }
}
</pre>
</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>
<pre class="def"><nowiki>
db.world.aggregate([
    {$match: {name: {$gt: 'V'}}},
    {$project: {
        _id: 0,
        name: 1,
        area: 1
    }}
]);</nowiki></pre>
<pre class="ans"><nowiki>db.world.aggregate([{$match:{name:{$gt:'V'}}},{$match:{area:{"$ne":0}}},{$project:{_id:0,name:1,density:{$divide:["$population","$area"]}}}]);</nowiki></pre>
</div>
</div>
==Population in millions==
<div class="q" data-lang="mongo">
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"><nowiki>
db.world.aggregate([
    {$match:{


<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.
    {$project:{
<pre class=def>
        _id: 0,
pp.pprint(list(
        name: 1
     db.world.aggregate([
    }}
        {"$match":{
]);</nowiki></pre>
           
<pre class="ans"><nowiki>db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}]);</nowiki></pre>
        }},
        {"$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>


 
==Population density==
<div class=q data-lang="py3">
<div class="q" data-lang="mongo">
Show the <code>name</code> and <code>population density</code> for <b>France</b>, <b>Germany</b>, and <b>Italy</b>
Show the <code>name</code> and <code>population density</code> for <b>France</b>, <b>Germany</b>, and <b>Italy</b>
<pre class=def>
<pre class="def"><nowiki>
pp.pprint(list(
db.world.aggregate([
    db.world.aggregate([
    {$match:{
        {"$match":{
        name: {$in: ['United Kingdom', 'United States', 'Brazil']},
            "name": {"$in":['United Kingdom','United States','Brazil']},
        population: {$ne: null},
            "population": {"$ne": None},
        area: {$ne: 0}
            "area": {"$ne": 0}
    }},
        }},
    {$project:{
        {"$project":{
        _id: 0,
            "_id":0,
        name: 1
            "name":1
    }}
        }}
]);</nowiki></pre>
    ])
<pre class="ans"><nowiki>db.world.aggregate([{"$match":{"name":{"$in":['France','Germany','Italy']},"population":{"$ne":null},"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"population density":{"$divide":["$population","$area"]}}}]);</nowiki></pre>
))
</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>
==Continents by area==
<div class="q" data-lang="mongo">
Order the <code>continents</code> by <code>area</code> from most to least.
<pre class="def"><nowiki>
db.world.aggregate([
    {$group: {
        _id: "$name",
        area: {$max: "$area"}
    }},
    {$sort: {
        area: -1
    }},
    {$project: {
        _id: 1,
        area: 1
    }}
]);</nowiki></pre>
<pre class="ans"><nowiki>db.world.aggregate([{"$group":{"_id":"$continent","area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}]);</nowiki></pre>
</div>
</div>


<div class=q data-lang="py3">
==Big Continents==
Order the <code>continents</code> by <code>area</code> from most to least.
<div class="q" data-lang="mongo">
<pre class=def>
Show the only two continents with total area greater than 25000000 and then sort from largest to smallest.
pp.pprint(list(
<pre class="def"><nowiki>
    db.world.aggregate([
db.world.aggregate([
        {"$group":{
  {$match: {
            "_id":"$name",
      continent: "North America"
            "area":{"$max": "$area"}
  }},
        }},
  {$project: {
        {"$sort":{
      _id: 0,
            "area": -1
      name: 1
        }},
  }}
        {"$project":{
]);</nowiki></pre>
            "_id":1,
<pre class="ans"><nowiki>db.world.aggregate([{$group:{_id:"$continent",area:{$sum:"$area"}}},{$sort:{area:-1}},{$match:{area:{$gt:25000000}}}]);</nowiki></pre>
            "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>
==First and last country by continent==
<div class="q" data-lang="mongo">
For each continent show the first and last country alphabetically like this:
<syntaxhighlight lang="JavaScript>
{ "_id" : "Africa", "from" : "Algeria", "to" : "Zimbabwe" }
{ "_id" : "Asia", "from" : "Afghanistan", "to" : "Yemen" }
{ "_id" : "Caribbean", "from" : "Antigua and Barbuda", "to" : "Trinidad and Tobago" }
{ "_id" : "Eurasia", "from" : "Armenia", "to" : "Russia" }
{ "_id" : "Europe", "from" : "Albania", "to" : "Vatican City" }
{ "_id" : "North America", "from" : "Belize", "to" : "United States" }
{ "_id" : "Oceania", "from" : "Australia", "to" : "Vanuatu" }
{ "_id" : "South America", "from" : "Argentina", "to" : "Venezuela" }
</syntaxhighlight>
<pre class="def"><nowiki>
db.world.aggregate([
  {$group: {
      _id: "$continent"
  }},
  {$sort: {
      _id: 1
  }}
]);</nowiki></pre>
<pre class="ans"><nowiki>db.world.aggregate([{$sort:{name:1}},{$group:{_id:'$continent',from:{$first:'$name'},to:{$last:'$name'}},},{$sort:{_id:1}}])</nowiki></pre>
</div>
</div>


==Harder Questions==
==Countries beginning with...==
<div class=q data-lang="py3">
<div class="q" data-lang="mongo">
Print a list of names for countries in the continent of "North America" change United States to USA
Group countries according to the first letter of the name. As shown.
<pre class=def>
Only give "U" through to "Z".
pp.pprint(list(
 
    db.world.aggregate([
You will need to use the '''$substr''' function and the '''$push''' aggregate function.
      {"$match":{
<syntaxhighlight lang="JavaScript">
          "continent":"North America"
{ "_id" : "U", "list" : [ "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom", "United States", "Uruguay", "Uzbekistan" ] }
      }},
{ "_id" : "V", "list" : [ "Vanuatu", "Vatican City", "Venezuela", "Vietnam" ] }
      {"$project":{
{ "_id" : "Y", "list" : [ "Yemen" ] }
          "_id":0,
{ "_id" : "Z", "list" : [ "Zambia", "Zimbabwe" ] }
          "name":1
</syntaxhighlight>
      }}
<pre class="def"><nowiki>
    ])
db.world.aggregate([
))
  {$project: {
</pre>
    _id: '$name',
<div class=ans>
    startsWith: {$substr: ['$name', 0, 1]}
pp.pprint(list(db.world.aggregate([{"$match":{"continent":"North America"}},{"$project":{"_id":0,"name":{"$cond": [{"$eq":["$name","United States"]},"USA","$name"]}}}])))
  }},
</div>
  {$match: {
    _id: {$gte: 'U'}
  }},
  {$sort: {_id: 1}}
]);</nowiki></pre>
<pre class="ans"><nowiki>db.world.aggregate([{$group:{_id:{$substr:['$name',0,1]},list:{$push:'$name'}}},{$match:{_id:{$gte:'U'}}},{$sort:{_id:1}}]);</nowiki></pre>
</div>
</div>


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


<div class=q data-lang="py3">
==Country populations by order of magnitude==
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>.
<div class="q" data-lang="mongo">
<pre class=def>
Show the number of countries in each order.
pp.pprint(list(
 
    db.world.aggregate([
For example UK has a population of 64,105,700 so it belongs in the 10,000,000 bucket.
        {"$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">
You will need the functions $floor, $log10 and $pow
Show the <b>name</b> and the <b>continent</b> but:<br/><br/>
&nbsp;&nbsp;&nbsp;&nbsp;substitute <b>Eurasia</b> for <b>Europe</b> and <b>Asia</b>.<br/>
&nbsp;&nbsp;&nbsp;&nbsp;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">
<pre class="def"><nowiki>
Put the continents right...
db.world.aggregate([
<br/><br/>
    {$match: {
&nbsp;&nbsp;&nbsp;&nbsp;<b>Oceania</b> becomes <b>Australasia</b><br/>
        name: {$regex: "^N"}
&nbsp;&nbsp;&nbsp;&nbsp;Countries in <b>Eurasia</b> and <b>Turkey</b> go to <b>Europe/Asia</b><br/>
    }},
&nbsp;&nbsp;&nbsp;&nbsp;<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/>
    {$project: {
<br/><br/>
        _id: 0,
<b>Show the name, the original continent and the new continent of all countries.</b>
        name: 1
<pre class=def></pre>
    }}
<div class=ans>
]);</nowiki></pre>
pp.pprint(list(
<pre class="ans"><nowiki>db.world.aggregate([
    db.world.aggregate([
    {$project: {name:1,l10:{$pow:[10,{$floor:{$log10:"$population"}}]}}},
        {"$project":{
    {$group:{_id:"$l10",c:{$sum:1}}},
            "_id":0,
    {$sort:{_id:1}}
            "name":1,
]);
            "original": "$continent",
</nowiki></pre>
            "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>
</div>

Latest revision as of 22:53, 31 March 2021

Country Profile

For these questions you should use aggregate([]) on the collection world

You may find these AGGREGATE examples useful.

$group on continent

The aggregate method allows a $group - you must specify the _id and you can use aggregating functions such as $sum $min $max $push

The sample code shows the total population of each continent.

Show the number of countries in each continent.
db.world.aggregate({
  $group: {
    _id: '$continent',
    res: {
      $sum: '$population'
    }
  }
});
db.world.aggregate({
  $group: {
    _id: '$continent',
    res: {
      $sum: 1
    }
  }
});

Per Capita GDP

Give the name and the per capita GDP for those countries with a population of at least 200 million.

per capita GDP is the GDP divided by the population.

db.world.aggregate([
    {$match: {
        population: {$gte: 250000000}
    }},
    {$project: {
        _id: 0,
        name: 1,
        "per capita GDP": {$divide: ['$gdp', 1000000]}
    }}
]);
db.world.aggregate([{"$match":{"population":{"$gte":200000000}}},{"$project":{"_id":0,"name":1,"per capita GDP": {"$divide": ["$gdp","$population"]}}}]);

Population Density in South America

Give the name and the population density of all countries in South America.

population density is the population divided by the area

Use a $match. {"area":{"$ne":0}}

db.world.aggregate([
    {$match: {continent: 'Asia'}},
    {$project: {
        _id: 0,
        name: 1,
        density: {$divide: ["$population", "$area"]}
    }}
]);
db.world.aggregate([{$match:{continent:'South America'}},{$project:{_id:0,name:1,density:{$divide:["$population","$area"]}}}]);

Population Density for "V"

Give the name and the population density of all countries with name after V in the alphabet.

Note that because Vatican City (with area 0) is in Europe you will get a divide by zero error unless you filter first.

Use a $match.

{ 
  $match: {
    area: {
      "$ne": 0
    }
  }
}
db.world.aggregate([
    {$match: {name: {$gt: 'V'}}},
    {$project: {
        _id: 0,
        name: 1,
        area: 1
    }}
]);
db.world.aggregate([{$match:{name:{$gt:'V'}}},{$match:{area:{"$ne":0}}},{$project:{_id:0,name:1,density:{$divide:["$population","$area"]}}}]);

Population in millions

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.

db.world.aggregate([
    {$match:{

    }},
    {$project:{
        _id: 0,
        name: 1
    }}
]);
db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}]);

Population density

Show the name and population density for France, Germany, and Italy

db.world.aggregate([
    {$match:{
        name: {$in: ['United Kingdom', 'United States', 'Brazil']},
        population: {$ne: null},
        area: {$ne: 0}
    }},
    {$project:{
        _id: 0,
        name: 1
    }}
]);
db.world.aggregate([{"$match":{"name":{"$in":['France','Germany','Italy']},"population":{"$ne":null},"area":{"$ne":0}}},{"$project":{"_id":0,"name":1,"population density":{"$divide":["$population","$area"]}}}]);

Continents by area

Order the continents by area from most to least.

db.world.aggregate([
    {$group: {
        _id: "$name",
        area: {$max: "$area"}
    }},
    {$sort: {
        area: -1
    }},
    {$project: {
        _id: 1,
        area: 1
    }}
]);
db.world.aggregate([{"$group":{"_id":"$continent","area":{"$sum":"$area"}}},{"$sort":{"area":-1}},{"$project":{"_id":1,"area":1}}]);

Big Continents

Show the only two continents with total area greater than 25000000 and then sort from largest to smallest.

db.world.aggregate([
  {$match: {
      continent: "North America"
  }},
  {$project: {
      _id: 0,
      name: 1
  }}
]);
db.world.aggregate([{$group:{_id:"$continent",area:{$sum:"$area"}}},{$sort:{area:-1}},{$match:{area:{$gt:25000000}}}]);

First and last country by continent

For each continent show the first and last country alphabetically like this:

 { "_id" : "Africa", "from" : "Algeria", "to" : "Zimbabwe" }
 { "_id" : "Asia", "from" : "Afghanistan", "to" : "Yemen" }
 { "_id" : "Caribbean", "from" : "Antigua and Barbuda", "to" : "Trinidad and Tobago" }
 { "_id" : "Eurasia", "from" : "Armenia", "to" : "Russia" }
 { "_id" : "Europe", "from" : "Albania", "to" : "Vatican City" }
 { "_id" : "North America", "from" : "Belize", "to" : "United States" }
 { "_id" : "Oceania", "from" : "Australia", "to" : "Vanuatu" }
 { "_id" : "South America", "from" : "Argentina", "to" : "Venezuela" }
db.world.aggregate([
  {$group: {
      _id: "$continent"
  }},
  {$sort: {
      _id: 1
  }}
]);
db.world.aggregate([{$sort:{name:1}},{$group:{_id:'$continent',from:{$first:'$name'},to:{$last:'$name'}},},{$sort:{_id:1}}])

Countries beginning with...

Group countries according to the first letter of the name. As shown. Only give "U" through to "Z".

You will need to use the $substr function and the $push aggregate function.

 { "_id" : "U", "list" : [ "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom", "United States", "Uruguay", "Uzbekistan" ] }
 { "_id" : "V", "list" : [ "Vanuatu", "Vatican City", "Venezuela", "Vietnam" ] }
 { "_id" : "Y", "list" : [ "Yemen" ] }
 { "_id" : "Z", "list" : [ "Zambia", "Zimbabwe" ] }
db.world.aggregate([
  {$project: {
    _id: '$name',
    startsWith: {$substr: ['$name', 0, 1]}
  }},
  {$match: {
    _id: {$gte: 'U'}
  }},
  {$sort: {_id: 1}}
]);
db.world.aggregate([{$group:{_id:{$substr:['$name',0,1]},list:{$push:'$name'}}},{$match:{_id:{$gte:'U'}}},{$sort:{_id:1}}]);

Harder Questions

Messing with continent names

Combine North America and South America to America, and then list the continents by area. Biggest first.

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
  }}
]);
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}}]); 

Country populations by order of magnitude

Show the number of countries in each order.

For example UK has a population of 64,105,700 so it belongs in the 10,000,000 bucket.

You will need the functions $floor, $log10 and $pow

db.world.aggregate([
    {$match: {
        name: {$regex: "^N"}
    }},
    {$project: {
        _id: 0,
        name: 1
    }}
]);
db.world.aggregate([
    {$project: {name:1,l10:{$pow:[10,{$floor:{$log10:"$population"}}]}}},
    {$group:{_id:"$l10",c:{$sum:1}}},
    {$sort:{_id:1}}
]);
  • You have been served by: dill