Actions

AGGREGATE Tutorial: Difference between revisions

From NoSQLZoo

 
(27 intermediate revisions by 2 users not shown)
Line 4: Line 4:
You may find these [[AGGREGATE examples]] useful.
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>
==$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==
==Per Capita GDP==
<div class=q data-lang="mongo">
<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]}
     }}
     }}
])
]);</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>
==Population Density in South America==
==Population Density in South America==
<div class=q data-lang="mongo">
<div class="q" data-lang="mongo">
Give the <code>name</code> and the <code>population density</code> of all countries in South America.
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">
Line 34: 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>
db.world.aggregate([
    {$match:{continent:'Asia'}},
    {$project:{
        _id:0,
        name:1,
        density: {$divide: ["$population","$area"]}
    }},
])
</pre>
<div class=ans>
db.world.aggregate([
db.world.aggregate([
     {$match:{continent:'South America'}},
     {$match: {continent: 'Asia'}},
     {$project:{
     {$project: {
         _id:0,
         _id: 0,
         name:1,
         name: 1,
         density: {$divide: ["$population","$area"]}
         density: {$divide: ["$population", "$area"]}
     }}
     }}
])
]);</nowiki></pre>
<pre class="ans"><nowiki>db.world.aggregate([{$match:{continent:'South America'}},{$project:{_id:0,name:1,density:{$divide:["$population","$area"]}}}]);</nowiki></pre>
</div>
</div>
</div>
==Population Density for "V"==
==Population Density for "V"==
<div class=q data-lang="mongo">
<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.
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>Note that because Vatican City (with area 0) is in Europe you will get a divide by zero error unless you filter first.
</p>
</p>
<div class="hint" title="Division by 0 error?">
<div class="hint" title="Division by 0 error?">
Use a <code>$match</code>. <code>{$match:{area:{"$ne":0}}}</code>
Use a <code>$match</code>.
<pre>
{  
  $match: {
    area: {
      "$ne": 0
    }
  }
}
</pre>
</div>
</div>
<pre class=def>
<pre class="def"><nowiki>
db.world.aggregate([
    {$match:{name:{$gt:'V'}}},
    {$project:{
        _id:0,
        name:1,
        area:1
    }},
])
</pre>
<div class=ans>
db.world.aggregate([
db.world.aggregate([
     {$match:{name:{$gt:'V'}}},
     {$match: {name: {$gt: 'V'}}},
    {$match:{area:{"$ne":0}}},
     {$project: {
     {$project:{
         _id: 0,
         _id:0,
         name: 1,
         name:1,
         area: 1
         density: {$divide: ["$population","$area"]}
     }}
     }}
])
]);</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>
</div>
==Population in millions==
==Population in millions==
<div class=q data-lang="mongo">
<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.  
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>
<pre class="def"><nowiki>
db.world.aggregate([
db.world.aggregate([
     {$match:{
     {$match:{
       
 
     }},
     }},
     {$project:{
     {$project:{
         _id:0,
         _id: 0,
         name:1
         name: 1
     }}
     }}
])
]);</nowiki></pre>
</pre>
<pre class="ans"><nowiki>db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}]);</nowiki></pre>
<div class=ans>
db.world.aggregate([{"$match":{"continent":{"$eq":"South America"}}},{"$project":{"_id":0,"name":1,"population":{"$divide":["$population",1000000]}}}])
</div>
</div>
</div>


==Population density==
==Population density==
<div class=q data-lang="mongo">
<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>
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: null},
         area: {$ne: 0}
         area: {$ne: 0}
     }},
     }},
     {$project:{
     {$project:{
         _id:0,
         _id: 0,
         name:1
         name: 1
     }}
     }}
])
]);</nowiki></pre>
</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>
<div class=ans>
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"]}}}])
</div>
</div>
</div>
==Continents by area==
==Continents by area==
<div class=q data-lang="mongo">
<div class="q" data-lang="mongo">
Order the <code>continents</code> by <code>area</code> from most to least.
Order the <code>continents</code> by <code>area</code> from most to least.
<pre class=def>
<pre class="def"><nowiki>
db.world.aggregate([
db.world.aggregate([
     {$group:{
     {$group: {
         _id:"$name",
         _id: "$name",
         area:{$max: "$area"}
         area: {$max: "$area"}
     }},
     }},
     {$sort:{
     {$sort: {
         area: -1
         area: -1
     }},
     }},
     {$project:{
     {$project: {
         _id:1,
         _id: 1,
         area:1
         area: 1
     }}
     }}
])
]);</nowiki></pre>
</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 class=ans>
    db.world.aggregate([
        {"$group":{
            "_id":"$continent",
            "area":{"$sum": "$area"}
        }},
        {"$sort":{
            "area": -1
        }},
        {"$project":{
            "_id":1,
            "area":1
        }}
    ])
</div>
</div>
</div>


