C100DBA Questions and Answers

Replica-set elections determine which eligible member serves as primary. An election can occur after the current primary becomes unavailable, after certain reconfigurations, during replica-set initialization, or when a primary is deliberately stepped down. Eligible voting members exchange election information and, when a candidate obtains the required support, that candidate transitions to primary and begins accepting writes. Option A describes asynchronous replication through the oplog, which is a separate mechanism. Option C is unrelated: index creation is an administrative database operation, not a function of elections. Option D is also incorrect because elections do not add members to the replica-set configuration; adding a secondary requires an explicit membership change such as rs.add() or equivalent configuration management. Elections are the foundation of automatic failover and are one reason MongoDB replica sets can provide high availability without a human manually designating a replacement primary after every failure. During an election there can be a brief period in which writes are unavailable, so applications should use retryable behavior and appropriate driver topology handling. The purpose described in option B is therefore correct.

Study Guide reference/topic:Cluster Reliability and Data Resilience - replica-set elections, primary selection, voting, and automatic failover.

===========

Queryable Encryption is designed for client-side protection of sensitive fields while preserving supported query capabilities over encrypted values. With this model, appropriately configured client drivers encrypt selected fields before data is transmitted to the MongoDB server and decrypt authorized results on the client side. That architecture is well suited to highly sensitive PII such as government identification numbers, dates of birth, or regulated demographic information because the database server stores encrypted field values rather than plaintext for those protected fields. The Encrypted Storage Engine, option A, protects database files at rest but the server can still process decrypted data internally. TLS/SSL, option B, protects data while it is moving across the network, not the application field values from the database server itself. Role-Based Access Control, option C, restricts which authenticated principals can perform actions but does not itself cryptographically protect the field contents. Queryable Encryption complements, rather than replaces, TLS, authentication, authorization, auditing, and storage encryption. For the specific requirement of client-side encryption of sensitive application data, option D is the correct MongoDB feature.

Study Guide reference/topic:Security, Networking, and Encryption - Queryable Encryption, client-side encryption, sensitive fields, and key management.

===========

When MongoDB ' s winning query plan uses a B-tree index, the plan includes an IXSCAN stage. That stage contains the index-specific information a DBA needs to identify how the query is being serviced, including the key pattern, index name, traversal direction, and index bounds. For example, keyPattern can show a compound definition such as { status: 1, createdAt: -1 }, making it straightforward to confirm which indexed keys participate in the chosen plan. A FETCH stage indicates that MongoDB is retrieving full documents, often after an index has produced candidate record identifiers; the fetch stage itself does not identify the index key. A COLLSCAN stage means MongoDB is scanning the collection and therefore is not using a normal index scan for the predicate. GROUP is unrelated to index selection. Effective DBA query analysis usually involves inspecting both queryPlanner.winningPlan and execution statistics such as totalKeysExamined, totalDocsExamined, and nReturned. But for the narrow question of which stage exposes the index key used by the winning plan, IXSCAN is the correct answer. Therefore option C is correct.

Study Guide reference/topic:Indexing and Query Optimization - explain output, winning plans, IXSCAN, key patterns, and index bounds.

===========

Sharding is MongoDB ' s horizontal-scaling mechanism: it partitions a collection ' s data across multiple shards so a deployment can scale storage capacity and distribute query or write workload beyond the limits of one server. That directly supports deployments with very large datasets and high-throughput operations, making C correct. MongoDB also supports zone sharding, which associates ranges of shard-key values with selected shards. Zones can be used to keep particular data near a geographical region, satisfy locality requirements, or map data ranges to hardware tiers, so A is also correct. Option B overstates what sharding itself provides; cross-region consistency behavior depends on replication topology, read/write concerns, latency, and application design rather than simply enabling sharding. Option D describes a deployment that already fits comfortably in memory and meets performance goals, so sharding may add unnecessary operational complexity. Option E primarily describes replication: replica sets maintain redundant copies, provide elections, and improve availability. Production shards are themselves normally replica sets, but redundancy is a replication function rather than the defining purpose of sharding. Therefore the two functions represented here are geographic zone distribution and horizontal scale: A and C.

