Error handling with PDO exceptions in PHP - Step-by-Step Execution

Concept Flow - Error handling with PDO exceptions

Start

↓

Try to connect to DB

↓

PDO throws exception?

No→Use DB connection

Yes↓

Catch exception

↓

Handle error (e.g., show message)

↓

End

The program tries to connect to the database. If an error happens, it catches the exception and handles it gracefully.

Execution Sample

PHP

<?php
try {
  $pdo = new PDO($dsn, $user, $pass);
  echo "Connected!";
} catch (PDOException $e) {
  echo "Error: " . $e->getMessage();
}
?>

This code tries to connect to a database and prints a message if it succeeds or an error message if it fails.

Execution Table

Step	Action	Evaluation	Result
1	Try to create PDO object	PDO constructor called with DSN, user, pass	Throws exception if connection fails, else creates object
2	PDO connection success?	No exception thrown	Proceed to echo 'Connected!'
3	Output	Print 'Connected!'	User sees: Connected!
4	Try to create PDO object	PDO constructor called with wrong DSN	Throws PDOException
5	Catch PDOException	Catch block runs	Print error message with exception text
6	Output	Print error message	User sees: Error: [exception message]

💡 Execution stops after printing success or error message.

Variable Tracker

Variable	Start	After Step 1	After Step 4	Final
$pdo	null	PDO object if success	null (exception thrown)	PDO object or null
$e	undefined	undefined	PDOException object	PDOException object or undefined

Key Moments - 3 Insights

Why do we use try-catch with PDO?

Because PDO throws exceptions on errors, try-catch lets us handle these errors without stopping the whole program. See execution_table rows 1 and 4.

What happens if the connection is successful?

The code inside try runs fully and prints 'Connected!'. No catch block runs. See execution_table rows 2 and 3.

What if the connection fails?

PDO throws an exception, the catch block runs and prints the error message. See execution_table rows 4, 5, and 6.

Visual Quiz - 3 Questions

Look at the execution_table, what variable holds the PDOException object?

A $pdo

B $e

C $dsn

D $user

💡 Hint

Check variable_tracker row for $e after Step 4

At which step does the program print 'Connected!'?

A Step 3

B Step 1

C Step 5

D Step 6

💡 Hint

Look at execution_table row with Output 'Connected!'

If the DSN is wrong, what happens in the try block?

A Nothing happens

B PDO object is created successfully

C Exception is thrown and caught

D Program crashes without message

💡 Hint

See execution_table rows 4 and 5 about exception throwing and catching

Concept Snapshot

try {
  $pdo = new PDO($dsn, $user, $pass); // try to connect
  echo "Connected!"; // success message
} catch (PDOException $e) {
  echo "Error: " . $e->getMessage(); // handle error
}
Use try-catch to catch PDO exceptions and avoid program crash.

Full Transcript

This example shows how to handle errors when connecting to a database using PDO in PHP. The code tries to create a PDO object inside a try block. If the connection is successful, it prints 'Connected!'. If there is a problem, PDO throws an exception. The catch block catches this exception and prints an error message. This way, the program does not crash and shows a friendly message instead.

Practice

1. What is the main purpose of using try and catch blocks when working with PDO exceptions in PHP?

easy

A. To create new database tables

B. To handle database errors without stopping the entire program

C. To automatically fix SQL syntax errors

D. To speed up database queries

Solution

1. Step 1: Understand the role of try-catch

   The try block runs code that might cause an error, and catch handles that error safely.

2. Step 2: Relate to PDO exceptions

   PDO exceptions occur on database errors; using try-catch prevents the program from stopping abruptly.

3. Final Answer:

   To handle database errors without stopping the entire program -> Option B

4. Quick Check:

   try-catch handles errors safely = D [OK]

Hint: Try-catch blocks catch errors to keep programs running [OK]

Common Mistakes:

• Thinking try-catch speeds up queries
• Believing it fixes SQL errors automatically
• Confusing error handling with database creation

2. Which of the following is the correct way to set PDO to throw exceptions on errors?

easy

A. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);

B. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);

C. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

D. $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_IGNORE);

Solution

1. Step 1: Identify PDO error modes

   PDO supports error modes: SILENT, WARNING, EXCEPTION, and IGNORE (not standard).

2. Step 2: Choose the mode that throws exceptions

   PDO::ERRMODE_EXCEPTION makes PDO throw exceptions on errors.

3. Final Answer:

   $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); -> Option C

4. Quick Check:

   Exception mode = PDO::ERRMODE_EXCEPTION = B [OK]

Hint: Use ERRMODE_EXCEPTION to get PDO exceptions [OK]

Common Mistakes:

• Using ERRMODE_SILENT which hides errors
• Confusing ERRMODE_WARNING with exceptions
• Using non-existent ERRMODE_IGNORE

3. What will be the output of this PHP code?

$pdo = new PDO('sqlite::memory:');
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
try {
    $pdo->exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)');
    $pdo->exec('INSERT INTO users (id, name) VALUES (1, "Alice")');
    $pdo->exec('INSERT INTO users (id, name) VALUES (1, "Bob")');
    echo "Insert successful";
} catch (PDOException $e) {
    echo "Error: " . $e->getMessage();
}

medium

