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.