Connection pooling concept in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main benefit of using connection pooling in Node.js?

Connection pooling helps manage database connections efficiently. What is the primary advantage of using connection pooling?

A It guarantees that only one connection is used for all queries.

B It encrypts all database queries automatically for security.

C It reduces the overhead of establishing new connections by reusing existing ones.

D It automatically scales the database server hardware.

💡 Hint

Think about what happens when you open and close connections repeatedly.

Connection pooling keeps a set of open connections ready to use, so the app doesn't need to open a new connection every time. This saves time and resources.

❓ component_behavior

intermediate

What happens when all connections in a Node.js pool are busy?

Consider a connection pool with a limited number of connections. What happens if all connections are currently in use and a new query requests a connection?

A The query fails immediately with a connection error.

B The new query waits until a connection is released back to the pool.

C The pool closes one active connection to free up space.

D The pool automatically creates unlimited new connections.

💡 Hint

Think about how a waiting line works when resources are limited.

When all connections are busy, new requests wait in a queue until a connection becomes free. This prevents overload and manages resources efficiently.

📝 Syntax

advanced

Which code snippet correctly creates a connection pool using the 'mysql2' package in Node.js?

Choose the code that properly creates a connection pool with a maximum of 5 connections.

A

const mysql = require('mysql2');
const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test', connectionLimit: 5 });

B

const mysql = require('mysql2');
const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test', maxPoolSize: 5 });

C

import mysql from 'mysql2';
const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test', maxConnections: 5 });

D

import mysql from 'mysql2';
const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test', connectionLimit: 10 });

💡 Hint

Check the exact option name for limiting connections in the pool.

The 'mysql2' package uses 'connectionLimit' to set the max number of connections. Option A uses correct syntax and option name.

🔧 Debug

advanced

Why does this Node.js connection pool code cause a runtime error?

Consider this code snippet:

const mysql = require('mysql2');
const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test' });
pool.query('SELECT 1', (err, results) => {
  if (err) throw err;
  console.log(results);
});
pool.end();
pool.query('SELECT 2', (err, results) => {
  if (err) throw err;
  console.log(results);
});

Why does the second query cause an error?

A Because the query syntax is invalid and causes a syntax error.

B Because the callback function is missing error handling.

C Because the database credentials are missing in the pool configuration.

D Because the pool was closed with pool.end() before the second query.

💡 Hint

Think about what pool.end() does to the connection pool.

Calling pool.end() closes all connections and disables the pool. Any queries after that cause errors because no connections are available.

❓ state_output

expert

What is the output of this Node.js connection pool code snippet?

Given the following code, what will be printed to the console?

import mysql from 'mysql2/promise';

async function testPool() {
  const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test', connectionLimit: 2 });

  const conn1 = await pool.getConnection();
  const conn2 = await pool.getConnection();

  let errorCaught = false;
  try {
    const conn3 = await pool.getConnection({ timeout: 100 });
  } catch (e) {
    errorCaught = true;
    console.log('Timeout error caught');
  }

  conn1.release();
  conn2.release();
  await pool.end();

  console.log('Error caught:', errorCaught);
}

testPool();

A

Timeout error caught
Error caught: true

B

Timeout error caught
Error caught: false

C Error caught: true

D No output, program crashes with unhandled promise rejection

💡 Hint

Consider the pool size and what happens when requesting more connections than the limit with a timeout.

The pool has 2 connections max. Getting two connections uses them all. The third getConnection call times out and throws an error, caught and logged. Then 'Error caught: true' is printed.

Practice

1. What is the main purpose of connection pooling in Node.js applications?

easy

A. To encrypt database connections automatically

B. To create a new database connection for every query

C. To reuse database connections and improve performance

D. To store user session data in memory

Solution

1. Step 1: Understand connection pooling concept

   Connection pooling keeps a set of open database connections ready to use.

2. Step 2: Identify the benefit of reusing connections

   Reusing connections avoids the overhead of opening and closing connections repeatedly, improving speed.

3. Final Answer:

   To reuse database connections and improve performance -> Option C

