Mastering sql

Presentation Objectives

 Understand the Basics of SQL

 Create and Modify Databases and Tables
 Insert, Update, and Delete Data
 Master Querying Data
 Understand Database Relationships
 Perform Advanced SQL Queries Using Joins
 Create and Use Views
 Develop and Use Stored Procedures
 Write and Implement Functions in SQL
 Implement Triggers for Data Integrity
 Understand Transactions and Data Consistency
 Apply SQL Concepts in Real-World Scenarios

Introduction to SQL

What is SQL?
SQL (Structured Query Language) is used for managing and manipulating databases. SQL
allows us to interact with databases through commands.

SQL Commands Overview

Types of SQL Commands

 DDL: Data Definition Language (CREATE, ALTER, DROP)

 DML: Data Manipulation Language (SELECT, INSERT, UPDATE, DELETE)
 DCL: Data Control Language (GRANT, REVOKE)
 TCL: Transaction Control Language (COMMIT, ROLLBACK)

Creating a Database

SQL Command: CREATE DATABASE

CREATE DATABASE School;

USE School;

Dropping a Database
SQL Command: DROP DATABASE

DROP DATABASE School;

Creating a Table

SQL Command: CREATE TABLE

CREATE TABLE Students (

id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50) NOT NULL,
age INT CHECK (age >= 5),
email VARCHAR(100) UNIQUE,
grade VARCHAR(5) NOT NULL
);

Common Constraints

Types of Constraints

 NOT NULL: Ensures a column cannot store NULL values.

 UNIQUE: Ensures all values in a column are distinct.
 CHECK: Ensures a column meets a specific condition.
 PRIMARY KEY: Uniquely identifies each row in a table.
 FOREIGN KEY: Ensures referential integrity between tables.

Altering Tables

SQL Command: ALTER TABLE

ALTER TABLE Students ADD COLUMN address VARCHAR(50);

ALTER TABLE Students ADD CONSTRAINT chk_age CHECK (age >= 5);

Inserting Data

SQL Command: INSERT INTO

INSERT INTO Students (name, age, email, grade)

VALUES ('Alice', 14, '[email protected]', '8th');

Updating Data
SQL Command: UPDATE

UPDATE Students SET age = 15 WHERE name = 'Alice';

Deleting Data

SQL Command: DELETE

DELETE FROM Students WHERE name = 'Alice';

Selecting Data

SQL Command: SELECT

SELECT * FROM Students;

SELECT name, age FROM Students;

Select with WHERE Clause

SQL Command: SELECT ... WHERE

SELECT name, age FROM Students WHERE age > 10;

Select with ORDER BY

SQL Command: SELECT ... ORDER BY

SELECT name, age FROM Students ORDER BY age DESC;

Select with LIKE

SQL Command: SELECT ... LIKE

SELECT name FROM Students WHERE name LIKE 'A%';

Select with BETWEEN

SQL Command: SELECT ... BETWEEN

SELECT name FROM Students WHERE age BETWEEN 10 AND 15;

Select with TOP and LIMIT

SQL Command: SELECT ... LIMIT or TOP

SELECT * FROM Students LIMIT 5;

Aggregate Functions

SQL Command: COUNT(), AVG(), SUM()

SELECT COUNT(*) FROM Students;

SELECT AVG(age) FROM Students;
SELECT SUM(age) FROM Students;

One-to-One Relationships

Example: A Student has one Profile.

CREATE TABLE StudentProfile (

student_id INT PRIMARY KEY,
address VARCHAR(255),
FOREIGN KEY (student_id) REFERENCES Students(id)
);

One-to-Many Relationships

Example: A Teacher teaches many Students.

CREATE TABLE Teachers (

id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50) NOT NULL
);

CREATE TABLE Students (

id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50) NOT NULL,
teacher_id INT,
FOREIGN KEY (teacher_id) REFERENCES Teachers(id)
);

Many-to-One Relationships

Example: Many Students belong to one Grade.

