Connection pooling concept in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is connection pooling in Node.js?

Connection pooling is a technique where a set of database connections are kept open and reused to handle multiple requests, instead of opening and closing a new connection each time.

beginner

Why is connection pooling useful?

It improves performance by reducing the time and resources needed to open and close connections repeatedly. It also helps manage limited database connections efficiently.

intermediate

How does connection pooling affect server response time?

By reusing existing connections, connection pooling reduces the delay caused by establishing new connections, leading to faster server responses.

beginner

Name a common Node.js library that supports connection pooling for databases.

The 'mysql2' and 'pg' libraries support connection pooling for MySQL and PostgreSQL databases respectively.

intermediate

What can happen if a connection pool is too small or too large?

If too small, requests may wait for free connections causing delays. If too large, it can waste resources and overload the database server.

What does connection pooling primarily help with in Node.js applications?

A Caching query results in memory

B Encrypting database connections automatically

C Creating new connections for every request

D Reusing database connections to improve performance

Connection pooling reuses open connections to reduce overhead and improve performance.

Which of these is a risk of having a connection pool that is too small?

A Queries run slower because of encryption

B Requests may have to wait for a free connection

C Connections never close automatically

D Database server crashes immediately

A small pool means fewer connections available, so requests wait longer.

Which Node.js library is known for supporting connection pooling with PostgreSQL?

A pg

B express

C mongoose

D socket.io

'pg' is a popular PostgreSQL client for Node.js that supports connection pooling.

What happens when a connection pool is too large?

A It wastes resources and may overload the database

B It speeds up queries infinitely

C It encrypts all connections automatically

D It prevents any new connections from opening

Too many open connections consume resources and can overload the database server.

How does connection pooling improve server response time?

A By encrypting data faster

B By caching all database queries in memory

C By reusing existing connections instead of opening new ones

D By closing connections immediately after use

Reusing connections avoids the delay of opening new connections, speeding up responses.

Explain connection pooling and why it is important in Node.js applications.

Think about how opening a new connection each time can slow things down.

Describe the risks of having a connection pool size that is too small or too large.

Consider what happens if too few or too many connections are open.

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