C100DEV Drivers, Tools, Transactions, and Search Practice Test 2 — 15 Questions

Question 1

A developer is using mongosh to investigate a production incident. They need to run a query against the 'orders' collection, but they want the output to be returned in a format that can be easily piped into a JSON parser on their local machine. Which mongosh command should they use?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

EJSON.stringify(db.orders.find().toArray()). The goal is to produce a single, valid JSON string from query results that can be parsed by an external tool. Using EJSON.stringify on the array of documents from find().toArray() achieves this, as EJSON is a strict superset of JSON that preserves BSON types. Other methods either produce non-JSON output or lose data entirely, making them unsuitable for this scenario.

Answer

db.orders.find().pretty()

Answer

db.orders.find().toArray().toString()

Answer

db.orders.find().forEach(printjson)

Question 2

A developer is writing a Node.js application that connects to a MongoDB replica set. The application must ensure that all read operations in a session see a consistent snapshot of the data, even if other clients are writing concurrently. The developer wants to use causal consistency. Which of the following should be done when starting the session?

Accepted Answer

Start the session with { causalConsistency: true } and use readConcern: 'snapshot' for all reads.. To achieve a consistent snapshot across multiple reads in a session, the session must be causally consistent and reads must use readConcern: 'snapshot'. Causal consistency ensures that the session's operations are ordered, while snapshot read concern provides a consistent view of the data. The other options either lack snapshot isolation or disable causal consistency, which is necessary for the required behavior.

Answer

Start the session with { causalConsistency: true } and use readConcern: 'local' for all reads.

Answer

Start the session with { causalConsistency: true } and use readConcern: 'majority' for all reads.

Answer

Start the session with { causalConsistency: false } and use readConcern: 'snapshot' for all reads.

Question 3

A developer is using the MongoDB Node.js driver to manage sessions for a multi-document transaction. Which TWO actions are required to ensure that the session is properly ended and resources are released? (Choose two.)

Accepted Answer

Call session.endSession() in a finally block to ensure it runs even if an error occurs.. To properly end a session in the Node.js driver, the developer must call session.endSession() after the transaction is complete, ideally within a finally block to ensure it executes even on errors. This releases the session and its resources. The withTransaction() method does not end the session automatically, so explicit ending is still required.

Answer

Set the session's causalConsistency option to false to allow immediate release.

Answer

Use the withTransaction() method to automatically handle commit and abort, which also ends the session.

Answer

Ensure that the session is not reused for other operations after ending.

Question 4

A developer is building an application that uses MongoDB Atlas Search to provide full-text search capabilities. They want to ensure that the search index stays up-to-date with changes in the collection without manual intervention. What should they do?

Accepted Answer

Configure the Atlas Search index to use dynamic mapping and enable automatic index updates.. Atlas Search indexes are automatically synchronized with the collection. When you create an index, it continuously indexes new and updated documents. Dynamic mapping allows the index to adapt to schema changes. No manual steps like cron jobs, reIndex(), or Change Streams are needed to keep the index up-to-date. The correct approach is to rely on the automatic synchronization provided by Atlas.

Answer

Schedule a cron job to run the 'mongodump' and 'mongorestore' commands periodically to rebuild the search index.

Answer

Manually run the 'db.collection.reIndex()' command after every document modification to update the search index.

Answer

Use MongoDB Change Streams to listen for changes and programmatically update the Atlas Search index via the Atlas API.

Question 5

A developer is using the MongoDB Node.js driver to implement a multi-document transaction. They need to ensure that the transaction uses a read concern that guarantees the data read is the most recent committed version, and a write concern that acknowledges the write only after it has been written to the majority of replica set members. Which combination of read and write concerns should they specify when starting the transaction?

Accepted Answer

readConcern: 'majority', writeConcern: { w: 'majority' }. For transactions requiring the most recent committed data and majority write acknowledgment, readConcern 'majority' and writeConcern { w: 'majority' } are appropriate. readConcern 'majority' ensures the read data is durable and committed by a majority, while writeConcern 'majority' ensures the write is acknowledged by a majority. Other combinations either provide weaker consistency or unacknowledged writes.

Answer

readConcern: 'available', writeConcern: { w: 'majority' }

Answer

readConcern: 'local', writeConcern: { w: 1 }

Answer

readConcern: 'snapshot', writeConcern: { w: 0 }

Question 6

A developer is using the MongoDB Node.js driver to implement a multi-document transaction that transfers funds between two accounts in a banking application. The transaction must be resilient to transient errors and ensure that both the debit and credit operations are applied atomically. Which two of the following statements are true regarding transaction error handling and retry logic in this scenario? (Choose two.)

Accepted Answer

The developer should use the withTransaction() method provided by the Node.js driver, which handles retries and commit/abort logic automatically for TransientTransactionError and UnknownTransactionCommitResult.. The correct statements are that the driver automatically retries on TransientTransactionError, and that the withTransaction() helper handles retries and commit logic. WriteConflict is transient and can be retried, so not retrying is wrong. Manual retry is not required because the driver provides automatic retries. Ending the session is not needed for retry; the same session can be reused.

Answer

If a transaction fails with a WriteConflict error, the developer should immediately abort the transaction and not retry, as it indicates a permanent conflict.

Answer

When a transaction is aborted due to an error, the developer should call session.endSession() to release resources and then start a new session for a retry.

Answer

The developer must manually implement retry logic for TransientTransactionError because the Node.js driver does not provide automatic retries for multi-document transactions.

Question 7