CREATE TABLE Grades (

id INT PRIMARY KEY AUTO_INCREMENT,
 grade_name VARCHAR(5) NOT NULL
);

ALTER TABLE Students ADD COLUMN grade_id INT;

ALTER TABLE Students ADD FOREIGN KEY (grade_id) REFERENCES Grades(id);

Many-to-Many Relationships

Example: Many Students enroll in many Courses.

CREATE TABLE Courses (

id INT PRIMARY KEY AUTO_INCREMENT,
course_name VARCHAR(100) NOT NULL
);

CREATE TABLE StudentCourses (

student_id INT,
course_id INT,
PRIMARY KEY (student_id, course_id),
FOREIGN KEY (student_id) REFERENCES Students(id),
FOREIGN KEY (course_id) REFERENCES Courses(id)
);

Inner Join

Example: Matching records from both tables.

SELECT Students.name, Courses.course_name

FROM Students
INNER JOIN StudentCourses ON Students.id = StudentCourses.student_id
INNER JOIN Courses ON StudentCourses.course_id = Courses.id;

Left Join

Example: All students, even without courses.

SELECT Students.name, Courses.course_name

FROM Students
LEFT JOIN StudentCourses ON Students.id = StudentCourses.student_id
LEFT JOIN Courses ON StudentCourses.course_id = Courses.id;

Right Join

Example: All courses, even without students.

SELECT Students.name, Courses.course_name

FROM Students
RIGHT JOIN StudentCourses ON Students.id = StudentCourses.student_id
RIGHT JOIN Courses ON StudentCourses.course_id = Courses.id;

Full Outer Join

Example: Returns all students and all courses.

SELECT Students.name, Courses.course_name

FROM Students
LEFT JOIN StudentCourses ON Students.id = StudentCourses.student_id
LEFT JOIN Courses ON StudentCourses.course_id = Courses.id
UNION
SELECT Students.name, Courses.course_name
FROM Students
RIGHT JOIN StudentCourses ON Students.id = StudentCourses.student_id
RIGHT JOIN Courses ON StudentCourses.course_id = Courses.id;

Creating a View

SQL Command: CREATE VIEW

CREATE VIEW TeenStudents AS

SELECT * FROM Students WHERE age >= 13;
SELECT * FROM TeenStudents;

Introduction to Stored Procedures

A stored procedure is a set of SQL statements that can be executed as a unit.

Creating a Simple Stored Procedure

SQL Command: CREATE PROCEDURE

DELIMITER //
CREATE PROCEDURE GetStudentsByGrade(IN gradeLevel VARCHAR(5))
BEGIN
SELECT * FROM Students WHERE grade = gradeLevel;
END //
DELIMITER ;

Stored Procedure with Output Parameters

Example: Returning student count.

DELIMITER //
CREATE PROCEDURE GetStudentCountByGrade(IN gradeLevel VARCHAR(5), OUT
studentCount INT)
BEGIN
SELECT COUNT(*) INTO studentCount FROM Students WHERE grade = gradeLevel;
END //
DELIMITER ;

Calling a Stored Procedure

Usage: Calling a stored procedure and fetching results.

CALL GetStudentCountByGrade('8th', @count);

SELECT @count;

Stored Procedure with Multiple Queries

Example: Retrieving student details and their grade.

DELIMITER //
CREATE PROCEDURE GetStudentDetails(IN studentID INT)
BEGIN
SELECT * FROM Students WHERE id = studentID;
SELECT * FROM Grades WHERE student_id = studentID;
END //
DELIMITER ;

Introduction to Functions

Functions in SQL return a single value and are used for calculations.

Creating a Function

Example: Calculate student age.

DELIMITER //
CREATE FUNCTION CalculateAge(birthdate DATE) RETURNS INT DETERMINISTIC
BEGIN
RETURN TIMESTAMPDIFF(YEAR, birthdate, CURDATE());
END //
DELIMITER ;

Using Functions
SQL Command: Using CalculateAge function.

