Free C100DBA Practice Test Questions and Answers (2026)

The aggregation pipeline consists of two stages. The first stage, $match, filters the documents from the posts collection, selecting only those where the likes field is greater than 100 and less than 200. The second stage, $group, takes these filtered documents and groups them. By specifying id: null, all documents are grouped into a single result. The $sum: 1 accumulator then counts the number of documents in this group, effectively calculating the total count of posts that met the match criteria.

A. The query does not modify the id of the original documents; id: null is used to group all documents into one for counting in the output.
B. The query groups all matched documents into a single group (id: null), not by the individual number of likes.
D. This incorrectly describes the $group stage. It doesn't set the id of the first document and increment; it counts all matched documents.

- MongoDB Documentation

$match (aggregation). (See documentation for the specific MongoDB version relevant to C100DBA

e.g.

4.4

5.0). This stage filters documents.

- MongoDB Documentation

$group (aggregation). The id field specifies the group key. Using id: null groups all input documents into a single output document.

- MongoDB Documentation

$sum (aggregation). When used with a value of 1 in a $group stage

$sum returns the total count of documents in the group.

When backing up a sharded cluster, it is crucial to ensure data consistency across all shards. The cluster's balancer process migrates data chunks between shards to maintain an even distribution. If a backup is performed while the balancer is active, chunks could be in transit, leading to an inconsistent state where data is either missing or duplicated in the backup. To prevent this, the balancer must be stopped before initiating the backup process. The correct mongosh command to achieve this is sh.stopBalancer().

A. db.stopBalancer(): This is not a valid command. Balancer control commands are executed against the sh helper object in mongosh.
B. db.stopserver(): This is not a valid command, and stopping a server is the incorrect action for ensuring a consistent backup.
D. sh.stopserverQ: This is not a valid command. The goal is to stop the balancer process, not shut down a server.

MongoDB Manual, "Back Up a Sharded Cluster with Filesystem Snapshots", Section: "Disable the Balancer". This section states, "The balancer for the sharded cluster must be stopped before starting the backup."

MongoDB Manual, sh.stopBalancer(). This page provides the syntax and description for the command used to disable the balancer.

A replica set requires a strict majority of its voting members to be available to elect a primary. An odd number of voters ensures that a majority can always be achieved, even during a network partition. If a replica set is split into two pieces by a network failure, only the partition with a majority of voters can elect a new primary. This prevents a "split-brain" scenario where both partitions might otherwise attempt to elect a primary, leading to data inconsistencies. Arbiters are a lightweight way to add a vote to achieve an odd number without the overhead of storing data.

A. While replica sets aid disaster recovery, the specific importance of an odd number of voters is to maintain operational consistency during network partitions, not DR in general.
C. Read preference settings determine where read operations are routed and are not dependent on the number of voters in the replica set.
D. Arbiters do not hold a copy of the data, so they add a vote for election purposes but do not increase data redundancy.
E. The number of voters in a replica set has no direct bearing on the efficiency of backup operations.

- MongoDB Manual, Replication, Replica Set Elections. "To be elected, a candidate must receive votes from a majority of the voting members of the replica set... Using an odd number of voting members ensures that the replica set is always able to elect a primary."

- MongoDB Manual, Replication, Replica Set Members, Arbiters. "Adding an arbiter to a replica set is a common strategy for replica sets with an even number of members... to ensure that the replica set has an odd number of voting members."

The replication factor in this context refers to the number of data-bearing nodes in the replica set. The replica set consists of one primary, three secondaries, and one arbiter. Both primary and secondary members maintain a full copy of the data. An arbiter, however, does not hold a copy of the data; it only participates in elections. A hidden secondary is still a data-bearing node. Therefore, the total number of data-bearing nodes is the sum of primaries and secondaries: 1 (primary) + 3 (secondaries) = 4.

A. 7: This number does not correspond to any logical count of members or data copies in the described topology.
B. 03: This incorrectly excludes one of the data-bearing nodes, such as the primary or one of the secondaries.
D. 06: This number is greater than the total number of members (5) in the replica set and is therefore incorrect.

1. MongoDB Documentation, "Replica Set Members". (2023). "A replica set can have the following types of members: Primary... Secondary... Arbiter." The document clarifies that primaries and secondaries hold data, while arbiters do not. Retrieved from https://www.mongodb.com/docs/manual/core/replica-set-members/.

2. MongoDB Documentation, "Hidden Replica Set Members". (2023). "Hidden members maintain a copy of the primary's data set...". This confirms hidden members are data-bearing. Retrieved from https://www.mongodb.com/docs/manual/core/replica-set-hidden-member/.

