MIT 213 – DATA MANAGEMENT

TUTORIAL 8: Advanced Database Operations

1 Introduction
In the realm of data management, Structured Query Language (SQL) serves as a foundational
tool for interacting with databases. As databases evolve to accommodate complex applications,
advanced database operations become essential for ensuring efficiency, reliability, and
maintainability. This overview focuses on two critical areas: working with stored procedures,
functions, and triggers, and handling exceptions and errors in SQL.
1.1 Working with Stored Procedures, Functions, and Triggers
Stored procedures and functions encapsulate SQL code, allowing for reusable and modular
programming. A stored procedure is a set of SQL statements that can be executed as a single
unit, enabling developers to perform complex operations without needing to rewrite code.
Functions, on the other hand, return a single value and can be used within SQL statements,
enhancing the flexibility of queries.
Triggers are automated responses to specific events on a table, such as INSERT, UPDATE, or
DELETE operations. They help maintain data integrity and enforce business rules by executing
predefined actions in reaction to database changes. Understanding how to effectively create
and manage these elements is crucial for optimizing database performance and ensuring
consistent application behaviour.
1.2 Handling Exceptions and Errors in SQL
Despite robust planning and execution, errors can still occur during database operations.
Handling exceptions and errors in SQL is vital for maintaining the integrity of applications and
providing a seamless user experience. SQL offers various mechanisms for error handling,
allowing developers to anticipate potential issues and respond appropriately.
By employing structured exception handling, developers can catch and manage errors without
disrupting the flow of the application. This includes logging errors for analysis, rolling back
transactions to preserve data consistency, and providing informative feedback to users. Mastery
of these techniques is essential for building resilient database applications that can gracefully
manage unexpected situations.
In summary, advanced database operations involving stored procedures, functions, triggers,
and robust error handling are crucial for effective data management using SQL. These
techniques empower developers to create efficient, responsive, and reliable database
applications, ultimately enhancing the overall functionality and user experience of the systems
they support.

2 Data Management Using SQL: Working with Stored

Procedures, Functions, and Triggers
In the domain of SQL database management, stored procedures, functions, and triggers are
powerful tools that enhance the functionality and maintainability of database applications. This
section explores how to create and manage these components, illustrating their usage with SQL
code examples based on a sample dataset.
2.1 Sample Dataset
To illustrate the concepts, let's consider a simple dataset for a bookstore. This dataset includes
two tables: Books and Sales.
2.1.1 Table Structure
2.1.1.1 Books Table
CREATE TABLE Books (
BookID INT PRIMARY KEY,
Title VARCHAR(100),
Author VARCHAR(100),
Price DECIMAL(10, 2),
Stock INT
);
2.1.1.2 Sales Table
CREATE TABLE Sales (
SaleID INT PRIMARY KEY,
BookID INT,
Quantity INT,
SaleDate DATETIME,
FOREIGN KEY (BookID) REFERENCES Books(BookID)
);
2.1.1.3 Populating the Tables
To have some data to work with, we can insert a few records into the Books table.
INSERT INTO Books (BookID, Title, Author, Price, Stock) VALUES
(1, 'The Great Gatsby', 'F. Scott Fitzgerald', 10.99, 5),
(2, '1984', 'George Orwell', 8.99, 10),
(3, 'To Kill a Mockingbird', 'Harper Lee', 12.99, 7);
2.2 Working with Stored Procedures
2.2.1 Definition and Purpose
A stored procedure is a precompiled collection of SQL statements and optional control-flow
statements stored under a name and processed as a unit. They improve performance,
encapsulate business logic, and enhance security.
2.2.2 Creating a Stored Procedure
Let’s create a stored procedure to add a new book to the Books table. This procedure will take
parameters for the book details and handle the insertion.
DELIMITER //

CREATE PROCEDURE AddBook(

IN p_Title VARCHAR(100),
IN p_Author VARCHAR(100),
IN p_Price DECIMAL(10, 2),
IN p_Stock INT
)
BEGIN
INSERT INTO Books (Title, Author, Price, Stock)
VALUES (p_Title, p_Author, p_Price, p_Stock);
END //

DELIMITER ;
2.2.3 Executing the Stored Procedure
To execute the AddBook procedure, you would call it with the required parameters:
CALL AddBook('Brave New World', 'Aldous Huxley', 9.99, 8);
This command will insert a new book into the Books table with the specified details.

2.3 Working with Functions

2.3.1 Definition and Purpose
A function is similar to a stored procedure but is designed to return a single value. Functions
can be used in SQL expressions, making them versatile for calculations and data
transformations.
2.3.2 Creating a Function
Let’s create a function to calculate the total price of a given quantity of a book based on its
BookID.

DELIMITER //

CREATE FUNCTION GetTotalPrice(p_BookID INT, p_Quantity INT)

RETURNS DECIMAL(10, 2)
BEGIN
DECLARE total DECIMAL(10, 2);

SELECT Price * p_Quantity INTO total

FROM Books
WHERE BookID = p_BookID;

RETURN total;
END //

