5.1SQL vs NoSQL: the trade-offs

"NoSQL" doesn't mean "no structure": it means "not only SQL's structure". Every database so far assumed every record has the same shape; a document database drops that rule.

Dimension	SQL	NoSQL
Schema	Fixed schema before you insert a row	Each record's shape may vary; structure enforced in app code, if at all
Consistency	Built around ACID transactions	Many trade strict consistency for availability and speed ("eventual consistency"); MongoDB still supports transactions
Scaling	Traditionally vertical: a bigger server	Designed to scale horizontally: more servers sharing the load

The NoSQL landscape

Model	Examples & fit
Key-value	Redis, DynamoDB: a giant dictionary; look up by key, get a value. Extremely fast, minimal structure.
Document	MongoDB, CouchDB: each record is a self-contained document, typically JSON/BSON.
Column-family	ClickHouse, DuckDB: optimised for reading whole columns across millions of rows (compare Databricks).
Graph	Neo4j: built around relationships (nodes and edges), e.g. social networks, recommendation engines.
Vector	Built around similarity search over embeddings.

5.2MongoDB in three pieces, and its vocabulary

Piece	What it is
Community Server	The free, open-source engine you can install yourself. Not used directly in this course.
Atlas	MongoDB's managed, cloud-hosted DBaaS: this week's platform. Atlas is to MongoDB what Supabase is to PostgreSQL.
Compass & mongosh	The two official clients. Compass (GUI): browse and build queries visually, like pgAdmin. mongosh (JavaScript-based CLI): scripting and automation, like psql.

Document: One record, stored as BSON: the equivalent of a row.
Collection: A group of documents: the equivalent of a table, but with no fixed columns.
Database: A group of collections, as in PostgreSQL.
_id: Every document gets a unique _id automatically (an ObjectId) if you don't supply one: MongoDB's primary key.

JSON vs BSON: Documents look like JSON when you type them, but MongoDB stores them as BSON (Binary JSON). BSON adds types JSON lacks (dates, binary data, ObjectId) and its binary layout parses and scans faster than text.

Databases and collections are created automatically on first write: there is no CREATE TABLE or CREATE DATABASE.

5.3Schema design: embedding vs referencing

Embed

Data that is always read together and belongs to one parent: an address, a line item. One customer document holds its address sub-object and account array; no joins needed.

Reference

Data that is large, shared across many parents, or grows without bound: keep it in its own collection and look it up (e.g. with $lookup).

The rule of thumb Embed what belongs to one parent and is read together. Reference what is large, shared, or grows without bound. An unbounded embedded array (a growing order history) is exactly what the rule warns against.

5.4MongoDB Atlas and the free M0 tier

