C100DEV Drivers, Tools, Transactions, and Search — Timed 20 Questions

Question 1

An application uses the MongoDB Node.js driver to perform a multi-document transaction. If the transaction takes too long and exceeds the default limit, which error mechanism should the application handle to ensure data integrity?

20 minute time limit — choose an answer to begin.

Accepted Answer

Retry the transaction using the TransientTransactionError label.. Transactions in MongoDB have a default lifetime limit, defined by the 'transactionLifetimeLimitSeconds' server parameter. If a transaction stays open longer than this, the server aborts it automatically to prevent blocking resources indefinitely. Applications must implement retry logic using the 'TransientTransactionError' or 'UnknownTransactionCommitResult' labels, which are standard best practices for maintaining transactional integrity and handling transient failures in distributed database systems effectively.

Answer

Catch a SocketTimeoutException and ignore it.

Answer

Increase the transactionLifetimeLimitSeconds on the client driver.

Answer

Disable the transaction limit in the connection string.

Question 2

Which TWO of the following statements regarding MongoDB Atlas Search are accurate?

Accepted Answer

Atlas Search allows for fuzzy matching and relevance scoring.. Atlas Search leverages Apache Lucene to provide advanced text searching capabilities directly within MongoDB. Unlike standard indexes that are optimized for exact matches or range queries, Atlas Search indexes allow for relevance scoring, fuzzy matching, and complex linguistic analysis. These features are decoupled from standard MongoDB query processing, meaning they operate on a separate engine that synchronizes data from the primary nodes to provide full-text search performance.

Answer

Atlas Search is a feature built into standard MongoDB indexes.

Answer

Atlas Search is available in self-managed, on-premises MongoDB clusters.

Answer

Atlas Search indexes support only collection-wide document schema.

Question 3

Which THREE of these are valid methods for monitoring a MongoDB cluster?

Accepted Answer

Using the mongostat command-line tool.. Monitoring is vital for maintaining the health of a MongoDB deployment. Administrators should utilize a combination of real-time tools, historical graphing, and command-line utilities. These tools provide visibility into resource consumption (CPU, RAM), operation throughput, and replication lag. A robust monitoring strategy involves both automated alerts and manual inspection to ensure the system can handle workloads and recover from potential failures efficiently.

Answer

Modifying the database engine source code.

Answer

Manually parsing the raw data files on disk.

Question 4

Which THREE factors influence the latency of a MongoDB transaction?

Accepted Answer

Network latency between client and primary node.. Transaction latency is affected by multiple factors within a distributed environment. Network latency between the client and the primary node, the complexity and number of operations within the transaction, and the need for majority write concern all contribute to the time taken to commit. Efficient transaction design requires balancing these factors, often by keeping transactions as short as possible to minimize lock contention and resource consumption across the cluster.

Answer

The size of the documents being queried.

Answer

The operating system used by the server.

Question 5

Which MongoDB tool should a developer use to perform a point-in-time backup and restore for a collection?

Accepted Answer

mongodump. mongodump and mongorestore are the standard utilities for logical backups in MongoDB. mongodump reads data from a MongoDB database and creates BSON files, while mongorestore reads these files to populate a database. These tools are essential for developers needing to move data between environments or perform simple point-in-time snapshots of collections, providing a reliable way to ensure data recoverability independent of the underlying storage engine's physical files.

Answer

mongostat

Answer

mongotop

Answer

mongoexport

Question 6

Refer to the exhibit. If an application encounters both error labels in an error object, what should the retry strategy be?

Accepted Answer

Catch the labels and perform a retry of the whole transaction.. When multiple error labels are present, the application should prioritize handling the retry logic according to the error context. 'TransientTransactionError' is the primary indicator that the transaction should be aborted and retried. 'UnknownTransactionCommitResult' is specifically used during the commit phase to determine if the commit actually succeeded or failed due to network issues. The best practice is to structure code to handle these labels sequentially, ensuring robust transaction completion.

Answer

Abort the transaction and do not retry.

Answer

Only retry if the error was a server-side crash.

Answer

Hard-code a delay before every single operation.

Question 7

Which TWO of the following are true regarding the use of MongoDB Atlas Search indexes?

Accepted Answer

You can use the $search stage in the aggregation pipeline to leverage Atlas Search indexes.. Atlas Search indexes are separate from standard MongoDB indexes and are built on Apache Lucene. They allow for full-text search capabilities, including relevance scoring and complex query filtering. Understanding that these indexes operate outside the standard B-tree index mechanism is vital for developers who need to implement advanced search features like fuzzy matching or autocomplete in their applications while maintaining the performance benefits of a dedicated search engine.

Answer

Atlas Search indexes are automatically created when you define a standard index in the MongoDB shell.

Answer

Standard MongoDB compound indexes can fully replace the functionality of Atlas Search indexes.

Answer

Atlas Search indexes are stored within the standard WiredTiger data files on the disk.

Question 8

Refer to the exhibit. An application using a multi-document transaction encounters the error shown. What is the most appropriate strategy to handle this?

Accepted Answer

Catch the exception and execute the entire transaction logic again in a loop.. A WriteConflict error (code 112) occurs when two transactions attempt to modify the same document simultaneously, resulting in a locking contention. In MongoDB, transactions are optimistic; when a conflict is detected during the commit or execution phase, the application must catch this specific exception and implement a retry logic. This ensures that the operation is eventually successful without manually intervening, which is standard practice for distributed transactional systems.