DELIMITER ;
2.3.3 Using the Function
You can use the GetTotalPrice function in a SQL statement to calculate the total price for a
specific book and quantity:
SELECT GetTotalPrice(1, 3) AS TotalPrice; -- Calculates total price for 3
copies of "The Great Gatsby"
2.4 Working with Triggers
2.4.1 Definition and Purpose
Triggers are special types of stored procedures that automatically execute in response to certain
events on a table, such as INSERT, UPDATE, or DELETE. They are useful for enforcing
business rules and maintaining data integrity.
2.4.2 Creating a Trigger
Let’s create a trigger that updates the stock quantity in the Books table whenever a sale is made
in the Sales table.
DELIMITER //

CREATE TRIGGER UpdateStockOnSale

AFTER INSERT ON Sales
FOR EACH ROW
BEGIN
UPDATE Books
SET Stock = Stock - NEW.Quantity
WHERE BookID = NEW.BookID;
END //
DELIMITER ;
2.4.3 Testing the Trigger
When a new sale is recorded in the Sales table, the trigger will automatically adjust the stock
in the Books table. For example:
INSERT INTO Sales (SaleID, BookID, Quantity, SaleDate) VALUES (1, 1, 2,
NOW());
After executing this command, the stock for "The Great Gatsby" will be automatically reduced
by 2.
2.5 Conclusion
Stored procedures, functions, and triggers are essential components of advanced SQL database
operations. They encapsulate business logic, enhance performance, and ensure data integrity.
By using these elements effectively, developers can create robust and maintainable database
applications that meet complex business requirements. This overview, complemented by
practical SQL code examples, provides a solid foundation for further exploration of data
management using SQL.

3 Data Management Using SQL: Handling Exceptions and

Errors in SQL
Effective data management using SQL requires not only the ability to perform operations but
also to handle exceptions and errors gracefully. Understanding how to manage errors is crucial
for maintaining data integrity and providing a smooth user experience. This section explores
how to handle exceptions and errors in SQL, using practical examples based on a sample
dataset.
3.1 Understanding Errors and Exceptions
When executing SQL statements, various errors and exceptions can occur, such as:
• Syntax Errors: Mistakes in SQL syntax can prevent the execution of a statement.
• Data Type Mismatches: Inserting or updating data with an incorrect data type leads to
errors.
• Constraint Violations: Violating primary key, foreign key, or unique constraints can
cause exceptions.
• Division by Zero: Performing arithmetic operations that result in division by zero will
trigger an error.
3.2 Using TRY...CATCH for Error Handling
SQL Server and MySQL (with certain limitations) provide structured error handling using
TRY...CATCH blocks, allowing developers to catch and respond to errors gracefully.

3.2.1 Example of TRY...CATCH

Suppose we want to implement a sale process that updates the Stock in the Books table and
records the sale in the Sales table. We can use a TRY...CATCH block to handle potential errors.
DELIMITER //

CREATE PROCEDURE ProcessSale(

IN p_BookID INT,
IN p_Quantity INT
)
BEGIN
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
-- Handle the error by rolling back the transaction and logging it
ROLLBACK;
SELECT 'An error occurred. The sale could not be processed.' AS
ErrorMessage;
END;

-- Start a transaction
START TRANSACTION;

-- Check if there is enough stock

DECLARE v_Stock INT;
SELECT Stock INTO v_Stock FROM Books WHERE BookID = p_BookID;

IF v_Stock < p_Quantity THEN

SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Insufficient stock for
the requested sale.';
END IF;

-- Insert the sale record

INSERT INTO Sales (SaleID, BookID, Quantity, SaleDate)
VALUES (NULL, p_BookID, p_Quantity, NOW());

-- Update the stock

UPDATE Books
SET Stock = Stock - p_Quantity
WHERE BookID = p_BookID;

-- Commit the transaction if everything is successful

COMMIT;
END //

DELIMITER ;
3.2.2 Executing the Stored Procedure
Now, let's see how this procedure behaves in different scenarios.
3.2.2.1 Successful Sale:
CALL ProcessSale(1, 2); -- This should succeed if stock is sufficient
3.2.2.2 Sale with Insufficient Stock:
CALL ProcessSale(1, 10); -- This should trigger an error and roll back the
transaction
3.3 Error Messages
When the second call is executed, the procedure will catch the error and return:
An error occurred. The sale could not be processed.
3.4 Logging Errors
In larger applications, it is often beneficial to log errors for further analysis. This can be
achieved by creating an error log table.
3.5 Creating an Error Log Table
CREATE TABLE ErrorLog (
ErrorID INT AUTO_INCREMENT PRIMARY KEY,
ErrorMessage VARCHAR(255),
ErrorDate DATETIME
);
3.6 Modifying the Error Handler to Log Errors
We can modify the EXIT HANDLER in our stored procedure to log errors into the ErrorLog
table:
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
-- Log the error message
INSERT INTO ErrorLog (ErrorMessage, ErrorDate)
VALUES (CONCAT('Error processing sale for BookID: ', p_BookID), NOW());

-- Handle the error

ROLLBACK;
SELECT 'An error occurred. The sale could not be processed.' AS
ErrorMessage;
END;
3.7 Conclusion
Handling exceptions and errors in SQL is crucial for building robust and user-friendly database
applications. By utilizing constructs like TRY...CATCH and implementing error logging,
developers can anticipate potential issues, maintain data integrity, and provide meaningful
feedback to users. The examples provided illustrate how to effectively manage errors in SQL,
ensuring that applications can gracefully handle unexpected situations while maintaining a
seamless experience for users. This foundational understanding of error handling will serve as
a cornerstone for more advanced data management techniques in SQL.