4. Quick Check:

   Connection pooling = reuse connections [OK]

Hint: Pooling means reuse connections, not create new each time [OK]

Common Mistakes:

• Thinking pooling creates new connections every time
• Confusing pooling with session storage
• Assuming pooling encrypts connections automatically

2. Which of the following is the correct way to create a connection pool using the popular 'mysql2' package in Node.js?

easy

A. const pool = mysql.createPool({ host: 'localhost', user: 'root' });

B. const pool = mysql.connectPool({ host: 'localhost', user: 'root' });

C. const pool = mysql.newPool({ host: 'localhost', user: 'root' });

D. const pool = mysql.poolCreate({ host: 'localhost', user: 'root' });

Solution

1. Step 1: Recall mysql2 pool creation syntax

   The correct method is createPool with configuration object.

2. Step 2: Match method names with options

   Only const pool = mysql.createPool({ host: 'localhost', user: 'root' }); uses createPool correctly; others use invalid method names.

3. Final Answer:

   const pool = mysql.createPool({ host: 'localhost', user: 'root' }); -> Option A

4. Quick Check:

   Use createPool() to make a pool [OK]

Hint: Remember method is createPool, not connectPool or others [OK]

Common Mistakes:

• Using wrong method names like connectPool
• Forgetting to pass config object
• Confusing pool creation with direct connection

3. Given this code snippet using a connection pool, what will be logged if the pool is properly configured and the query succeeds?

const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test' });
pool.query('SELECT 1 + 1 AS solution', (err, results) => {
  if (err) throw err;
  console.log(results[0].solution);
});

medium

A. undefined

B. 2

C. Error

D. 1 + 1

Solution

1. Step 1: Understand the SQL query result

   The query 'SELECT 1 + 1 AS solution' returns a result with solution = 2.

2. Step 2: Check the console.log output

   results[0].solution accesses the first row's solution field, which is 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Query result = 2 [OK]

Hint: SELECT 1 + 1 returns 2, not string or error [OK]

Common Mistakes:

• Expecting string '1 + 1' instead of result 2
• Accessing wrong property of results
• Not handling async callback properly

4. Identify the error in this Node.js code using a connection pool:

const pool = mysql.createPool({ host: 'localhost', user: 'root' });
pool.getConnection((err, connection) => {
  if (err) throw err;
  connection.query('SELECT NOW()', (err, results) => {
    if (err) throw err;
    console.log(results);
    connection.release();
  });
});

medium

A. The pool is created with wrong method

B. The callback functions are missing error handling

C. The query syntax is invalid

D. The connection is not released back to the pool after query

Solution

1. Step 1: Check connection usage in pool

   After using a connection from pool, it must be released with connection.release().

2. Step 2: Verify code for releasing connection

   The code does not call connection.release(), so connection stays checked out, causing leaks.

3. Final Answer:

   The connection is not released back to the pool after query -> Option D

4. Quick Check:

   Always release connection after use [OK]

Hint: Always call connection.release() after query [OK]

Common Mistakes:

• Forgetting to release connection causing pool exhaustion
• Assuming pool auto-releases connections
• Ignoring error handling in callbacks

5. You want to optimize a Node.js app that runs many database queries quickly. Which approach best uses connection pooling to improve performance and resource use?

hard

A. Create a single pool at app start and reuse it for all queries

B. Create a new pool for each query and close it immediately

C. Use direct connections without pooling for faster queries

D. Open one connection and never close it or use a pool

Solution

1. Step 1: Understand best practice for pooling

   Creating one pool at app start and reusing it avoids overhead and manages resources well.

2. Step 2: Evaluate other options

   Creating new pools per query wastes resources; direct connections lack reuse; never closing connections risks leaks.

3. Final Answer:

   Create a single pool at app start and reuse it for all queries -> Option A

4. Quick Check:

   One shared pool = best practice [OK]

Hint: One pool shared app-wide is efficient and safe [OK]

Common Mistakes:

• Making new pools per query causing overhead
• Not using pooling at all
• Leaving connections open without management