SELECT CalculateAge('2005-04-20');

Function with Conditional Logic

Example: Get student grade based on age.

DELIMITER //
CREATE FUNCTION GetGradeByAge(age INT) RETURNS VARCHAR(5)
BEGIN
IF age >= 15 THEN
RETURN 'High School';
ELSE
RETURN 'Middle School';
END IF;
END //
DELIMITER ;

Advanced Function Example

Example: Calculate total fee based on number of courses.

DELIMITER //
CREATE FUNCTION CalculateFee(courseCount INT) RETURNS DECIMAL(10,2)
BEGIN
RETURN courseCount * 100;
END //
DELIMITER ;

Introduction to Triggers

Triggers are automatic actions executed when certain events occur in a database.

Creating a BEFORE INSERT Trigger

SQL Command: Prevent inserting students under age 5.

DELIMITER //
CREATE TRIGGER before_student_insert
BEFORE INSERT ON Students
FOR EACH ROW
BEGIN
IF NEW.age < 5 THEN
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Age must be at least 5';
 END IF;
END //
DELIMITER ;

Creating a BEFORE UPDATE Trigger

SQL Command: Prevent grade downgrade.

DELIMITER //
CREATE TRIGGER prevent_grade_downgrade
BEFORE UPDATE ON Students
FOR EACH ROW
BEGIN
IF NEW.grade < OLD.grade THEN
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Grade downgrade not
allowed';
END IF;
END //
DELIMITER ;

AFTER INSERT Trigger

Example: Logging student insertions.

DELIMITER //
CREATE TRIGGER after_student_insert

AFTER INSERT ON Students FOR EACH ROW BEGIN INSERT INTO StudentLog
(student_id, action) VALUES (NEW.id, 'Student Inserted'); END // DELIMITER ;

---

### AFTER UPDATE Trigger

**Example**: Log student grade change.
```sql
DELIMITER //
CREATE TRIGGER after_grade_update
AFTER UPDATE ON Students
FOR EACH ROW
BEGIN
IF NEW.grade != OLD.grade THEN
INSERT INTO GradeChangeLog (student_id, old_grade, new_grade,
timestamp)
VALUES (NEW.id, OLD.grade, NEW.grade, NOW());
END IF;
END //
DELIMITER ;
BEFORE DELETE Trigger

Example: Prevent deletion of a student under 18.

DELIMITER //
CREATE TRIGGER before_student_delete
BEFORE DELETE ON Students
FOR EACH ROW
BEGIN
IF OLD.age < 18 THEN
SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Cannot delete student
under 18';
END IF;
END //
DELIMITER ;

Trigger Example for Audit

Example: Track changes in students' grades.

DELIMITER //
CREATE TRIGGER audit_student_changes
AFTER UPDATE ON Students
FOR EACH ROW
BEGIN
INSERT INTO AuditLog (student_id, action, old_value, new_value, timestamp)
VALUES (NEW.id, 'Grade Change', OLD.grade, NEW.grade, NOW());
END //
DELIMITER ;

Transactions in SQL

Transactions ensure data integrity.

 START TRANSACTION, COMMIT, ROLLBACK

Example: Simple Transaction

START TRANSACTION;
UPDATE Students SET age = age + 1 WHERE grade = '8th';
IF (SELECT COUNT(*) FROM Students WHERE grade = '8th') > 10 THEN
COMMIT;
ELSE
ROLLBACK;
END IF;
Example: Bank Transfer (Transaction)
START TRANSACTION;
UPDATE Accounts SET balance = balance - 500 WHERE account_id = 1;
UPDATE Accounts SET balance = balance + 500 WHERE account_id = 2;
IF ROW_COUNT() = 0 THEN
ROLLBACK;
ELSE
COMMIT;
END IF;

Interactive Hands-On Exercises

 Exercise 1: Create a stored procedure to calculate student attendance.

 Exercise 2: Write a trigger to log any deletions from the Students table.