Why database connectivity matters in Node.js - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the database client module.

Node.js

const dbClient = require('[1]');

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

Aexpress

Bmongodb

Cfs

Dhttp

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'express' or 'http' which are for servers, not databases.

The mongodb module is used to connect to a MongoDB database in Node.js.

2fill in blank

medium

Complete the code to connect to the database using the client.

Node.js

dbClient.connect('[1]', (err) => {
  if (err) throw err;
  console.log('Connected!');
});

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

Amongodb://localhost:27017

Bhttp://localhost:3000

Cftp://localhost

Dfile://localhost

Attempts:

3 left

💡 Hint

Common Mistakes

Using HTTP or FTP protocols which are not for database connections.

The connection string for MongoDB starts with mongodb:// followed by the host and port.

3fill in blank

hard

Fix the error in the code to properly close the database connection.

Node.js

dbClient.[1]();

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

Astop

Bdisconnect

Cend

Dclose

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'disconnect' or 'end' which are not valid methods for MongoDB client.

The correct method to close a MongoDB client connection is close().

4fill in blank

hard

Fill both blanks to create a query that finds all users older than 18.

Node.js

db.collection('users').find({ age: { [1]: [2] } }).toArray((err, results) => {
  if (err) throw err;
  console.log(results);
});

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

A$gt

B18

C$lt

D21

Attempts:

3 left

💡 Hint

Common Mistakes

Using '$lt' which means 'less than', or wrong age values.

The MongoDB query operator $gt means 'greater than'. We want users older than 18.

5fill in blank

hard

Fill all three blanks to insert a new user with name and age into the database.

Node.js

db.collection('[1]').insertOne({ name: '[2]', age: [3] }, (err, res) => {
  if (err) throw err;
  console.log('User added');
});

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

Ausers

BAlice

C30

Dproducts

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong collection names or putting age as a string.

We insert into the 'users' collection a user named 'Alice' who is 30 years old.

Practice

1. Why is database connectivity important in a Node.js application?

easy

A. It makes the app run faster without any data storage.

B. It allows the app to save and retrieve data persistently.

C. It helps the app display colors on the screen.

D. It automatically fixes bugs in the code.

Solution

1. Step 1: Understand the role of database connectivity

   Database connectivity lets the app communicate with a database to save or get data.

2. Step 2: Identify the importance for data persistence

   Without database connectivity, the app cannot remember or update information after it stops running.

3. Final Answer:

   It allows the app to save and retrieve data persistently. -> Option B

4. Quick Check:

   Database connectivity = save and retrieve data [OK]

Hint: Database connectivity means saving and getting data [OK]

Common Mistakes:

• Thinking it speeds up the app without data storage
• Confusing database connectivity with UI features
• Assuming it fixes code bugs automatically

2. Which of the following is the correct way to start a database connection in Node.js using a common library?

easy

A. const db = require('mysql').createConnection(config);

B. const db = connect('database');

C. const db = require('db').connect();

D. connect.db('mysql', config);

Solution

1. Step 1: Recognize common Node.js database connection syntax

   Popular libraries like mysql use require('mysql').createConnection(config) to connect.

2. Step 2: Check each option for correct syntax

   const db = require('mysql').createConnection(config); matches the correct pattern; others have wrong method calls or missing parts.

3. Final Answer:

   const db = require('mysql').createConnection(config); -> Option A

4. Quick Check:

   Correct connection syntax = const db = require('mysql').createConnection(config); [OK]

Hint: Look for require + createConnection pattern [OK]

Common Mistakes:

• Using connect() directly without require
• Wrong method names like connect.db
• Missing configuration object

3. What will the following Node.js code output if the database connection fails?

const mysql = require('mysql');
const connection = mysql.createConnection({host: 'localhost', user: 'root', password: 'wrong'});
connection.connect(err => {
  if (err) {
    console.log('Connection error');
  } else {
    console.log('Connected');
  }
});

medium

A. Connected

B. SyntaxError

C. Connection error

D. No output

Solution

1. Step 1: Understand the connection callback behavior

   The connect method calls the callback with an error if connection fails.

2. Step 2: Analyze the error handling in the callback

   If err exists, it logs 'Connection error'; otherwise, 'Connected'. Wrong password causes err.

3. Final Answer:

   Connection error -> Option C

4. Quick Check:

   Error in connect logs 'Connection error' [OK]

Hint: Error in connect callback logs 'Connection error' [OK]

Common Mistakes:

• Assuming it logs 'Connected' even on failure
• Expecting a syntax error from wrong password
• Thinking no output occurs on failure

4. Identify the error in this Node.js database connection code:

const mysql = require('mysql');
const connection = mysql.createConnection({host: 'localhost', user: 'root', password: 'pass'});
connection.connect();
connection.query('SELECT * FROM users', (err, results) => {
  if (err) throw err;
  console.log(results);
});
connection.end();

medium

A. createConnection() requires a callback function.

B. query() method is used incorrectly with wrong parameters.

C. end() should be called before query() to close connection early.

D. Missing callback in connect() causes query to run before connection is ready.

Solution

1. Step 1: Check connection timing

   connect() is asynchronous; without a callback, query may run before connection is ready.

2. Step 2: Identify the impact on query execution

   Running query before connection is established can cause errors or unexpected behavior.

3. Final Answer:

   Missing callback in connect() causes query to run before connection is ready. -> Option D

4. Quick Check:

   connect() async needs callback before query [OK]

Hint: Always use callback or await after connect() before queries [OK]

Common Mistakes:

• Calling end() too early before queries finish
• Thinking createConnection needs a callback
• Misusing query() parameters

5. You want to build a Node.js app that stores user preferences and updates them often. Which approach best ensures data is saved and updated correctly?

hard

A. Connect to the database once at app start, reuse connection for all queries, and close on app exit.

B. Open a new database connection for every query and close it immediately after.

C. Store preferences only in memory variables without database connection.

D. Use database connection only for reading data, not for saving updates.

Solution

1. Step 1: Consider connection efficiency and data consistency

   Reusing one connection reduces overhead and keeps queries consistent.

2. Step 2: Evaluate options for frequent updates

   Opening and closing connections for each query wastes resources; in-memory storage loses data on restart.

3. Final Answer:

   Connect to the database once at app start, reuse connection for all queries, and close on app exit. -> Option A

4. Quick Check:

   Reuse connection for frequent updates [OK]

Hint: Reuse one connection for many queries, close at app end [OK]

Common Mistakes:

• Opening/closing connection for every query wastes resources
• Not using database loses persistent data
• Using DB only for reads misses updates