3. MongoDB University, M103: Basic Cluster Administration. Course materials explain that only primary and secondary nodes are data-bearing, while arbiters are not.

The $slice projection operator is specifically designed to control the number of elements returned from an array field in a query result. It can be used to return the first n elements, the last n elements, or a specific subset of elements from the array by specifying a number of elements to skip and a number to return. This provides precise control over which part of an array is included in the output documents, which is useful for managing large arrays or for pagination.

A. The $elemMatch projection operator returns only the first element in an array that matches the specified condition, not a configurable number of items.
C. The $ positional projection operator returns only the first array element that matches the query condition, similar to $elemMatch but with a different syntax.
D. This statement is false. MongoDB provides several operators, most notably $slice, for retrieving partial array content.

1. MongoDB Manual, Projection Operators, $slice. "The $slice projection operator specifies the number of elements in an array to return in the query result." The documentation provides examples for returning the first n, last n, and a sub-section of an array.

2. MongoDB Manual, Projection Operators, $elemMatch (projection). "The $elemMatch operator projects the first element in an array that matches the specified $elemMatch condition."

3. MongoDB Manual, Projection Operators, $ (projection). "The positional $ operator limits the contents of an to return the first element that matches the query condition on the array."

MongoDB Ops Manager is the on-premises platform for managing MongoDB. It provides a comprehensive suite of services for monitoring, alerting, automation, and backup for self-hosted MongoDB deployments. Its functionality is equivalent to that of MongoDB Cloud Manager, which offers similar services but for MongoDB Atlas (the cloud-hosted database-as-a-service). Ops Manager allows organizations to run MongoDB in their own data centers while retaining the operational advantages and management tools available in the cloud.

A. Service Manager is not a MongoDB product; it's a generic term and not the name of the on-premise management solution.
B. Replica Manager is not a specific MongoDB tool. Replica sets are a core feature of MongoDB, not a separate management product.
D. Journaling is a durability feature of the WiredTiger storage engine in MongoDB, not a management platform.

1. MongoDB, Inc. "MongoDB Ops Manager" (Product Documentation). The official product page states, "Ops Manager is the best way to run MongoDB in your own data center or private cloud." It details features like automation, backup, and monitoring, which are parallel to Cloud Manager.

2. MongoDB Manual, "MongoDB Ops Manager". The introduction describes Ops Manager as "an on-premise management solution for MongoDB that provides for the monitoring, backup, and automation of MongoDB instances."

MongoDB provides high availability and fault tolerance through replication. Replication involves maintaining multiple copies of data across a group of servers, known as a replica set. If the primary server in the replica set fails, an automatic failover process occurs, and one of the secondary servers is elected as the new primary. This process ensures that the database remains operational and accessible even in the event of a server failure, which is the core of high availability.

A. Sharding is a method for horizontal scaling to distribute large datasets across multiple servers; it does not inherently provide high availability on its own.
B. Indexing is a feature used to improve query performance by reducing the amount of data the query engine has to scan.
D. Write concern specifies the level of acknowledgment for write operations, ensuring data durability, but it is not the mechanism for system-wide fault tolerance.