Study Guide reference/topic:Sharding Strategies and Scalable Deployments - horizontal scaling, large datasets, throughput, shard keys, and zone sharding.

The --fork option starts mongod in daemon mode so the server process continues in the background. When --fork is used, MongoDB requires diagnostic output to be redirected through a logging destination such as --logpath or --syslog; the process cannot simply detach while continuing to use the normal foreground output stream. Option C supplies both --fork and a valid log path, while leaving the other server settings at their normal defaults unless they are configured elsewhere. Option A explicitly sets the default port but does not satisfy the logging requirement associated with --fork. Option B treats the literal word default as a filesystem path and does not provide the required log destination. Option D uses an unsupported --default switch. In production, MongoDB packages commonly use service managers such as systemd, and a configuration file is usually preferred over manually launching mongod with a long list of command-line options. Nevertheless, among the commands shown, C is the one that correctly daemonizes the server process and provides the logging configuration required for a successful fork.

Study Guide reference/topic:MongoDB Architecture and Core Operations - mongod startup, background execution, logging, and server configuration.

===========

An upsert combines update behavior with conditional insertion. updateOne() first searches for a document matching { product: " laptop " }. If one exists, $set changes unitsInStock to 25. If none exists and the options document contains { upsert: true }, MongoDB inserts a new document based on the equality portions of the filter together with the update result. Option A uses exactly this pattern. Options B and C incorrectly use insertOne(), which inserts a supplied document and does not accept an update-operator document plus upsert semantics in this form. Option D uses the correct method and update structure but specifies True with a capital T. Mongosh uses JavaScript Boolean syntax, so the literal must be lowercase true. Upserts are useful when an application needs to ensure that a logical entity exists after an operation, but DBAs should consider a unique index on the identifying field when duplicate creation by concurrent requests must be prevented. Given the choices, updateOne(..., {$set:...}, {upsert:true}) is the valid operation, so A is correct.

Study Guide reference/topic:MongoDB Architecture and Core Operations - updateOne(), $set, upserts, and Boolean syntax.

===========

logLevel is a MongoDB server parameter, and server parameters are retrieved through the administrative getParameter database command. The documented and unambiguous mongosh form is db.adminCommand({ getParameter: 1, logLevel: 1 }), which executes the command against the admin database and requests the current value of logLevel. The first numeric value activates the command, while the logLevel field identifies the parameter to return. Options B and C refer to a db.getParameter() helper that is not the documented interface. Option A uses db.runCommand() without explicitly switching to the admin database. Because getParameter is an administrative command, db.adminCommand() is the correct and reliable form among the choices. Administrators use server parameters to inspect and, where supported, tune aspects of mongod or mongos behavior. logLevel controls global diagnostic verbosity, while component-specific verbosity can be managed through the logging configuration. For this question, option D precisely matches the expected administrative syntax. Checking the current value before changing logging settings is also a sound operational practice during troubleshooting.

Study Guide reference/topic:Performance Monitoring and Tuning - runtime server parameters, logging configuration, and getParameter.

===========

MongoDB provides db.grantRolesToUser() specifically for assigning one or more additional roles to an existing user. The method takes the username as its first argument and an array of roles as its second argument, so db.grantRolesToUser( " user1 " , [ " customRole1 " ]) is the correct choice. A role can be supplied as a simple string when it belongs to the current database or as an explicit document such as { role: " customRole1 " , db: " admin " } when the database context must be specified. Option B uses db.createUser(), which is used to create a new user rather than modify the role membership of an account that already exists. Options A and C use method names that are not the documented mongosh interfaces for this operation. Administrators should also distinguish grantRolesToUser() from grantRolesToRole(): the latter makes a user-defined role inherit other roles, whereas the former directly changes a user ' s assigned roles. Least-privilege practice requires granting only roles necessary for the user ' s responsibilities. For the requested update to the existing user, option D is correct.

