Connection pooling concept in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a MongoDB client with connection pooling enabled.

MongoDB

const client = new MongoClient(uri, { [1]: 10 });

Drag options to blanks, or click blank then click option'

AmaxPoolSize

BpoolSize

Cconnections

DconnectionLimit

Attempts:

3 left

💡 Hint

Common Mistakes

Using poolSize which is deprecated in newer drivers.

Using connectionLimit which is not a valid option here.

The maxPoolSize option sets the maximum number of connections in the pool for MongoDB clients.

2fill in blank

medium

Complete the code to connect the MongoDB client and log a success message.

MongoDB

await client.[1]();
console.log('Connected to MongoDB with pooling');

Drag options to blanks, or click blank then click option'

Astart

Binitialize

Copen

Dconnect

Attempts:

3 left

💡 Hint

Common Mistakes

Using start() which does not exist.

Using open() which is not a MongoDB client method.

The connect() method establishes the connection pool and connects the client to the MongoDB server.

3fill in blank

hard

Fix the error in the code to properly close the MongoDB client connection pool.

MongoDB

await client.[1]();

Drag options to blanks, or click blank then click option'

Adisconnect

Bclose

Cshutdown

Dend

Attempts:

3 left

💡 Hint

Common Mistakes

Using disconnect() which is not a MongoDB client method.

Using end() which is not valid here.

The close() method properly closes all connections in the pool and releases resources.

4fill in blank

hard

Fill both blanks to create a MongoDB client with a max pool size of 20 and a timeout of 3000 ms.

MongoDB

const client = new MongoClient(uri, { [1]: 20, [2]: 3000 });

Drag options to blanks, or click blank then click option'

AmaxPoolSize

BconnectTimeoutMS

CsocketTimeoutMS

DpoolTimeout

Attempts:

3 left

💡 Hint

Common Mistakes

Confusing socketTimeoutMS with connection timeout.

Using poolTimeout which is not a valid option.

maxPoolSize sets the max connections in the pool, and connectTimeoutMS sets the connection timeout in milliseconds.

5fill in blank

hard

Fill all three blanks to create a MongoDB client with a max pool size of 50, a connect timeout of 5000 ms, and a socket timeout of 45000 ms.

MongoDB

const client = new MongoClient(uri, { [1]: 50, [2]: 5000, [3]: 45000 });

Drag options to blanks, or click blank then click option'

AmaxPoolSize

BconnectTimeoutMS

CsocketTimeoutMS

DpoolSize

Attempts:

3 left

💡 Hint

Common Mistakes

Using poolSize instead of maxPoolSize.

Mixing up connectTimeoutMS and socketTimeoutMS.

Use maxPoolSize for max connections, connectTimeoutMS for connection timeout, and socketTimeoutMS for socket inactivity timeout.

Practice

1. What is the main purpose of connection pooling in MongoDB?

easy

A. To reuse existing database connections for faster performance

B. To create a new connection for every database request

C. To store data temporarily in the database

D. To backup the database automatically

Solution

1. Step 1: Understand connection pooling concept

   Connection pooling means reusing open connections instead of opening new ones each time.

2. Step 2: Identify the benefit of reusing connections

   Reusing connections saves time and resources, making database access faster.

3. Final Answer:

   To reuse existing database connections for faster performance -> Option A

4. Quick Check:

   Connection pooling = reuse connections [OK]

Hint: Connection pooling means reuse connections, not create new ones [OK]

Common Mistakes:

• Thinking connection pooling creates new connections each time
• Confusing connection pooling with data caching
• Assuming connection pooling is for backup

2. Which of the following is the correct way to set the maximum pool size in a MongoDB connection string?

easy

A. mongodb://localhost:27017/?poolMax=50

B. mongodb://localhost:27017/?maxConnections=50

C. mongodb://localhost:27017/?maxPoolSize=50

D. mongodb://localhost:27017/?connectionLimit=50

Solution