1. MongoDB Manual, "Replication". The introduction states, "Replication provides redundancy and increases data availability... Replication protects a database from the loss of a single server." (https://www.mongodb.com/docs/manual/replication/)

2. MongoDB Manual, "High Availability". This section details how replica sets provide automatic failover to support high availability. (https://www.mongodb.com/docs/manual/core/replica-set-high-availability/)

This question aims to find documents where the posttimestamp field is of the BSON type Null. The correct operator for this is $type. The BSON type code for Null is 10, and its string alias is "null". Therefore, the correct query is db.posts.find({ posttimestamp: { $type: 10 } }) or db.posts.find({ posttimestamp: { $type: "null" } }). Option C, despite its severe syntax errors ($type; 10 > >), is the only one that contains both the correct operator ($type) and the correct BSON type code (10), making it the intended answer, assuming typos are corrected.

A. $fieldtype is not a valid MongoDB query operator. The correct operator to query by BSON type is $type.
B. The $type operator requires a BSON type number or a string alias (e.g., "null"), not the value null itself. This syntax is invalid.
D. $fieldtype is not a valid MongoDB query operator. This option is incorrect for the same reason as option A.

- MongoDB Documentation

Query and Projection Operators

$type. This page lists the available BSON types and their corresponding numbers and string aliases.

- MongoDB Documentation

BSON Types. This page explicitly states that the number for the Null type is 10 and its alias is "null".

This query correctly uses the aggregation framework's $group stage to meet the requirements. It groups documents by a compound id key composed of the state and city fields. The $sum accumulator is then used with the field path "$pop" to calculate the total of the pop field for all documents within each group. This provides the total population for each unique state and city combination. (Note: The provided option contains typos, but its structure is the only one that correctly implements the required logic).

A. This option has multiple syntax errors and uses $sum: 1, which counts documents rather than summing the values in the pop field.
B. This option has syntax errors and uses $pop, which is an update operator and not a valid accumulator for the $group stage.
D. This query incorrectly groups only by city, failing to meet the requirement of grouping by both state and city.

1. MongoDB Manual, $group (aggregation): "Groups input documents by the specified id expression and for each distinct grouping, outputs a document." (https://www.mongodb.com/docs/manual/reference/operator/aggregation/group/)

2. MongoDB Manual, $sum (aggregation): "Calculates and returns the collective sum of numeric values. $sum ignores non-numeric values." (https://www.mongodb.com/docs/manual/reference/operator/aggregation/sum/)

3. MongoDB University, M121: The MongoDB Aggregation Framework, Chapter 2, "Basic Aggregation - $group and $match". This courseware covers the fundamental usage of $group with a compound id and accumulators like $sum.

The statement "MongoDB is a schema-less design" is considered true. MongoDB uses a document data model, which allows for a flexible schema. Unlike traditional SQL databases that require a predefined table structure, documents in a MongoDB collection do not need to have the same set of fields or structure. This flexibility facilitates easier application development and data model evolution. While the term "flexible schema" is more precise, "schema-less" is widely used to describe this core characteristic. MongoDB also provides optional schema validation to enforce structure when needed.

False: This is incorrect because MongoDB's fundamental design does not enforce a rigid, predefined schema on collections, which is the primary characteristic of a schema-less or flexible-schema database.

1. MongoDB Manual, Data Modeling Introduction. "Data in MongoDB has a flexible schema. Unlike SQL databases, where you must determine and declare a table's schema before inserting data, MongoDB's collections, by default, do not require their documents to have the same schema."

2. MongoDB Manual, Schema Validation. "Starting in MongoDB 3.2, you can enforce schema validation on a collection during update and insert operations. However, validation is optional and not enabled by default."

The mongoexport tool exports data from a MongoDB collection into a human-readable format like JSON or CSV. The mongoimport tool imports data from human-readable formats (JSON, CSV, TSV) into a collection. Both tools, therefore, allow a user to work with data in a human-readable text format, either for extraction or for ingestion. mongodump creates a binary BSON file, which is not human-readable. mongostat displays performance statistics, not collection data.

A. mongodump creates a binary (BSON) backup of data, which is not directly human-readable and is intended for machine processing and restoration via mongorestore.
B. mongostat is a diagnostic tool that provides a real-time view of database server statistics and performance metrics, not the data itself.

1. MongoDB Manual, mongoexport, "Output Formats". The documentation states, "mongoexport can export data in either comma-separated values (CSV) or JavaScript Object Notation (JSON) formats." (https://www.mongodb.com/docs/database-tools/mongoexport/#output-formats)

2. MongoDB Manual, mongoimport, "mongoimport". The documentation specifies it "imports content from an Extended JSON, CSV, or TSV file". (https://www.mongodb.com/docs/database-tools/mongoimport/)

3. MongoDB Manual, mongodump, "Behavior". It states, "mongodump reads data from a MongoDB database and creates high-performance BSON files." (https://www.mongodb.com/docs/database-tools/mongodump/#behavior)

The positional $ operator is specifically designed to identify an element in an array for an update without knowing its index. It acts as a placeholder in the update document, referring to the first element that matched the query condition of the update operation. This allows for targeted modifications of array elements based on their value or content rather than their position.

A. $elemMatch is a query operator used in the query portion of a find or update operation to match documents, not a positional operator for updates.
B. $slice is an operator used to limit the number of elements in an array during projection or updates, not to identify a specific one for modification.
C. This statement is factually incorrect; the positional $ operator provides exactly this functionality.

1. MongoDB Manual, Update Operators, Positional $ Operator, Version 7.0. "The positional $ operator identifies an element in an array to update without explicitly specifying the position of the element in the array."

2. MongoDB University, M103: Basic Cluster Administration, Chapter 3: "CRUD", Lecture: "Updating Documents". This courseware explains the use of the positional $ operator for updating array elements.

MongoDB has robust, built-in support for geospatial data. It allows you to store geospatial data as GeoJSON objects or legacy coordinate pairs and query this data efficiently. This is enabled through specialized geospatial indexes, such as 2dsphere for calculations on an earth-like sphere and 2d for calculations on a two-dimensional plane. These are core, first-class features of the database used for location-based applications.

B. MongoDB supports some of the SQL functions: MongoDB uses its own query language (MQL). While its aggregation framework has operators analogous to SQL functions, it does not directly support SQL syntax or functions.
C. MongoDB uses JSON format to represent documents: MongoDB uses BSON (Binary JSON) for data storage and network transfer. BSON is more performant and supports additional data types not found in JSON.
D. MongoDB supports collection joins: MongoDB provides the $lookup aggregation stage, which performs a left outer join. However, this is more limited than traditional SQL joins, so stating it supports "collection joins" without qualification can be misleading. Option A is a more precise and fundamental truth.

- MongoDB Manual, "Geospatial Queries". This section provides a comprehensive overview of MongoDB's geospatial capabilities, including data formats, index types (2dsphere, 2d), and query operators.

- MongoDB Manual, "Geospatial Indexes". Details the creation and usage of 2dsphere and 2d indexes, confirming them as a core feature.

- MongoDB Manual, "Aggregation Pipeline Stages, $lookup". Describes the specific functionality and limitations of MongoDB's join-like operation.

The statement that both find() and findOne() return cursors is incorrect. The db.collection.find() method returns a cursor object, which points to the result set of a query. The client application can then iterate through the cursor to retrieve the documents. In contrast, the db.collection.findOne() method executes a search for a single document and returns that one document object directly, not a cursor. This makes findOne() a more direct way to retrieve a single record.

A. This statement is functionally correct; find() is used to get multiple documents (via a cursor) and findOne() gets the first one.
B. This is a correct statement. find().limit(1) returns a cursor, whereas findOne() returns a document object, making their return types different.
C. This is a correct statement. findOne() retrieves and returns the first document that matches the query criteria based on the natural order or a specified sort order.

1. MongoDB Manual, "db.collection.findOne()". The documentation explicitly states, "Returns one document that satisfies the specified query criteria on the collection or view." The return value is described as a document.

2. MongoDB Manual, "db.collection.find()". The documentation states, "Selects documents in a collection or view and returns a cursor to the selected documents."

3. MongoDB University, M001: MongoDB Basics, "findOne vs find". The course material distinguishes between the two methods, highlighting that find() returns a cursor that can be iterated, while findOne() returns the document itself.

The replication factor of a replica set refers to the total number of data-bearing members. In the described configuration, there is one primary and three secondaries. All primaries and secondaries, including hidden members, maintain a full copy of the dataset and are therefore data-bearing. Arbiters, however, do not hold a copy of the data; they only participate in elections. Therefore, the replication factor is the sum of the data-bearing nodes: 1 (primary) + 3 (secondaries) = 4.

A. None of the above: The replication factor is calculable from the given information and is 4.
B. 5: This count incorrectly includes the arbiter, which is not a data-bearing node and does not contribute to data redundancy.
C. 3: This count only includes the secondary members, omitting the primary node which also holds a complete copy of the data.

MongoDB Manual, "Replica Set Members". This page details the roles of different members.

MongoDB Manual, "Replica Set Arbiters". The documentation explicitly states, "Arbiters do not maintain a data set. Arbiters exist solely to respond to heartbeat and election requests."

MongoDB University, M103: Basic Cluster Administration, Chapter 2: Replication, "Replica Set Architecture" lecture.

The db.collection.update() method behaves differently based on the update document provided. When the update document (the second parameter) does not contain any update operators (like $set, $inc, etc.), MongoDB performs a full replacement. In this query, the document {Title:"This is post with ID 1"} will completely replace the existing document that matches the filter {id:1}. Any other fields in the original document will be removed.

A. Syntax error: The syntax is valid for an update operation. The l is likely a typo for 1, but even as a variable l, the command is syntactically correct.
C. Updates the Title of the post: This would only occur if the update operator $set was used, like so: {$set: {Title: "This is post with ID 1"}}.
D. Updating a document is possible only with $set: This is false. MongoDB supports many update operators ($inc, $push, etc.) and also allows for full document replacement.

1. MongoDB Manual. "db.collection.update()". The documentation states: "By default, the update() method updates a single document. ... If the document contains only field and value pairs, the update() method replaces the existing document...".

2. MongoDB Manual. "Update Documents with Replacement". This section provides a specific example: "To replace the entire document except for the id field, pass an entirely new document as the second argument to db.collection.update()."