==Big Continents==
==Big Continents==
<div class=q data-lang="mongo">
<div class="q" data-lang="mongo">
Show the only two continents with total area greater than 25000000
Show the only two continents with total area greater than 25000000 and then sort from largest to smallest.
<pre class=def>
<pre class="def"><nowiki>
db.world.aggregate([
db.world.aggregate([
   {$match:{
   {$match: {
       continent:"North America"
       continent: "North America"
   }},
   }},
   {$project:{
   {$project: {
       _id:0,
       _id: 0,
       name:1
       name: 1
   }}
   }}
])
]);</nowiki></pre>
</pre>
<pre class="ans"><nowiki>db.world.aggregate([{$group:{_id:"$continent",area:{$sum:"$area"}}},{$sort:{area:-1}},{$match:{area:{$gt:25000000}}}]);</nowiki></pre>
<div class=ans>
db.world.aggregate([
    {$group:{
        _id:"$continent",
        area:{$sum: "$area"}
    }},
    {$sort:{
        area: -1
    }},
    {$match:{
        area:{$gt:25000000}
    }}
])
</div>
</div>
</div>
==First and last country by continent==
==First and last country by continent==
<div class=q data-lang="mongo">
<div class="q" data-lang="mongo">
For each continent show the first and last country alphabetically like this:
For each continent show the first and last country alphabetically like this:
<syntaxhighlight lang="JavaScript>
  { "_id" : "Africa", "from" : "Algeria", "to" : "Zimbabwe" }
  { "_id" : "Africa", "from" : "Algeria", "to" : "Zimbabwe" }
  { "_id" : "Asia", "from" : "Afghanistan", "to" : "Yemen" }
  { "_id" : "Asia", "from" : "Afghanistan", "to" : "Yemen" }
Line 204: Line 178:
  { "_id" : "Oceania", "from" : "Australia", "to" : "Vanuatu" }
  { "_id" : "Oceania", "from" : "Australia", "to" : "Vanuatu" }
  { "_id" : "South America", "from" : "Argentina", "to" : "Venezuela" }
  { "_id" : "South America", "from" : "Argentina", "to" : "Venezuela" }
<pre class=def>
</syntaxhighlight>
<pre class="def"><nowiki>
db.world.aggregate([
db.world.aggregate([
   {$group:{
   {$group: {
       _id:"$continent"
       _id: "$continent"
   }},
   }},
   {$sort:{
   {$sort: {
       _id:1
       _id: 1
   }}
   }}
])
]);</nowiki></pre>
</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 class=ans>
</div>
 
==Countries beginning with...==
<div class="q" data-lang="mongo">
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.
<syntaxhighlight lang="JavaScript">
{ "_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" ] }
</syntaxhighlight>
<pre class="def"><nowiki>
db.world.aggregate([
db.world.aggregate([
    {$sort:{name:1}},
  {$project: {
    {$group:{
    _id: '$name',
      _id:'$continent',
    startsWith: {$substr: ['$name', 0, 1]}
      from:{$first:'$name'},
  }},
      to:{$last:'$name'}
  {$match: {
      },
    _id: {$gte: 'U'}
    },
  }},
    {$sort:{_id:1}}
  {$sort: {_id: 1}}
])
]);</nowiki></pre>
</div>
<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>


==Harder Questions==
==Harder Questions==
==Messing with continent names==
==Messing with continent names==
<div class=q data-lang="mongo">
<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>
db.world.aggregate([
db.world.aggregate([
    {$group:{
  {$group: {
        _id:{
    _id: {
            $cond: [{$eq:["$continent","North America"]},"America",
      $cond: [
                {$cond: [{$eq:["$continent","Asia"]},"The East","$continent"]}]
        {$eq: ["$continent", "North America"]},
        },
        "America",
        area:{$sum: "$area"}
        {$cond: [
    }},
          {$eq: ["$continent", "Asia"]},
    {$sort:{
          "The East",
        area: -1
          "$continent"
    }},
        ]}
    {$project:{
      ]
        _id:1,
    },
        area:1
    area: {$sum: "$area"}
    }}
  }},
])
  {$sort: {area: -1}},
</pre>
  {$project: {
<div class=ans>
    _id: 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}}])  
    area: 1
</div>
  }}
]);</nowiki></pre>
<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>


==Messing with continent names 2==
==Country populations by order of magnitude==
<div class=q data-lang="mongo">
<div class="q" data-lang="mongo">
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>.
Show the number of countries in each order.
<pre class=def>
 
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"}
You will need the functions $floor, $log10 and $pow
    }},
    {$project:{
        _id:0,
        name:1
    }}
])
</pre>
<div class=ans>
db.world.aggregate([{"$match":{"name":{"$regex":"^N"}}},{"$project":{"_id":0,"name":1,"continent":{"$cond":[{"$eq":["$continent","Oceania"]},"Australasia","$continent"]}}}])
</div>
</div>


==Messing with continent names 3==
<pre class="def"><nowiki>
<div class=q data-lang="mongo">
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>
db.world.aggregate([
db.world.aggregate([
     {$match:{
     {$match: {
         name:{$regex:"^A|^B"}
         name: {$regex: "^N"}
     }},
     }},
     {$project:{
     {$project: {
         _id:0,
         _id: 0,
         name:1,
         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"]}
            ]}
     }}
     }}
])
]);</nowiki></pre>
</div>
<pre class="ans"><nowiki>db.world.aggregate([
</div>
    {$project: {name:1,l10:{$pow:[10,{$floor:{$log10:"$population"}}]}}},
 
    {$group:{_id:"$l10",c:{$sum:1}}},
==Messing with continent names 4==
    {$sort:{_id:1}}
<div class=q data-lang="mongo">
]);
Put the continents right...
</nowiki></pre>
<br/><br/>
&nbsp;&nbsp;&nbsp;&nbsp;<b>Oceania</b> becomes <b>Australasia</b><br/>
&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/>
<br/><br/>
<b>Show the name, the original continent and the new continent of all countries.</b>
<pre class=def></pre>
<div class=ans>
    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>
</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