Answer

Increase the transaction time limit in the configuration file to allow for longer locks.

Answer

Switch to using a single-document update to avoid transactional overhead entirely.

Answer

Disable write concern for the transaction to bypass locking mechanisms.

Question 9

An application uses the MongoDB Node.js driver to perform a multi-document transaction. If the transaction exceeds the default lifetime limit, what behavior should the developer expect?

Accepted Answer

The server aborts the transaction and returns a TransientTransactionError.. Transactions have a default limit of 60 seconds to prevent long-running operations from holding locks and consuming memory in the WiredTiger storage engine. When this limit is exceeded, MongoDB automatically aborts the transaction to maintain system stability. Developers must handle this abort by implementing retry logic, ensuring their application remains resilient in high-load scenarios where network latency or complex document processing might lead to timeout triggers.

Answer

The transaction continues indefinitely until the client closes the session.

Answer

The server automatically retries the transaction until it succeeds.

Answer

The server pauses the transaction and requests a client heartbeat.

Question 10

Which TWO of the following are true regarding the use of MongoDB Atlas Search?

Accepted Answer

The $search stage must be the first stage in an aggregation pipeline.. Atlas Search is built on Apache Lucene and provides powerful full-text search capabilities directly within the database. Understanding its indexing and query behavior is critical for developers building search features. These indices are separate from standard MongoDB indexes, and users must account for the asynchronous propagation delay between data updates and index availability when designing search-driven applications or user interfaces.

Answer

Atlas Search indexes are stored in the same local storage as the collection data.

Answer

Atlas Search indexes automatically reflect all document updates with zero latency.

Answer

Only one index per collection can be created for Atlas Search.

Question 11

Which THREE actions are required when using the MongoDB Node.js driver to safely manage sessions?

Accepted Answer

Always pass the session object to every operation within the transaction.. Managing sessions correctly is vital for performance and reliability in MongoDB. Proper session handling prevents resource leaks and ensures that operations are executed within the correct transaction or causal consistency context. Developers must be diligent in creating, passing, and closing sessions appropriately to avoid issues like idle cursor accumulation, which can degrade database server performance over time in high-traffic production environments.

Answer

Create a new session for every single query in the application.

Answer

Define the session globally and reuse it for all concurrent users.

Question 12

Refer to the exhibit. Why does MongoDB require 'majority' read concern for multi-document transactions?

Accepted Answer

To prevent the transaction from reading uncommitted data from a previous primary.. Transactions in MongoDB must be durable and consistent across the replica set. Using 'majority' read concern ensures that a transaction only reads data that has been acknowledged by a majority of the voting nodes. This prevents the transaction from relying on data that might be rolled back in the event of a primary node failover, which is essential for maintaining the transactional guarantee of atomicity and isolation in a distributed database.

Answer

To increase the speed of the transaction by avoiding secondary nodes.

Answer

To allow the transaction to span multiple shards efficiently.

Answer

To ensure that the transaction can be performed on hidden nodes.

Question 13

When using the mongosh 'bulkWrite' method, which option is critical to ensure that operations are processed in the specified sequence?

Accepted Answer

ordered. The 'ordered' option in bulkWrite is fundamental to controlling the execution flow. When set to true (the default), MongoDB stops processing the bulk operation if an error occurs. When set to false, MongoDB continues to process the remaining operations even if one fails. This is vital for developers who need to ensure that dependencies between operations remain intact during a batch update, preventing partial application state corruption.

Answer

writeConcern

Answer

bypassDocumentValidation

Answer

collation

Question 14

A developer is using the MongoDB Node.js driver to execute a multi-document transaction. The transaction updates a document in the 'orders' collection and inserts a record into the 'audit' collection. After committing, the developer wants to ensure that the transaction is retried automatically if it encounters a transient error. Which driver feature should be used?

Accepted Answer

Use the driver's built-in retryable writes and transactions feature.. The MongoDB Node.js driver includes built-in support for retrying transactions that fail with transient errors. By using the driver's transaction API with a session, the driver will automatically retry the commit if it encounters a TransientTransactionError, provided the transaction is idempotent. This reduces the need for custom retry logic.

Answer

Set the write concern to { w: "majority" } to avoid transient errors.

Answer

Enable the 'retryWrites' option in the connection string and disable transactions.

Answer

Manually implement a retry loop around the transaction commit.

Question 15

A developer is creating an Atlas Search index on a collection of product documents. The index definition includes a field mapping for 'description' with type 'string' and an analyzer of 'lucene.standard'. The developer wants to also support case-insensitive searches on the 'name' field. Which additional field mapping should be added?

Accepted Answer

Add a field mapping for 'name' with type 'string' and analyzer 'lucene.standard'.. To support case-insensitive searches, the field mapping should use an analyzer that lowercases tokens, such as 'lucene.standard'. This analyzer is the default for string fields in Atlas Search and provides case-insensitive matching while preserving numbers and other characters. Other analyzers either do not lowercase or remove important characters.

Answer

Add a field mapping for 'name' with type 'string' and analyzer 'lucene.whitespace'.

Answer

Add a field mapping for 'name' with type 'string' and analyzer 'lucene.keyword'.

Answer

Add a field mapping for 'name' with type 'string' and analyzer 'lucene.simple'.

Question 16

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?

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 17

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 18

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 19

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 20

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 }