A. Insert successful

B. Syntax error in SQL statement

C. No output

D. Error: SQLSTATE[23000]: Integrity constraint violation: UNIQUE constraint failed: users.id

Solution

1. Step 1: Understand the code flow

   The code creates a table with a primary key on 'id' and inserts two rows with the same id=1.

2. Step 2: Identify the error

   Inserting duplicate primary keys causes an integrity constraint violation, triggering a PDOException.

3. Final Answer:

   Error: SQLSTATE[23000]: Integrity constraint violation: UNIQUE constraint failed: users.id -> Option D

4. Quick Check:

   Duplicate primary key causes exception = C [OK]

Hint: Duplicate primary keys cause PDOException errors [OK]

Common Mistakes:

• Expecting 'Insert successful' despite duplicate keys
• Thinking it's a syntax error
• Ignoring exception handling output

4. Identify the error in this PHP code snippet that uses PDO exceptions:

try {
    $pdo = new PDO('mysql:host=localhost;dbname=testdb', 'user', 'pass');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $pdo->exec('INVALID SQL');
} catch (PDOException $e) {
    echo 'Error: ' . $e->getMessage();
}

medium

A. SQL statement is invalid causing exception

B. Error mode is not set to exceptions

C. PDO connection string is incorrect

D. Missing catch block for exceptions

Solution

1. Step 1: Check PDO connection and error mode

   The connection string and error mode setting are correct for throwing exceptions.

2. Step 2: Analyze the SQL statement

   The SQL statement 'INVALID SQL' is not valid SQL, so it triggers a PDOException.

3. Final Answer:

   SQL statement is invalid causing exception -> Option A

4. Quick Check:

   Invalid SQL causes exception = A [OK]

Hint: Invalid SQL triggers PDOException if error mode set [OK]

Common Mistakes:

• Assuming connection string is wrong
• Forgetting error mode is set correctly
• Thinking catch block is missing

5. You want to safely insert user data into a database using PDO and handle errors with exceptions. Which of the following code snippets correctly implements this with prepared statements and exception handling?

hard

A. try {
$pdo = new PDO($dsn, $user, $pass);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$stmt = $pdo->prepare('INSERT INTO users (name, email) VALUES (:name, :email)');
$stmt->execute([':name' => $name, ':email' => $email]);
echo 'User added';
} catch (PDOException $e) {
echo 'Error: ' . $e->getMessage();
}

B. $pdo = new PDO($dsn, $user, $pass);
$stmt = $pdo->query('INSERT INTO users (name, email) VALUES ($name, $email)');
echo 'User added';

C. try {
$pdo = new PDO($dsn, $user, $pass);
$stmt = $pdo->prepare('INSERT INTO users (name, email) VALUES (?, ?)');
$stmt->execute([$name, $email]);
echo 'User added';
} catch (Exception $e) {
echo 'Error';
}

D. try {
$pdo = new PDO($dsn, $user, $pass);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
$pdo->exec('INSERT INTO users (name, email) VALUES ("$name", "$email")');
echo 'User added';
} catch (PDOException $e) {
echo 'Error: ' . $e->getMessage();
}

Solution

1. Step 1: Check for proper error mode setting

   try { $pdo = new PDO($dsn, $user, $pass); $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $stmt = $pdo->prepare('INSERT INTO users (name, email) VALUES (:name, :email)'); $stmt->execute([':name' => $name, ':email' => $email]); echo 'User added'; } catch (PDOException $e) { echo 'Error: ' . $e->getMessage(); } sets PDO::ATTR_ERRMODE to ERRMODE_EXCEPTION, enabling exception handling.

2. Step 2: Verify use of prepared statements and parameter binding

   try { $pdo = new PDO($dsn, $user, $pass); $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $stmt = $pdo->prepare('INSERT INTO users (name, email) VALUES (:name, :email)'); $stmt->execute([':name' => $name, ':email' => $email]); echo 'User added'; } catch (PDOException $e) { echo 'Error: ' . $e->getMessage(); } uses prepared statements with named parameters and executes safely with user data.

3. Step 3: Confirm exception handling

   try { $pdo = new PDO($dsn, $user, $pass); $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $stmt = $pdo->prepare('INSERT INTO users (name, email) VALUES (:name, :email)'); $stmt->execute([':name' => $name, ':email' => $email]); echo 'User added'; } catch (PDOException $e) { echo 'Error: ' . $e->getMessage(); } catches PDOException and outputs the error message, providing safe error handling.

4. Final Answer:

   try { $pdo = new PDO($dsn, $user, $pass); $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); $stmt = $pdo->prepare('INSERT INTO users (name, email) VALUES (:name, :email)'); $stmt->execute([':name' => $name, ':email' => $email]); echo 'User added'; } catch (PDOException $e) { echo 'Error: ' . $e->getMessage(); } -> Option A

5. Quick Check:

   Prepared + ERRMODE_EXCEPTION + try-catch = A [OK]

Hint: Use prepared statements with ERRMODE_EXCEPTION and try-catch [OK]

Common Mistakes:

• Not setting error mode to exceptions
• Using query() with unescaped variables
• Catching generic Exception instead of PDOException
• Using ERRMODE_WARNING which doesn't throw exceptions