Connection pooling concept in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main benefit of connection pooling in MongoDB?

Imagine you have a busy coffee shop where many customers come to order drinks. Instead of making a new coffee machine for each customer, you use a few machines shared by everyone. How does this idea relate to connection pooling in MongoDB?

A It increases the number of connections to the database indefinitely.

B It reduces the time to establish new connections by reusing existing ones.

C It stores data temporarily to speed up queries.

D It encrypts all data sent between client and server.

💡 Hint

Think about saving time and resources when many users need to connect.

Connection pooling keeps a set of open connections ready to use, so new requests don't need to open a new connection each time. This saves time and system resources.

❓ query_result

intermediate

How many connections are active after running this MongoDB connection pool code?

Given the following MongoDB client code snippet, what is the number of active connections after running it?

MongoDB

const { MongoClient } = require('mongodb');

const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri, { maxPoolSize: 5 });

async function run() {
  await client.connect();
  const db = client.db('testdb');
  const collection = db.collection('items');

  // Run 10 queries concurrently
  await Promise.all(
    Array.from({ length: 10 }).map(() => collection.findOne({}))
  );

  console.log(client.topology.s.pool.size);
  await client.close();
}

run();

A 5

B 10

C 1

D 0

💡 Hint

Check the maxPoolSize option and how many connections the pool can open.

The maxPoolSize is set to 5, so the pool will open up to 5 connections to handle the 10 queries concurrently, reusing them as needed.

📝 Syntax

advanced

Which MongoDB connection string correctly enables connection pooling with a max pool size of 20?

Select the correct MongoDB connection string that sets the maximum connection pool size to 20.

A mongodb://localhost:27017/?connectionPool=20

B mongodb://localhost:27017/?poolSize=20

C mongodb://localhost:27017/?maxConnections=20

D mongodb://localhost:27017/?maxPoolSize=20

💡 Hint

Look for the official option name for max pool size in MongoDB URI.

The correct URI option to set the maximum connection pool size is maxPoolSize. Other options are invalid or deprecated.

❓ optimization

advanced

How does increasing maxPoolSize affect MongoDB application performance?

Consider a MongoDB application with many simultaneous users. What is the effect of increasing the maxPoolSize setting?

A It can improve throughput by allowing more concurrent connections but may increase resource usage.

B It disables connection pooling entirely.

C It reduces memory usage by limiting connections.

D It always decreases latency regardless of workload.

💡 Hint

Think about trade-offs between concurrency and resource consumption.

Increasing maxPoolSize allows more concurrent connections, which can improve throughput under heavy load, but it also uses more memory and CPU resources.

🔧 Debug

expert

Why does this MongoDB connection pool code cause a connection leak?

Review the following code snippet. Why might it cause a connection leak in MongoDB?

MongoDB

const { MongoClient } = require('mongodb');

const client = new MongoClient('mongodb://localhost:27017', { maxPoolSize: 10 });

async function query() {
  await client.connect();
  const db = client.db('testdb');
  const collection = db.collection('users');

  for (let i = 0; i < 100; i++) {
    collection.findOne({});
  }
}

query();

A The maxPoolSize is too low to handle 100 queries.

B The findOne method is called without await, so queries never complete.

C The code never closes the client connection, causing connections to remain open.

D The MongoClient constructor is missing the poolSize option.

💡 Hint

Check if the client connection is properly closed after use.

The code connects the client but never calls client.close(). This leaves connections open, causing a leak.