PostgreSQL connection with pg in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the pg module.

Node.js

const { Client } = require('[1]');

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

Aexpress

Bpg

Cmysql

Dhttp

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'express' instead of 'pg'.

Using 'mysql' which is for a different database.

You need to import the pg module to use PostgreSQL in Node.js.

2fill in blank

medium

Complete the code to create a new client with connection details.

Node.js

const client = new Client({ connectionString: '[1]' });

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

Ahttp://localhost:5432

Bmongodb://localhost:27017

Cpostgresql://user:pass@localhost:5432/mydb

Dftp://localhost:21

Attempts:

3 left

💡 Hint

Common Mistakes

Using HTTP or FTP URLs instead of PostgreSQL connection string.

Omitting username or database name.

The connection string must start with postgresql:// and include user, password, host, port, and database name.

3fill in blank

hard

Fix the error in the code to connect the client asynchronously.

Node.js

await client.[1]();

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

Aconnect

Bstart

Cdisconnect

Dopen

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'disconnect' instead of 'connect'.

Using non-existent methods like 'start' or 'open'.

The method to start the connection is connect(), and it returns a promise.

4fill in blank

hard

Fill both blanks to query the database and get results.

Node.js

const res = await client.[1]('[2]');

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

Aquery

Bconnect

CSELECT * FROM users

Ddisconnect

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'connect' or 'disconnect' instead of 'query'.

Using invalid SQL commands.

Use query method with a SQL string to get data from the database.

5fill in blank

hard

Fill all three blanks to close the client connection properly.

Node.js

try {
  await client.[1]();
  // do queries
} finally {
  await client.[2]();
  console.[3]('Connection closed');
}

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

Aconnect

Bend

Clog

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'start' instead of 'connect'.

Using 'disconnect' before queries.

Using 'console.error' instead of 'console.log'.

You connect first, then disconnect in finally block, and log a message with console.log.

Practice

1. What is the main purpose of the pg library in Node.js?

easy

A. To connect and interact with PostgreSQL databases

B. To create web servers

C. To manage file uploads

D. To style web pages

Solution

1. Step 1: Understand the role of pg

   The pg library is designed specifically to connect Node.js applications to PostgreSQL databases.

2. Step 2: Compare with other options

   Creating web servers, managing file uploads, and styling pages are unrelated to database connections and are handled by other libraries.

3. Final Answer:

   To connect and interact with PostgreSQL databases -> Option A

4. Quick Check:

   pg = PostgreSQL connection [OK]

Hint: Remember pg is for PostgreSQL database connection [OK]

Common Mistakes:

• Confusing pg with web server libraries
• Thinking pg handles frontend styling
• Assuming pg manages file uploads

2. Which of the following is the correct way to create a new Client instance from the pg library?

easy

A. const client = pg.connect('postgresql://user:pass@localhost/db');

B. const client = new pg.Client({ connectionString: 'postgresql://user:pass@localhost/db' });

C. const client = new Client.connect('postgresql://user:pass@localhost/db');

D. const client = pg.new Client('postgresql://user:pass@localhost/db');

Solution

1. Step 1: Recall the correct Client creation syntax

   The pg library requires creating a new Client instance using new pg.Client() with a config object.

2. Step 2: Check each option's syntax

   const client = new pg.Client({ connectionString: 'postgresql://user:pass@localhost/db' }); correctly uses new pg.Client({ connectionString: ... }). Options B, C, and D use invalid syntax or methods that do not exist.

3. Final Answer:

   const client = new pg.Client({ connectionString: 'postgresql://user:pass@localhost/db' }); -> Option B

4. Quick Check:

   Use new pg.Client with config object [OK]

Hint: Use 'new pg.Client' with config object for connection [OK]

Common Mistakes:

• Calling pg.connect directly without new Client
• Using incorrect method names like Client.connect
• Missing the 'new' keyword when creating Client

3. What will the following code output if the query succeeds?

const { Client } = require('pg');
const client = new Client({ connectionString: 'postgresql://user:pass@localhost/db' });

async function run() {
  await client.connect();
  const res = await client.query('SELECT 1 AS number');
  console.log(res.rows[0].number);
  await client.end();
}

run();

medium

A. 1

B. [{ number: 1 }]

C. undefined

D. Error: query failed

Solution

1. Step 1: Understand the query and result structure

   The query SELECT 1 AS number returns one row with a column named 'number' having value 1.

2. Step 2: Check how the result is accessed

   The code logs res.rows[0].number, which accesses the first row's 'number' field, so it prints 1.

3. Final Answer:

   1 -> Option A

4. Quick Check:

   res.rows[0].number = 1 [OK]

Hint: Access query result via res.rows[0].columnName [OK]

Common Mistakes:

• Logging res.rows instead of a specific field
• Expecting the whole array instead of one value
• Not awaiting client.connect() before query

4. Identify the error in this code snippet that uses pg to connect to PostgreSQL:

const { Client } = require('pg');
const client = new Client({ connectionString: 'postgresql://user:pass@localhost/db' });

client.connect();
const res = await client.query('SELECT NOW()');
console.log(res.rows[0]);
client.end();

medium

A. client.end() should be called before query

B. client.query() should not be awaited

C. No error, code is correct

D. Missing await before client.connect()

Solution

1. Step 1: Check async usage for connect()

   The client.connect() method returns a promise and must be awaited to ensure connection before querying.

2. Step 2: Verify other async calls

   The await before client.query() is correct. Calling client.end() after query is also correct.

3. Final Answer:

   Missing await before client.connect() -> Option D

4. Quick Check:

   Always await client.connect() before queries [OK]

Hint: Always await client.connect() before querying [OK]

Common Mistakes:

• Not awaiting client.connect() causing race conditions
• Awaiting client.query() is correct, so skipping it is wrong
• Calling client.end() too early before query finishes

5. You want to write a Node.js function using pg that connects to PostgreSQL, runs a query, and always closes the connection even if an error occurs. Which pattern is best?

hard

A. Call connect, query, and end sequentially without error handling

B. Only call client.end() if query succeeds, skip on error

C. Use try-catch-finally: connect in try, query in try, close in finally

D. Use callbacks instead of async/await for better error handling

Solution

1. Step 1: Understand error-safe connection handling

   To ensure the connection closes even if an error happens, use a try-catch-finally block where client.end() is called in the finally block.

2. Step 2: Evaluate options for best practice

   Use try-catch-finally: connect in try, query in try, close in finally correctly uses try-catch-finally. Call connect, query, and end sequentially without error handling lacks error handling. Only call client.end() if query succeeds, skip on error risks leaving connection open on errors. Use callbacks instead of async/await for better error handling is outdated compared to async/await.

3. Final Answer:

   Use try-catch-finally: connect in try, query in try, close in finally -> Option C

4. Quick Check:

   try-catch-finally ensures connection closes [OK]

Hint: Use try-catch-finally to always close connection [OK]

Common Mistakes:

• Not closing connection on errors
• Ignoring async/await for error handling
• Closing connection only on success