A developer is using MongoDB Atlas Search to implement a search feature for an e-commerce application. They have created an Atlas Search index on the 'products' collection with a custom analyzer. They now need to write an aggregation pipeline stage to perform a search that returns products matching a query for 'wireless headphones' and also includes a count of the total number of matching documents. Which two aggregation stages should they use in their pipeline? (Choose two.)

Accepted Answer

$search. To perform an Atlas Search and get a count of matching documents, the pipeline should start with $search to execute the full-text query. Then, to count the results, the $count stage can be used, which outputs the total number of documents that passed through $search. The combination of $search and $count achieves both returning the products (if needed, but note $count replaces the documents with a count; to return both products and count, a $facet would be used, but the question only asks for the stages to include a count) and providing the count. However, the question specifically asks for two stages to use; $search and $count are the correct ones.

Answer

$match

Answer

$group

Answer

$searchMeta

Question 8

Refer to the exhibit. What is the impact of setting 'dynamic' to true in this Atlas Search index definition?

Accepted Answer

It automatically indexes all fields in every document.. Setting 'dynamic' to true enables Atlas Search to automatically index all fields in every document within the collection. This is useful for rapid prototyping or collections with unpredictable schemas. However, it can significantly increase the size of the index and consume more resources compared to manual mappings. Understanding this balance is critical for developers managing performance and cost when dealing with large datasets and varying document structures in search-enabled collections.

Answer

It forces all documents to follow a strict schema.

Answer

It prevents the creation of any custom field mappings.

Answer

It disables the indexing of nested object fields.

Question 9

When using MongoDB Compass to analyze query performance, which tool is most effectively used to view the explain plan output in a visual format?

Accepted Answer

The Explain Plan tab.. MongoDB Compass provides a built-in 'Explain Plan' tab that visualizes how the database executes a query. This tool represents the execution path as a tree, highlighting which indexes were used, how many documents were scanned, and the efficiency of the operation. Using this visual output is essential for developers to identify bottlenecks, missing indexes, or suboptimal query structures without manually parsing complex JSON output from the shell.

Answer

The Aggregation Pipeline builder.

Answer

The Schema validation tab.

Answer

The Connection health monitor.

Question 10

Which of the following describes the behavior of a 'write concern' in a MongoDB transaction?

Accepted Answer

It is specified during the commitTransaction command.. Transactions in MongoDB honor the write concern configured on the 'commitTransaction' command. This allows developers to specify the durability level, such as 'majority', ensuring that changes are acknowledged by the majority of replica set members before the transaction is considered complete. Proper management of write concerns ensures that even if a primary node fails immediately after a commit, the data remains durable and consistent across the cluster.

Answer

Write concern is ignored inside multi-document transactions.

Answer

It is applied to each individual operation within the transaction.

Answer

It is determined solely by the server's default configuration.

Question 11

Refer to the exhibit. What is the most appropriate next step for an application encountering this error?

Accepted Answer

Abort the transaction and retry the entire operation.. The 'TransientTransactionError' label indicates that the failure occurred due to a temporary issue, such as a network hiccup or a transient server conflict. In accordance with MongoDB best practices, the application must catch this error, perform a rollback if necessary, and then retry the entire transaction from the beginning. This mechanism ensures that the application state remains consistent despite the intermittent nature of the underlying failure.

Answer

Display an error message to the user and stop.

Answer

Retry the individual failed operation only.

Answer

Ignore the error and continue with the next request.

Question 12

When using the MongoDB C#/.NET driver, which object is essential for managing the scope and lifecycle of a multi-document transaction?

Accepted Answer

IClientSessionHandle. In the .NET driver, the 'IClientSessionHandle' object is used to represent a session that controls the lifecycle of a transaction. By using the 'StartTransaction' method on this session object, developers can encapsulate multiple operations within a single, atomic unit of work. This session handle is passed to every database operation within the transaction, ensuring that all actions are associated with the correct transactional scope and are properly committed or aborted.

Answer

IMongoDatabase

Answer

MongoClient

Answer

IMongoCollection

Question 13

Which of the following best describes the purpose of the MongoDB 'mongosh' shell?

Accepted Answer

To serve as a modern interactive JavaScript shell.. The 'mongosh' shell is the modern, interactive command-line interface for MongoDB. It allows developers to run JavaScript commands to interact with the database, perform CRUD operations, manage indexes, and execute administrative tasks. It replaces the legacy 'mongo' shell, offering improved features like syntax highlighting, auto-completion, and better integration with current MongoDB server versions, making it the essential tool for daily development and database management tasks.

Answer

To act as a GUI for database administration.

Answer

To perform background replication between nodes.

Answer

To automatically optimize database query indexes.

Question 14

What is the primary role of the 'mongos' process in a sharded cluster?

Accepted Answer

It routes requests to the correct shards.. The 'mongos' process acts as a query router, bridging the gap between client applications and the sharded cluster. It receives incoming requests, determines which shards contain the necessary data using the cluster's metadata, and routes the request to the appropriate shards. It then aggregates the results before returning them to the client. This abstraction allows applications to interact with the entire cluster as if it were a single database instance.

Answer

It stores the data chunks for the shards.

Answer

It manages the election of the primary node.

Answer

It persists the metadata for the entire cluster.

Question 15

Which of the following describes the behavior of a 'causally consistent' session in MongoDB?

Accepted Answer

It ensures operations are observed in their logical order.. Causal consistency ensures that operations within a session reflect the order in which they were performed. If an application writes a document and then immediately reads it back within the same session, causal consistency guarantees that the read will see the result of that write, even if the read is directed to a secondary node. This is vital for applications requiring linear-like history for user interactions across distributed read/write nodes.

Answer

It forces all reads and writes to the primary node.

Answer

It eliminates the need for replication in the cluster.

Answer

It significantly increases the latency of every write.