Study Guide reference/topic:Security, Networking, and Encryption - user administration, role assignment, RBAC, and grantRolesToUser().

===========

MongoDB supports direct equality matching against elements contained in an array. When the predicate is { sizes: " M " } and sizes is an array field, a document matches when at least one element of the array equals the scalar value " M " . Document 1 contains only " XS " and " S " , so it does not match. Document 2 contains " M " in [ ' S ' , ' M ' , ' XL ' ], and document 3 contains " M " in [ ' M ' , ' L ' , ' XL ' , ' XXL ' ]; both therefore match. No $elemMatch expression is required for this simple scalar membership test. $elemMatch becomes important when multiple conditions must be satisfied by the same array element, particularly for arrays of embedded documents or compound conditions. This array equality behavior is a core part of MongoDB ' s document query model and allows concise filtering of array-valued fields. The correct result is consequently the t-shirt and vest documents, which corresponds to option D. This same matching behavior applies consistently whenever a scalar predicate targets values stored inside a BSON array field.

Study Guide reference/topic:MongoDB Architecture and Core Operations - querying array fields and equality predicates.

===========

The first argument to find() is the query filter and the second argument is the projection. Because the requirement applies to every employee, the filter must be an empty document {}. The projection must include name and age while explicitly suppressing _id. MongoDB includes _id by default even in inclusion projections, so { name: 1, age: 1 } would return three fields: _id, name, and age. Adding _id: 0 is the documented exception that allows _id to be excluded from an otherwise inclusion-style projection. Option C therefore produces exactly the requested fields. Options A and B mistakenly place projection-like expressions in the filter position, which would cause MongoDB to search for documents where those fields literally match the specified values rather than controlling returned fields. Option D is close but violates the word “ONLY” because _id remains present. Projection design can also reduce network traffic and, when a suitable index covers both the predicate and projected fields, can contribute to covered-query plans. For this requirement, however, the essential syntax is find({}, {name:1, age:1, _id:0}), so C is correct.

Study Guide reference/topic:MongoDB Architecture and Core Operations - find(), filters, projections, inclusion fields, and _id exclusion.

===========

MongoDB exposes server parameters that can be configured through the parameter framework. Among the choices, --setParameter is the option specifically designed to set a server parameter on the mongod command line, using syntax such as mongod --setParameter < name > = < value > . A configuration file can also contain a setParameter section, but --config by itself merely tells mongod which configuration file to load; it is not the parameter-setting mechanism identified by the question. Connection-string options control how clients connect and cannot be used to configure arbitrary server runtime parameters. Option D is also incorrect because the server must already be running for mongosh to issue administrative commands. A technical nuance is important: parameters that support modification while the process is already running are changed with the administrative setParameter command, for example db.adminCommand({setParameter:1, ...}). Such runtime changes may not persist across a restart unless the value is also configured for startup. Given the options provided and the exam wording, --setParameter is the intended method, so A is correct.

Study Guide reference/topic:MongoDB Architecture and Core Operations - server parameters, --setParameter, configuration files, and runtime administration.

===========

The quantity condition is “less than or equal to 1000,” which maps to MongoDB ' s $lte comparison operator. The sales representative condition is “not equal to Anne,” which maps to $ne. When predicates on two different fields appear in the same query document, MongoDB applies an implicit logical AND, so both conditions must be true for a document to match. Option C therefore expresses exactly the requested filter: { quantity: { $lte: 1000 }, salesRep: { $ne: " Anne " } }. Options A and D use $neq, which is not MongoDB ' s inequality operator. Options B and D use $lt, which excludes documents whose quantity is exactly 1000 and therefore fails the “less than or equal” requirement. One nuance of $ne is that it can also match documents where the field is missing, because a missing field is not equal to the specified value. If the application requires salesRep to exist as well, an explicit existence predicate may be appropriate. For the wording shown, however, option C is the correct command.