1. Step 1: Recall MongoDB connection string options

   The correct option to set max pool size is maxPoolSize.

2. Step 2: Match the option with the connection string

   Only mongodb://localhost:27017/?maxPoolSize=50 uses maxPoolSize correctly in the connection string.

3. Final Answer:

   mongodb://localhost:27017/?maxPoolSize=50 -> Option C

4. Quick Check:

   maxPoolSize sets max connections [OK]

Hint: Use maxPoolSize to set max connections in MongoDB URI [OK]

Common Mistakes:

• Using maxConnections instead of maxPoolSize
• Using poolMax or connectionLimit which are invalid
• Placing options outside the URI query string

3. Consider this MongoDB connection code snippet using Node.js driver:

const client = new MongoClient(uri, { maxPoolSize: 5 });
await client.connect();

const db = client.db('test');
const col = db.collection('items');

// Simulate 10 quick queries
for (let i = 0; i < 10; i++) {
  await col.findOne({});
}

What is the effect of setting maxPoolSize to 5 here?

medium

A. The pool size limits the number of documents returned

B. Only 5 connections will be open at once, reused for all queries

C. No connections will be reused, each query opens a new one

D. 10 connections will open, one per query

Solution

1. Step 1: Understand maxPoolSize effect on connections

   maxPoolSize limits how many connections can be open simultaneously in the pool.

2. Step 2: Analyze the loop with 10 queries

   Even with 10 queries, only 5 connections open and are reused for all queries.

3. Final Answer:

   Only 5 connections will be open at once, reused for all queries -> Option B

4. Quick Check:

   maxPoolSize=5 means max 5 open connections [OK]

Hint: maxPoolSize limits open connections, not queries [OK]

Common Mistakes:

• Thinking each query opens a new connection
• Confusing pool size with query limits
• Assuming pool size affects returned data count

4. You wrote this code to connect to MongoDB with connection pooling:

const client = new MongoClient(uri, { maxPoolSize: 10 });
await client.connect();

// Later in code
await client.close();
await client.connect();

But you notice performance drops after reconnecting. What is the likely problem?

medium

A. The URI string is missing maxPoolSize parameter

B. maxPoolSize is too low, causing slow queries

C. You must create a new MongoClient instance before reconnecting

D. Calling client.close() closes all connections, so reconnecting is slow

Solution

1. Step 1: Understand client.close() effect

   Calling client.close() closes all connections in the pool, clearing them.

2. Step 2: Analyze reconnecting after close()

   Reconnecting after close() requires opening new connections, causing delay and performance drop.

3. Final Answer:

   Calling client.close() closes all connections, so reconnecting is slow -> Option D

4. Quick Check:

   client.close() clears pool, reconnect is slower [OK]

Hint: Avoid closing client if you plan to reconnect soon [OK]

Common Mistakes:

• Assuming maxPoolSize affects reconnect speed
• Thinking you can reconnect without new client instance
• Ignoring that close() clears all connections

5. Your app makes many short database requests to MongoDB. You want to optimize performance using connection pooling. Which approach is best?

hard

A. Create one MongoClient with a suitable maxPoolSize and reuse it for all requests

B. Create a new MongoClient for each request with maxPoolSize=1

C. Set maxPoolSize to 1 and open a new connection for each request

D. Disable connection pooling to avoid connection reuse

Solution

1. Step 1: Understand connection pooling best practice

   Best practice is to create one MongoClient instance and reuse it to benefit from pooling.

2. Step 2: Evaluate options for many short requests

   Reusing one client with a proper maxPoolSize allows multiple connections reused efficiently.

3. Final Answer:

   Create one MongoClient with a suitable maxPoolSize and reuse it for all requests -> Option A

4. Quick Check:

   Reuse one client with pooling for many requests [OK]

Hint: Reuse one client with maxPoolSize for many requests [OK]

Common Mistakes:

• Creating new client per request wastes resources
• Setting maxPoolSize to 1 limits concurrency
• Disabling pooling reduces performance