M0 (Free): 512 MB storage, shared vCPU and RAM, up to 100 connections, one M0 cluster per project. No card.
Network Access: an IP allow-list deciding which machines may connect at all (Network Access → Add Current IP Address).
Connect: Atlas gives a Compass connection string and the exact mongosh command (mongodb+srv://…); substitute your database user's password.

The detail that matters most this week Even the free M0 cluster is a genuine 3-node replica set, not a simplified stand-in. rs.status() shows one PRIMARY and two SECONDARY.

5.5CRUD, update operators and query operators

mongosh	SQL
`db.customers.insertOne({ first_name: "Yousef" })`	INSERT
`db.customers.find({ "account.balance": { $gt: 100 } })`	SELECT … WHERE
`db.customers.updateOne({ _id: "100" }, { $set: { age: 45 } })`	UPDATE
`db.customers.deleteOne({ _id: "100" })`	DELETE

One vs many, explicit in the name insertOne takes one document; insertMany takes an array. updateOne/deleteOne touch only the first match; updateMany/deleteMany touch every match.

Update tool	Effect
$set	Set a field's value (dot notation reaches nested fields: `"address.street"`)
$inc	Add to a number (negative value subtracts)
$mul	Multiply a number in place
$rename	Change a field's name, keep its value
$unset / $push	Remove a field / append to an array
{ upsert: true }	Update if it exists, insert if it doesn't; with false (default) nothing is created
replaceOne	Swaps the entire document: every old field is gone except _id

Query operators	Meaning
Comparison	`$eq $ne $gt $gte $lt $lte $in $nin` (`$in` is SQL's IN; `$nin` is NOT IN)
Logic	`$and $or $not`
Arrays	`$all` (contains all, any order), `$size` (exact length), `$elemMatch` (several conditions on the same element)
Other	`$exists`, `$expr`, regex such as `/^M/`; `"account.0.currency"` = first element

db.customers.find({}, { _id: 0, first_name: 1 })        // projection: 1 show, 0 hide
db.customers.find().sort({ last_name: -1 })              // 1 ascending, -1 descending
db.customers.find().limit(2).skip(1)                     // paging: skip 1, then return 2 (documents 2 and 3)
db.customers.find().limit(3).sort({ "address.city": -1 }) // same result as .sort(…).limit(3): MongoDB sorts, skips, then limits
db.customers.find({ account: { $elemMatch: { currency: "USD", balance: { $gte: 100 } } } })

Exam traps

$gt excludes the boundary, $gte includes it.
{ field: null } matches documents where the field is null and where it is missing.
With $elemMatch both conditions must hold on one array element; with plain dot notation they may be met by different elements.
.limit(0) means no limit.

5.6Indexes, including text indexes

Like PostgreSQL, MongoDB can index a field so queries skip a full scan. A text index is built for search: it enables $text/$search queries that tokenize and rank by relevance, which a plain equality or regex filter can't do.

db.articles.createIndex({ subject: "text", author: "text" })   // one text index per collection, several fields
db.articles.find({ $text: { $search: "coffee" } }, { score: { $meta: "textScore" } })
           .sort({ score: { $meta: "textScore" } })

Order matters Running $text before creating the index throws: MongoServerError: text index required for $text query.

5.7The aggregation pipeline

A sequence of stages, each passing its output to the next: SQL's GROUP BY, HAVING, ORDER BY and JOIN made explicit as a chain.

$unwindone doc per array element
$matchfilter, like WHERE
$groupaggregate by a key
$sortorder the results
$limitkeep the first n

Stage	SQL equivalent / purpose
$match	Filter documents before further processing: WHERE
$group	Aggregate by a key: GROUP BY, with accumulators $sum, $push…
$sort / $project	ORDER BY / SELECT's column list
$unwind	Flatten an array: each element becomes its own document
$lookup	MongoDB's JOIN (from, localField, foreignField, as)
$out / $merge	Write the result into a collection: a materialized view

db.purchase_orders.aggregate([
  { $match: {} },
  { $group: { _id: "$product", total: { $sum: "$total" } } },   // _id here is the GROUPING KEY
  { $sort: { total: -1 } }
])
db.customers.aggregate([
  { $unwind: "$account" },
  { $group: { _id: "$account.currency", sum_balance: { $sum: "$account.balance" } } }
])

Exam traps (mock Q5 style)

{ $sum: 1 } counts documents; { $sum: "$items.qty" } adds the field's values.
$match after $unwind filters single items, not whole orders.
$sort: { units: -1, _id: 1 }: the second key breaks ties (alphabetical _id).

$out vs $merge

	$out	$merge
Effect	Fully replaces the target collection	Decides per document: `whenMatched` (replace / merge) and `whenNotMatched` (insert)
Re-running	Wipes and rewrites	Keeps a summary up to date without wiping the rest
Position	Each may appear only once, and only as the last stage

whenMatched: "merge" keeps both documents' fields; "replace" swaps the whole matched document, so fields from the first run disappear.

Three $lookup join patterns (week05_05)

Pattern	Pipeline	Returns
"Left JOIN"	`clients` + `$lookup` orders	Every client, with an orders array (possibly empty)
"Inner JOIN"	…then `$match: { user_orders: { $ne: [] } }`	Only clients with at least one order
"Right JOIN"	`orders` + `$lookup` clients + `$unwind` with `preserveNullAndEmptyArrays: true`	Every order, even one whose client doesn't exist

5.8High availability: replication

A replica set keeps several full copies of the same data in sync on separate servers, so one failure doesn't take the database down.

Writes go to the primary; secondaries replicate from it; on failure the others elect a new primary.

Primary: The one node that receives all writes (the mock's one-word answer).
Secondary: The other nodes: they replicate from the primary and can be promoted.
Automatic failover: If the primary goes down, the remaining nodes hold an election and promote a secondary automatically, typically within seconds.
Arbiter: Votes in elections but holds no data (reference only, not on Atlas).

rs.status().members.map(m => ({ name: m.name, state: m.stateStr }))   // 1 PRIMARY, 2 SECONDARY
db.hello().primary              // which node is the primary
db.hello().isWritablePrimary    // true only on the primary

High availability means the database survives a server failure, not that failures never happen. Replica-set admin commands (rs.initiate, rs.add) are reference only: Atlas's control plane owns membership.

5.9High performance: sharding

Sharding splits one large collection across servers by a shard key; config servers hold the cluster's metadata.

Replication

Copies the same data everywhere: high availability. M0 already is a replica set.

Sharding

Splits a large collection across servers by a shard key: high performance. Needs a dedicated M30+ cluster; not on the free tier.

5.10Backup, restore, export and import

Tool	Does
mongodump / mongorestore	Back up and restore whole databases or single collections (BSON)
mongoexport / mongoimport	The same idea for one collection, as JSON or CSV

mongodump --uri "mongodb+srv://<user>:<pw>@cluster0.xxxxx.mongodb.net/" --db it8417_bank --collection customers --out ./backups
mongorestore --uri "mongodb+srv://…" -d it8417_bank -c customers ./backups/it8417_bank/customers.bson

These are terminal commands (MongoDB Database Tools), not mongosh commands. Against Atlas they work the same: just point them at the cluster with --uri.
Atlas's own automatic cloud backups exist, but not on the free tier.

5.11Common pitfalls and troubleshooting

Symptom	Likely cause	Fix
Can't connect at all	Your IP isn't on the Network Access allow-list	Add Current IP Address, retry
Authentication failed	Password not substituted into the connection string, or special characters unescaped	Re-copy the string, replace <password> carefully
insertMany fails partway	One document has invalid syntax	Check each document is valid on its own
find() returns nothing expected	Field name or value doesn't exactly match	Run `find()` with no filter first
$text throws "index required"	The text index hasn't been created	Run `createIndex()` first
mongodump can't connect	--uri missing user/password, or IP not allow-listed	Copy the exact Atlas connection string

5.12Questions from your Phase 1 PDF

The 17 questions of the PDF that belong to this week, with the same numbers. Answer each one first, then open its answer.

Q5True/False · 1 markPart A

To keep it free, a MongoDB Atlas M0 cluster runs on a single server node with no replica set.

True
False

Show answer

Answer: False

Even the free M0 cluster is a real 3-node replica set (one PRIMARY, two SECONDARY), as rs.status() shows in the lab. What M0 cannot do is sharding, which needs M30+.

Source: Week 5 slide 10 / handout §8 (“The detail that matters most this week”).

Q16Multiple choice · 2 marksPart A

Each customer has one home address that is always read together with the customer. Each customer also has orders that keep growing without limit and are used by other reports too. Following the course’s rule of thumb, how should these be modelled?

a.Embed both the address and the orders inside the customer document
b.Reference the address in its own collection; embed the orders array
c.Reference both of them, each kept in a separate collection
d.Embed the address; reference the orders in their own collection

Show answer

Answer: d. Embed the address; reference the orders in their own collection

Embed what belongs to one parent and is read together (the address); reference what is large, shared or grows without bound (the orders). Trap (a): an unbounded embedded array is exactly the problem the rule warns about.

Source: Week 5 slide 9 / handout §7 (rule of thumb).

Q17Multiple choice · 2 marksPart A

Which statement about MongoDB replication and sharding is correct?

a.Replication splits a large collection across servers by a shard key.
b.Sharding keeps a full copy of the same data on every server.
c.Sharding splits a collection by a shard key; each shard is a replica set.
d.The free M0 tier allows sharding, but replication needs a paid, dedicated cluster.

Show answer

Answer: c. Sharding splits a collection by a shard key; each shard is a replica set.

Replication copies the SAME data to every member; sharding SPLITS a collection by a shard key, a mongos router sends each query to the right shard, and each shard is its own replica set. (a) and (b) swap the two ideas; (d) is reversed: M0 is a replica set, sharding needs M30+.

Source: Week 5 slides 15–16 / handout §13–14.

Q21Matching · 4 marksPart A

Match each description with the aggregation stage that does it. Each stage is used at most once; one stage is not used.

1. Filters documents before further processing, like SQL’s WHERE.	Choose… ▾
2. Aggregates documents by a key, like SQL’s GROUP BY, using accumulators such as $sum and $push.	Choose… ▾
3. Flattens an array field so that each element becomes its own document.	Choose… ▾
4. Pulls in matching documents from another collection, like a JOIN.	Choose… ▾
5. Writes the result into a collection, updating the documents that match and inserting new ones, while leaving the other documents in that collection untouched.	Choose… ▾

Options in every list: $group · $lookup · $match · $merge · $out · $unwind

Show answer

Answer: 1 → $match · 2 → $group · 3 → $unwind · 4 → $lookup · 5 → $merge · ($out is not used)

1. $match is the WHERE of a pipeline.
2. $group is GROUP BY; its _id is the grouping key.
3. $unwind turns one document with an n-element array into n documents.
4. $lookup is MongoDB’s JOIN (from, localField, foreignField, as).
5. $merge decides per document (whenMatched / whenNotMatched); $out fully replaces the target collection, so it would not leave other documents untouched.

Source: Week 5 handout §12 (stage → SQL equivalent table); week05_04 and week05_05.

Q24One-word answer · 2 marksPart A

In a MongoDB replica set, one node is PRIMARY and receives all writes. Each of the other nodes copies the data from it and can be promoted automatically if it fails. What is each of these other nodes called? (one word)

Answer:

Show answer

Answer: secondary (also accept SECONDARY or secondaries)

The PRIMARY takes all writes; SECONDARY members replicate from it, and an election promotes one if the primary fails. Executed: rs.status() showed one PRIMARY and two SECONDARY, and a write sent straight to a secondary failed with not primary.

Source: Mock family F4 (one word “Primary”); Week 5 handout §13; week05_06.

Q30Code tracing (multiple choice) · 4 marksPart A

The collection orders contains exactly these documents:

{ _id: 1, branch: "Sitra", items: [
    { name: "karak",  type: "drink", qty: 2 },
    { name: "samosa", type: "snack", qty: 5 } ] }
{ _id: 2, branch: "Isa Town", items: [
    { name: "latte",  type: "drink", qty: 1 },
    { name: "karak",  type: "drink", qty: 1 },
    { name: "mocha",  type: "drink", qty: 1 } ] }
{ _id: 3, branch: "Sitra", items: [
    { name: "latte",  type: "drink", qty: 3 } ] }
{ _id: 4, branch: "Hamad Town", items: [
    { name: "karak",  type: "drink", qty: 5 },
    { name: "cookie", type: "snack", qty: 6 } ] }
{ _id: 5, branch: "Isa Town", items: [
    { name: "cookie", type: "snack", qty: 2 } ] }

What does this pipeline return?

db.orders.aggregate([
  { $unwind: "$items" },
  { $match: { "items.type": "drink" } },
  { $group: { _id: "$branch", cups: { $sum: "$items.qty" } } },
  { $sort: { cups: -1, _id: 1 } },
  { $limit: 1 }        // keeps only the first document, like .limit(1)
])

a.[ { _id: 'Sitra', cups: 5 } ]
b.[ { _id: 'Isa Town', cups: 3 } ]
c.[ { _id: 'Hamad Town', cups: 11 } ]
d.[ { _id: 'Hamad Town', cups: 5 } ]

Show answer

Answer: d. [ { _id: 'Hamad Town', cups: 5 } ]

Trace: $unwind gives one document per item; $match keeps the drinks; $group sums qty per branch (Sitra 2 + 3 = 5, Hamad Town 5, Isa Town 1 + 1 + 1 = 3); $sort by cups −1 leaves a tie at 5, broken by _id ascending, and “Hamad Town” comes before “Sitra”; $limit 1 keeps it. (a) breaks the tie the wrong way, (b) counts lines ($sum: 1), (c) sums every item (no $match).

Source: Mock family F5 (aggregation over nested item arrays; sum vs count; tie broken by a second sort key); week05_04.

Q31Code reading (multiple choice) · 4 marksPart A

The collection customers contains exactly these documents:

{ _id: 1, name: "Huda",   account: [ { currency: "USD", balance: 80 },
                                     { currency: "BHD", balance: 900 } ] }
{ _id: 2, name: "Salman", account: [ { currency: "USD", balance: 450 } ] }
{ _id: 3, name: "Noora",  account: [ { currency: "EUR", balance: 600 },
                                     { currency: "USD", balance: 120 } ] }
{ _id: 4, name: "Faisal", account: [ { currency: "BHD", balance: 300 } ] }

Which customers does this query return?

db.customers.find(
  { account: { $elemMatch: { currency: "USD", balance: { $gte: 100 } } } },
  { _id: 0, name: 1 }
)

a.Salman only
b.Salman and Noora
c.Huda, Salman and Noora
d.Huda, Salman, Noora and Faisal

Show answer

Answer: b. Salman and Noora

$elemMatch needs ONE account element that is both USD and ≥ 100: Salman (USD 450) and Noora (USD 120). Huda’s USD account holds 80; her 900 is in BHD. (c) is what { "account.currency": "USD", "account.balance": { $gte: 100 } } returns, because there the two conditions may be met by different elements (this form is beyond the scripts); (a) looks only at the first element; (d) ignores the currency.

Source: week05_02 ($elemMatch section) / Week 5 handout §10 (“$elemMatch tests several conditions against the same array element”).

Q34Code completion (select missing words) · 4 marksPart A

The collection cafes starts with exactly these documents:

{ _id: 1, name: "Gulf Brew",      city: "Muharraq", rating: 3.5, seats: 35 }
{ _id: 2, name: "Riffa Roasters", city: "Riffa",    rating: 4.8, seats: 15 }
{ _id: 3, name: "Pearl Cup",      city: "Manama",   rating: 4.0, seats: 20 }
{ _id: 4, name: "Dilmun Beans",   city: "Manama",   rating: 4.2, seats: 40 }

Run the commands below in order in mongosh. Choose the missing word in each gap so that every command does what its description says and prints exactly the result shown (including any comment line).

(a) Add one new café.

db.cafes.1insertOne / insertMany({ _id: 5, name: "Sitra Sips", city: "Sitra", rating: 3.9, seats: 12 })

Result shown:

{ acknowledged: true, insertedId: 5 }

(b) Give every Manama café 5 more seats.

db.cafes.2updateOne / updateMany / replaceOne({ city: "Manama" }, { 3$set / $inc / $mul: { seats: 5 } })

Result shown:

{ acknowledged: true, insertedId: null, matchedCount: 2, modifiedCount: 2, upsertedCount: 0 }
// afterwards Pearl Cup has 25 seats and Dilmun Beans has 45

(c) Save café 6, creating it if it does not exist.

db.cafes.updateOne({ _id: 6 }, { $set: { name: "Hidd Haven", city: "Hidd", rating: 4.1, seats: 18 } }, { upsert: 4true / false })

Result shown:

{ acknowledged: true, insertedId: 6, matchedCount: 0, modifiedCount: 0, upsertedCount: 1 }

(d) Gulf Brew’s document must become exactly { _id: 1, name: "Gulf Brew", city: "Muharraq" }.

db.cafes.5updateOne / replaceOne / insertOne({ _id: 1 }, { name: "Gulf Brew", city: "Muharraq" })

Result shown:

{ acknowledged: true, insertedId: null, matchedCount: 1, modifiedCount: 1, upsertedCount: 0 }

(e) List the cafés rated 4.0 or higher: name and rating only, without _id, highest rating first.

db.cafes.find({ rating: { 6$gt / $gte / $eq: 4.0 } }, { _id: 70 / 1, name: 1, rating: 1 }).sort({ rating: 81 / -1 })

Result shown:

[ { name: 'Riffa Roasters', rating: 4.8 }, { name: 'Dilmun Beans', rating: 4.2 },
  { name: 'Hidd Haven', rating: 4.1 }, { name: 'Pearl Cup', rating: 4 } ]

(f) Show only the name of the café with the most seats.

db.cafes.find({}, { _id: 0, name: 1 }).sort({ seats: -1 }).limit(90 / 1 / 2)

Result shown:

[ { name: 'Dilmun Beans' } ]

(g) Remove the Manama cafés.

db.cafes.10deleteOne / deleteMany({ city: "Manama" })

Result shown:

{ acknowledged: true, deletedCount: 2 }

Show answer

Answer: 1 insertOne · 2 updateMany · 3 $inc · 4 true · 5 replaceOne · 6 $gte · 7 0 · 8 -1 · 9 1 · 10 deleteMany

[1] insertOne: one document, not an array, and a single insertedId (insertMany with one document fails: Argument "docs" must be an array).
[2] updateMany: matchedCount 2, both Manama cafés; updateOne would match 1; replaceOne cannot take a $ operator.
[3] $inc: 20 → 25 and 40 → 45 means “add 5”; $set would give 5 and 5, $mul 100 and 200.
[4] true: upsertedCount 1 and insertedId 6 show the document was created; with false nothing happens.
[5] replaceOne: rating and seats disappear and the second argument has no $ operator; updateOne errors, insertOne hits a duplicate _id.
[6] $gte: Pearl Cup (exactly 4.0, printed as 4) is in the result; $gt would drop it, $eq would keep only it.
[7] 0: the result has no _id.
[8] -1: highest rating first.
[9] 1: one document; limit(0) means no limit, limit(2) gives two.
[10] deleteMany: deletedCount 2; deleteOne removes only the first match.

Source: Mock family F6 (select-missing-words completion of MongoDB commands); week05_01 and week05_02; café data in the mock practical’s style.

Q52One-word answer · 2 marksPart B

A replica-set member that votes in elections but holds no copy of the data is called an ______. (one word)

Answer:

Show answer

Answer: arbiter (any capitalisation)

An arbiter only votes in elections. The course notes it is reference only and not used on Atlas.

Source: Variant of mock family F4 (answer changes); Week 5 slide 26 (“An arbiter votes in elections but holds no data”).

Q53Code tracing (multiple choice) · 4 marksPart B

The collection orders contains exactly these documents:

{ _id: 1, branch: "Sitra", items: [
    { name: "karak",  type: "drink", qty: 2 },
    { name: "samosa", type: "snack", qty: 5 } ] }
{ _id: 2, branch: "Isa Town", items: [
    { name: "latte",  type: "drink", qty: 1 },
    { name: "karak",  type: "drink", qty: 1 },
    { name: "mocha",  type: "drink", qty: 1 } ] }
{ _id: 3, branch: "Sitra", items: [
    { name: "latte",  type: "drink", qty: 3 } ] }
{ _id: 4, branch: "Hamad Town", items: [
    { name: "karak",  type: "drink", qty: 5 },
    { name: "cookie", type: "snack", qty: 6 } ] }
{ _id: 5, branch: "Isa Town", items: [
    { name: "cookie", type: "snack", qty: 2 } ] }

What does this pipeline return?

db.orders.aggregate([
  { $unwind: "$items" },
  { $match: { "items.type": "drink" } },
  { $group: { _id: "$branch", cups: { $sum: 1 } } },
  { $sort: { cups: -1, _id: 1 } },
  { $limit: 1 }        // keeps only the first document, like .limit(1)
])

a.[ { _id: 'Hamad Town', cups: 5 } ]
b.[ { _id: 'Isa Town', cups: 4 } ]
c.[ { _id: 'Sitra', cups: 2 } ]
d.[ { _id: 'Isa Town', cups: 3 } ]

Show answer

Answer: d. [ { _id: 'Isa Town', cups: 3 } ]

$sum: 1 adds 1 per document, so after $unwind and $match it counts drink lines: Isa Town 3, Sitra 2, Hamad Town 1. (a) sums qty instead, (b) counts every line including snacks (no $match), (c) counts orders instead of lines.

Source: Variant of mock family F5 (answer changes: count instead of sum); week05_04 ($sum: 1).

Q54Code completion (select missing words) · 4 marksPart B

The collection students starts with exactly these documents:

{ _id: 1, name: "Huda",   city: "Manama",   gpa: 3.2, credits: 60 }
{ _id: 2, name: "Salman", city: "Riffa",    gpa: 3.6, credits: 90 }
{ _id: 3, name: "Noora",  city: "Manama",   gpa: 3.6, credits: 75 }
{ _id: 4, name: "Faisal", city: "Muharraq", gpa: 2.9, credits: 30 }

Run the commands below in order in mongosh. Choose the missing word in each gap so that every command does what its description says and prints exactly the result shown (including any comment line).

(a) Add two students in one command.

db.students.1insertOne / insertMany([ { _id: 5, name: "Ali", city: "Sitra", gpa: 3.0, credits: 45 },
                          { _id: 6, name: "Maryam", city: "Riffa", gpa: 3.8, credits: 100 } ])

Result shown:

{ acknowledged: true, insertedIds: { '0': 5, '1': 6 } }

(b) Change Huda’s GPA to 3.4.

db.students.updateOne({ name: "Huda" }, { 2$set / $inc / $mul: { gpa: 3.4 } })

Result shown:

{ acknowledged: true, insertedId: null, matchedCount: 1, modifiedCount: 1, upsertedCount: 0 }
// afterwards Huda’s gpa is 3.4

(c) Add 15 credits to the first Manama student only.

db.students.3updateOne / updateMany({ city: "Manama" }, { $inc: { credits: 15 } })

Result shown:

{ acknowledged: true, insertedId: null, matchedCount: 1, modifiedCount: 1, upsertedCount: 0 }
// afterwards Huda has 75 credits and Noora still has 75

(d) Update student 9 only if it already exists.

db.students.updateOne({ _id: 9 }, { $set: { name: "Yousef" } }, { upsert: 4true / false })

Result shown:

{ acknowledged: true, insertedId: null, matchedCount: 0, modifiedCount: 0, upsertedCount: 0 }

(e) Students with a GPA above 3.6 (3.6 itself not included), showing _id and name.

db.students.find({ gpa: { 5$gt / $gte: 3.6 } }, { _id: 60 / 1, name: 1 })

Result shown:

[ { _id: 6, name: 'Maryam' } ]

(f) The two students with the fewest credits, fewest first.

db.students.find({}, { _id: 0, name: 1, credits: 1 }).sort({ credits: 71 / -1 }).limit(80 / 1 / 2)

Result shown:

[ { name: 'Faisal', credits: 30 }, { name: 'Ali', credits: 45 } ]

(g) Remove one Riffa student.

db.students.9deleteOne / deleteMany({ city: "Riffa" })

Result shown:

{ acknowledged: true, deletedCount: 1 }

Show answer

Answer: 1 insertMany · 2 $set · 3 updateOne · 4 false · 5 $gt · 6 1 · 7 1 · 8 2 · 9 deleteOne

[1] insertMany: an array of two documents and insertedIds (plural); insertOne does not give insertedIds for 5 and 6.
[2] $set: the GPA becomes 3.4; $inc would give 6.6 and $mul 10.88.
[3] updateOne: matchedCount 1 and Noora unchanged; updateMany would match both Manama students.
[4] false: nothing matched and nothing was created (upsertedCount 0); true would insert _id 9.
[5] $gt: 3.6 itself is excluded, so Salman and Noora (3.6) are not shown; $gte would show them too.
[6] 1: the result shows _id.
[7] 1: fewest credits first (ascending).
[8] 2: two documents; limit(1) gives one, limit(0) means no limit.
[9] deleteOne: deletedCount 1; deleteMany would remove both Riffa students.

Source: Variant of mock family F6 (answers change); week05_01 and week05_02.

Q55Code reading (multiple choice) · 3 marksPart B

The collection contacts contains exactly these documents:

{ _id: 1, name: "Huda",   phone: "+973 3600 1111" }
{ _id: 2, name: "Salman", phone: null }
{ _id: 3, name: "Noora" }

What does this query return?

db.contacts.find({ phone: null }, { _id: 0, name: 1 })

a.[ { name: 'Salman' } ]
b.[ { name: 'Noora' } ]
c.[ { name: 'Salman' }, { name: 'Noora' } ]
d.[ ]: an empty result, because $exists is needed

Show answer

Answer: c. [ { name: 'Salman' }, { name: 'Noora' } ]

{ field: null } matches documents where the field is null AND documents where the field is missing (executed). To find only the missing ones use { phone: { $exists: false } } (Noora only). Running week05_02’s last query shows the same: find({ gender: null }) returns the customer set to null and the one with no gender field.

Source: week05_02 “null values” section (find({ gender: null }) after setting one gender to null). Beyond the slides: the script runs this query but does not show or explain its output, so the key follows what MongoDB really returns.

Q56Code tracing (multiple choice) · 3 marksPart B

The collections contain exactly these documents and quarter_report starts empty:

// purchases
{ _id: 1, quarter: "2026Q3", branch: "Manama", qty: 120 }
{ _id: 2, quarter: "2026Q3", branch: "Riffa",  qty: 80 }
{ _id: 3, quarter: "2026Q4", branch: "Manama", qty: 150 }
// returns
{ _id: 1, quarter: "2026Q3", branch: "Manama", qty: 7 }
{ _id: 2, quarter: "2026Q3", branch: "Riffa",  qty: 3 }

These two pipelines run in order:

db.purchases.aggregate([
  { $group: { _id: "$quarter", purchased: { $sum: "$qty" } } },
  { $merge: { into: "quarter_report", on: "_id",
              whenMatched: "merge", whenNotMatched: "insert" } }
])
db.returns.aggregate([
  { $group: { _id: "$quarter", returned: { $sum: "$qty" } } },
  { $merge: { into: "quarter_report", on: "_id",
              whenMatched: "replace", whenNotMatched: "insert" } }
])

What is the 2026Q3 document in quarter_report at the end?

a.{ _id: '2026Q3', purchased: 200, returned: 10 }
b.{ _id: '2026Q3', returned: 10 }
c.{ _id: '2026Q3', purchased: 200 }
d.Two documents, both with _id '2026Q3'

Show answer

Answer: b. { _id: '2026Q3', returned: 10 }

The first pipeline inserts { _id: '2026Q3', purchased: 200 }. The second matches the same _id and uses whenMatched: "replace", which swaps the whole document, so purchased disappears. With "merge" (as in the script) the result would be (a); _id is unique, so (d) cannot happen.

Source: week05_05 “Merging two DIFFERENT collections” section and its merge-vs-replace comment.

Q57Code tracing (multiple choice) · 3 marksPart B

The collections contain exactly these documents:

// clients
{ _id: 1, name: "Huda Al-Khalifa" }
{ _id: 2, name: "Salman Ahmed" }
{ _id: 3, name: "Noora Hasan" }
{ _id: 4, name: "Faisal Ali" }
// bookings
{ _id: 201, client_id: 1, room: "Seef 12" }
{ _id: 202, client_id: 1, room: "Seef 14" }
{ _id: 203, client_id: 3, room: "Juffair 3" }
{ _id: 204, client_id: 9, room: "Amwaj 7" }

How many documents does each pipeline return?

// P1
db.clients.aggregate([
  { $lookup: { from: "bookings", localField: "_id",
               foreignField: "client_id", as: "client_bookings" } }
])
// P2
db.clients.aggregate([
  { $lookup: { from: "bookings", localField: "_id",
               foreignField: "client_id", as: "client_bookings" } },
  { $match: { client_bookings: { $ne: [] } } }
])
// P3
db.bookings.aggregate([
  { $lookup: { from: "clients", localField: "client_id",
               foreignField: "_id", as: "client_info" } },
  { $unwind: { path: "$client_info", preserveNullAndEmptyArrays: true } }
])

a.P1 4 · P2 2 · P3 4
b.P1 2 · P2 2 · P3 3
c.P1 4 · P2 2 · P3 3
d.P1 4 · P2 3 · P3 4

Show answer

Answer: a. P1 4 · P2 2 · P3 4

P1 keeps every client (4), with an empty array for Salman and Faisal; P2 keeps clients whose array is not empty (Huda, Noora = 2); P3 starts from bookings (4), and preserveNullAndEmptyArrays keeps booking 204 although client 9 does not exist (without it: 3).

Source: week05_05 $lookup section (“Left JOIN”, “Inner JOIN”, “Right JOIN” patterns).

Q58Multiple choice · 1 markPart B

A new collection menu has only the default _id index (no text index yet). You run db.menu.find({ $text: { $search: "karak" } }). What happens?

a.It fails: MongoServerError: text index required for $text query.
b.It returns every document whose item field contains the word karak.
c.MongoDB builds the text index automatically and then searches.
d.It returns an empty result, because no field is called $text.

Show answer

Answer: a. It fails: MongoServerError: text index required for $text query.

$text needs a text index, so createIndex({ item: "text" }) must run first (executed). After the index exists, the same query finds “karak tea” and “Iced Karak”. Only one text index is allowed per collection.

Source: Week 5 slide 23 (“Order matters”) / week05_03.

Q59Multiple choice · 1 markPart B

According to the course, how do SQL databases and most NoSQL databases traditionally scale?

a.SQL scales horizontally; NoSQL scales vertically.
b.SQL scales vertically; NoSQL scales horizontally.
c.Both scale only vertically, with a bigger server.
d.Both scale only horizontally, with more servers.

Show answer

Answer: b. SQL scales vertically; NoSQL scales horizontally.

SQL databases traditionally scale vertically (a bigger server); most NoSQL databases are designed to scale horizontally (more servers sharing the load).

Source: Week 5 slide 4 / handout §2 (SQL vs NoSQL trade-offs).

Q60One-word answer · 1 markPart B

Documents look like JSON when you type them, but MongoDB stores them in a binary format that adds types such as dates and ObjectId. What is this format called? (one word)

Answer:

Show answer

Answer: BSON (any capitalisation)

BSON = Binary JSON: it adds types JSON lacks (dates, binary data, ObjectId) and is faster to parse and scan than text.

Source: Week 5 slide 7 / handout §5 (JSON vs BSON).