Study Guide reference/topic:MongoDB Architecture and Core Operations - comparison predicates, $lte, $ne, and implicit AND semantics.

===========

The outer $or returns a document if either branch is true. Document 1 satisfies the first branch because product equals " x-small box " , so it is included regardless of the second branch. The nested $and requires both qty != 50 and the absence of " brown " from the colors array. Document 2 has quantity 60 but contains " brown " , so it fails $nin. Document 3 has quantity 45 and its colors do not include brown, so it satisfies both conditions. Document 4 has no brown but quantity is exactly 50, so it fails $ne: 50. Document 5 has quantity 10 and colors [ ' grey ' , ' white ' ], so it also satisfies both nested predicates. The final set is therefore documents 1, 3, and 5. This question also illustrates that MongoDB applies an implicit AND between multiple top-level field predicates in the same document, but here the explicit $and makes the required conjunction clear. Option D is the only answer containing exactly the matching documents.

Study Guide reference/topic:MongoDB Architecture and Core Operations - logical query operators, $or, $and, $ne, and $nin.

===========

The query first applies .sort({ price: -1 }). In MongoDB, -1 specifies descending order, so the result stream is ordered from the highest price to the lowest: Laptop at 1500, Smartphone at 800, Tablet at 600, Monitor at 300, and Headphones at 200. The subsequent .limit(2) restricts the cursor to the first two documents in that sorted sequence. Therefore, only Laptop and Smartphone are returned. Option B identifies the two lowest-priced products rather than the highest. Option C reflects the sort but ignores the limit(2) stage. Option D shows the two lowest products in ascending order and therefore contradicts both the requested sort direction and the limit semantics. For a large collection, a single-field index on price could support this sort efficiently because MongoDB can traverse an index in either direction; an ascending index can be scanned backward to satisfy a descending sort and vice versa. The logical query result, however, is independent of whether such an index exists. Option A is the correct output.

Study Guide reference/topic:MongoDB Architecture and Core Operations - cursor sorting, limiting result sets, and query result ordering.

===========

The proposed index is a compound index across home_score and away_score. MongoDB supports compound multikey indexes, but it imposes an important restriction: for any one indexed document, no more than one field covered by the compound index may contain an array. Document 1 is valid because only away_score is an array. Document 2 is also valid because only home_score is an array. Document 4 contains scalar values for both fields. Document 3 contains arrays in both indexed fields: home_score: [5,8] and away_score: [9,6] . Indexing that document would require a compound multikey index to expand two independent array dimensions, which MongoDB prohibits. Therefore document 3 prevents the compound index from being valid. The restriction is important because a single multikey field already creates multiple index keys per document; allowing multiple independently array-valued keys in the same compound index would create ambiguous and potentially combinatorial key combinations. DBAs designing indexes over document schemas with arrays must understand these multikey constraints before building compound indexes. The failing document is _id:3, making option D correct.

Study Guide reference/topic:Indexing and Query Optimization - multikey indexes, compound multikey restrictions, and array-valued fields.

===========

db.collection.getIndexes() is the mongosh method used to return the definitions of all indexes that currently exist on a collection. The result is an array of index specification documents that can show fields such as the index name, key pattern, index version, uniqueness, partial-filter settings, sparse configuration, collation, and whether the index is hidden. This makes the method useful for index audits, troubleshooting, and confirming the physical indexes available to the query planner. Option A is not a documented method for enumerating collection indexes. Option B resembles the $indexStats aggregation stage, which reports usage statistics for indexes, but db.collection.indexStats() is not the method used to list full index definitions. Option C, findIndexes(), is also not the documented mongosh collection helper. Administrators should distinguish between listing index definitions, examining index usage, and inspecting an individual query ' s winning plan: getIndexes() addresses the first requirement, $indexStats addresses usage metrics, and explain() addresses query-planner behavior. Therefore option D is the correct command for listing all indexes on the collection.

Study Guide reference/topic:Indexing and Query Optimization - index administration, index metadata, and db.collection.getIndexes().

===========

db.collection.stats() returns statistics for a specific collection, including storage-related values that help a DBA understand that collection ' s disk footprint. Therefore, for a collection named order, db.order.stats() is the relevant command among the choices. The result can include metrics such as logical data size, allocated storage size, document count, index information, and related collection statistics depending on version and storage engine. Option A, db.stats(), reports database-level statistics aggregated across the database rather than isolating the order collection. db.hostInfo(), option C, reports host and operating-system information rather than collection storage consumption. db.serverStatus(), option D, provides broad server-process runtime metrics such as connections, memory, operation counters, replication/storage-engine information, and other health data, but it is not the collection-specific disk-utilization interface requested here. Administrators can also use dedicated helpers such as collection storage-size or total-size methods when they need a more narrowly defined measurement. For a general collection-level statistics query targeting order, however, db.order.stats() is the correct answer, making option B correct.

Study Guide reference/topic:Performance Monitoring and Tuning - collection statistics, storage utilization, db.collection.stats(), and database/server metrics.

===========

The query filters only on the sizes field, so the most direct supporting index is a single-field index on sizes. Because sizes contains arrays, MongoDB automatically treats the resulting index as a multikey index and creates index entries derived from the array elements. That allows the query { sizes: " M " } to locate matching documents through the index rather than scanning every document in the collection. Option B indexes item, which is not part of the predicate and therefore does not help this query. Option C contains sizes, but _id is the leading key and the query provides no equality restriction on _id; this prevents efficient use of the later key as a standalone prefix for the query. Option D has the same structural problem because item precedes sizes and is not constrained. MongoDB ' s index-prefix rules make a targeted { sizes: 1 } index the strongest choice here. In a real workload, DBAs should also consider write overhead and whether additional queries can share a compound index before creating redundant indexes. For this single query pattern, option A is optimal.

Study Guide reference/topic:Indexing and Query Optimization - multikey indexes, array fields, index prefixes, and query support.

===========

In MongoDB explain output, a COLLSCAN stage means the winning plan is scanning documents in the collection rather than traversing a suitable index. This is the clearest indicator that the query is not being serviced by a normal index scan for the relevant predicate. By contrast, IXSCAN explicitly indicates an index scan and typically includes details such as the index key pattern, direction, and bounds. A FETCH stage represents retrieval of full documents, often after an index has already identified candidate record locations; its presence does not imply that no index was used. GROUP relates to grouping behavior and is not the stage used to identify missing index support. A collection scan is not automatically wrong: for tiny collections or queries that return most documents, it can be efficient. However, on large collections with selective predicates, repeated COLLSCAN plans are a strong signal that the DBA should evaluate indexing. Administrators should compare totalDocsExamined, totalKeysExamined, execution time, and the winning/rejected plans before deciding to add an index. For the terminology tested by the question, COLLSCAN is the correct stage, so C is correct.

Study Guide reference/topic:Indexing and Query Optimization - explain plans, COLLSCAN, IXSCAN, and missing index diagnostics.

===========

The rnd field should lead the compound index because it is the query ' s equality predicate. MongoDB ' s common compound-index design rule is Equality, Sort, Range (ESR): fields tested for exact equality are typically placed first, followed by fields used for sorting and then range predicates, subject to workload-specific selectivity considerations. Here, rnd: 1234 is an equality condition. _id: { $lte: 1000 } is a range condition, and date: { $gte: ... } is also a range condition while the query additionally sorts on date. Leading with rnd sharply narrows the index region that must be scanned before MongoDB handles the sort/range dimensions. Starting with _id or date would place a range-oriented key ahead of the exact-match predicate and generally reduce the efficiency of index bounds for this query shape. The complete optimal key pattern may depend on whether avoiding the sort or maximizing range selectivity matters most, but the question asks only for the first field. Under ESR guidance, that first field is rnd, so option B is correct.

Study Guide reference/topic:Indexing and Query Optimization - compound indexes, selectivity, and the Equality-Sort-Range guideline.

===========