## Experiment 1: DDL Commands using CREATE, ALTER, TRUNCATE and DROP
```sql
-- Create a database
CREATE DATABASE student_management;
-- Use the database
USE student_management;
-- Create a table
CREATE TABLE students (
student_id INT,
first_name VARCHAR(50),
last_name VARCHAR(50),
age INT,
email VARCHAR(100)
);
-- Alter table to add a column
ALTER TABLE students ADD COLUMN phone_number VARCHAR(15);
-- Alter table to modify a column
ALTER TABLE students MODIFY COLUMN age TINYINT;
-- Truncate table (remove all data but keep structure)
TRUNCATE TABLE students;
-- Drop table (remove completely)
DROP TABLE students;
```
## Experiment 2: DDL Commands with Constraints
```sql
CREATE TABLE students (
student_id INT PRIMARY KEY AUTO_INCREMENT,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
age TINYINT CHECK (age >= 18),
email VARCHAR(100) UNIQUE,
admission_date DATE DEFAULT (CURRENT_DATE),
department_id INT,
CONSTRAINT fk_department
FOREIGN KEY (department_id)
REFERENCES departments(department_id)
);
CREATE TABLE departments (
department_id INT PRIMARY KEY,
department_name VARCHAR(50) NOT NULL
);
```
## Experiment 3: DML Commands using INSERT, SELECT
```sql
-- Insert single record
INSERT INTO students (first_name, last_name, age, email)
-- Insert multiple records
INSERT INTO students (first_name, last_name, age, email)
VALUES
-- Select all records
SELECT * FROM students;
-- Select specific columns
SELECT first_name, last_name FROM students;
-- Select with condition
SELECT * FROM students WHERE age > 20;
```
## Experiment 4: DML Commands using UPDATE, DELETE
```sql
-- Update single record
UPDATE students
SET age = 23
WHERE student_id = 1;
-- Update multiple records
UPDATE students
SET department_id = 101
WHERE age > 20;
-- Delete specific record
DELETE FROM students
WHERE student_id = 3;
-- Delete with condition
DELETE FROM students
WHERE age < 18;
```
## Experiment 5: TCL Commands
```sql
-- Start transaction
START TRANSACTION;
-- Perform operations
INSERT INTO students (first_name, last_name, age)
VALUES ('Alice', 'Brown', 22);
-- Create savepoint
SAVEPOINT sp1;
UPDATE students SET age = 24 WHERE first_name = 'Alice';
-- Rollback to savepoint
ROLLBACK TO sp1;
-- Commit transaction
COMMIT;
-- Rollback entire transaction (if needed)
-- ROLLBACK;
```
## Experiment 6: DCL Commands
```sql
-- Create user
CREATE USER 'student_user'@'localhost' IDENTIFIED BY 'password123';
-- Grant privileges
GRANT SELECT, INSERT ON student_management.* TO 'student_user'@'localhost';
-- Revoke privileges
REVOKE INSERT ON student_management.* FROM 'student_user'@'localhost';
-- Show grants
SHOW GRANTS FOR 'student_user'@'localhost';
```
## Experiment 7: SELECT with WHERE and pattern matching
```sql
-- Exact match
SELECT * FROM students WHERE first_name = 'John';
-- Pattern matching with LIKE
SELECT * FROM students WHERE last_name LIKE 'S%';
-- Case insensitive search
SELECT * FROM students WHERE LOWER(first_name) = 'john';
-- Multiple conditions
SELECT * FROM students
WHERE age > 20 AND (last_name LIKE 'D%' OR last_name LIKE 'S%');
```
## Experiment 8: SELECT with BETWEEN, IN, Aggregate Functions
```sql
-- BETWEEN
SELECT * FROM students WHERE age BETWEEN 20 AND 22;
-- IN
SELECT * FROM students WHERE department_id IN (101, 102, 103);
-- Aggregate functions
SELECT
COUNT(*) AS total_students,
AVG(age) AS average_age,
MIN(age) AS youngest,
MAX(age) AS oldest
FROM students;
```
## Experiment 9: SELECT with GROUP BY, HAVING, ORDER BY
```sql
-- Group by department with count
SELECT
department_id,
COUNT(*) AS student_count
FROM students
GROUP BY department_id;
-- Having clause
SELECT
department_id,
AVG(age) AS avg_age
FROM students
GROUP BY department_id
HAVING AVG(age) > 20;
-- Order by
SELECT * FROM students
ORDER BY last_name ASC, first_name ASC;
```
## Experiment 10: SubQuery & Correlated Query
```sql
-- Subquery in WHERE
SELECT * FROM students
WHERE department_id IN (
SELECT department_id FROM departments
WHERE department_name = 'Computer Science'
);
-- Correlated subquery
SELECT s.first_name, s.last_name
FROM students s
WHERE EXISTS (
SELECT 1 FROM departments d
WHERE d.department_id = s.department_id
AND d.department_name LIKE '%Science%'
);
```
## Experiment 11: Joins
```sql
-- Inner join
SELECT s.first_name, s.last_name, d.department_name
FROM students s
INNER JOIN departments d ON s.department_id = d.department_id;
-- Left outer join
SELECT s.first_name, s.last_name, d.department_name
FROM students s
LEFT JOIN departments d ON s.department_id = d.department_id;
-- Right outer join
SELECT s.first_name, s.last_name, d.department_name
FROM students s
RIGHT JOIN departments d ON s.department_id = d.department_id;
```
## Experiment 12: VIEW and INDEX
```sql
-- Create view
CREATE VIEW student_department_view AS
SELECT s.student_id, s.first_name, s.last_name, d.department_name
FROM students s
JOIN departments d ON s.department_id = d.department_id;
-- Create index
CREATE INDEX idx_student_name ON students(last_name, first_name);
-- Show indexes
SHOW INDEX FROM students;
```
## Experiment 13: AUTO_INCREMENT SEQUENCES
```sql
-- Using AUTO_INCREMENT
CREATE TABLE courses (
course_id INT PRIMARY KEY AUTO_INCREMENT,
course_name VARCHAR(100) NOT NULL,
credits TINYINT NOT NULL
) AUTO_INCREMENT=1001;
-- Insert records (ID will auto-increment)
INSERT INTO courses (course_name, credits)
VALUES ('Database Systems', 4), ('Algorithms', 3);
-- Reset auto-increment
ALTER TABLE courses AUTO_INCREMENT = 2001;
```
## Experiment 14: REPEAT and WHILE loops
```sql
-- Procedure with REPEAT loop
DELIMITER //
CREATE PROCEDURE populate_test_data(IN num_records INT)
BEGIN
DECLARE i INT DEFAULT 1;
REPEAT
INSERT INTO test_table (value) VALUES (CONCAT('Test ', i));
SET i = i + 1;
UNTIL i > num_records END REPEAT;
END //
DELIMITER ;
-- Procedure with WHILE loop
DELIMITER //
CREATE PROCEDURE update_student_ages()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE s_id INT;
DECLARE cur CURSOR FOR SELECT student_id FROM students;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
OPEN cur;
read_loop: WHILE NOT done DO
FETCH cur INTO s_id;
IF NOT done THEN
UPDATE students SET age = age + 1 WHERE student_id = s_id;
END IF;
END WHILE;
CLOSE cur;
END //
DELIMITER ;
```
## Experiment 15: CASE and LOOP
```sql
-- Using CASE in SELECT
SELECT
first_name,
last_name,
CASE
WHEN age < 20 THEN 'Freshman'
WHEN age BETWEEN 20 AND 22 THEN 'Sophomore'
ELSE 'Senior'
END AS student_level
FROM students;
-- Procedure with LOOP
DELIMITER //
CREATE PROCEDURE generate_departments()
BEGIN
DECLARE i INT DEFAULT 1;
my_loop: LOOP
INSERT INTO departments (department_id, department_name)
VALUES (i, CONCAT('Department ', i));
SET i = i + 1;
IF i > 10 THEN
LEAVE my_loop;
END IF;
END LOOP my_loop;
END //
DELIMITER ;
```
## Experiment 16: Procedures
```sql
DELIMITER //
CREATE PROCEDURE add_student(
IN p_first_name VARCHAR(50),
IN p_last_name VARCHAR(50),
IN p_age INT,
IN p_email VARCHAR(100)
BEGIN
INSERT INTO students (first_name, last_name, age, email)
VALUES (p_first_name, p_last_name, p_age, p_email);
SELECT LAST_INSERT_ID() AS new_student_id;
END //
DELIMITER ;
-- Call procedure
CALL add_student('Michael', 'Wilson', 21, '[email protected]');
```
## Experiment 17: Functions
```sql
DELIMITER //
CREATE FUNCTION calculate_grade(score INT)
RETURNS VARCHAR(2)
DETERMINISTIC
BEGIN
DECLARE grade VARCHAR(2);
IF score >= 90 THEN SET grade = 'A';
ELSEIF score >= 80 THEN SET grade = 'B';
ELSEIF score >= 70 THEN SET grade = 'C';
ELSEIF score >= 60 THEN SET grade = 'D';
ELSE SET grade = 'F';
END IF;
RETURN grade;
END //
DELIMITER ;
-- Use function
SELECT student_id, calculate_grade(test_score) AS grade FROM test_results;
```
## Experiment 18: Cursors
```sql
DELIMITER //
CREATE PROCEDURE update_all_ages()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE s_id INT;
DECLARE s_age INT;
DECLARE cur CURSOR FOR SELECT student_id, age FROM students;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
OPEN cur;
read_loop: LOOP
FETCH cur INTO s_id, s_age;
IF done THEN
LEAVE read_loop;
END IF;
UPDATE students SET age = s_age + 1 WHERE student_id = s_id;
END LOOP;
CLOSE cur;
END //
DELIMITER ;
```
## Experiment 19: Triggers
```sql
-- Before insert trigger
DELIMITER //
CREATE TRIGGER before_student_insert
BEFORE INSERT ON students
FOR EACH ROW
BEGIN
IF NEW.age < 18 THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'Student must be at least 18 years old';
END IF;
END //
DELIMITER ;
-- Audit trail trigger
CREATE TABLE student_audit (
audit_id INT AUTO_INCREMENT PRIMARY KEY,
student_id INT,
action VARCHAR(10),
changed_on DATETIME DEFAULT CURRENT_TIMESTAMP
);
DELIMITER //
CREATE TRIGGER after_student_update
AFTER UPDATE ON students
FOR EACH ROW
BEGIN
INSERT INTO student_audit (student_id, action)
VALUES (NEW.student_id, 'UPDATE');
END //
DELIMITER ;
```
## Experiment 20: MySQL String Functions (1)
```sql
-- REPLACE
SELECT REPLACE(first_name, 'o', '0') AS modified_name FROM students;
-- REPEAT
SELECT CONCAT(first_name, REPEAT('*', 3)) AS name_with_stars FROM students;
-- REVERSE
SELECT REVERSE(last_name) AS reversed_name FROM students;
-- LEFT and RIGHT
SELECT
LEFT(first_name, 1) AS first_initial,
RIGHT(last_name, 2) AS last_two_chars
FROM students;
-- LPAD and RPAD
SELECT
LPAD(student_id, 5, '0') AS padded_id,
RPAD(first_name, 10, '.') AS padded_name
FROM students;
```
## Experiment 21: MySQL String Functions (2)
```sql
-- SPACE
SELECT CONCAT(first_name, SPACE(1), last_name) AS full_name FROM students;
-- SUBSTR
SELECT SUBSTR(email, 1, 5) AS email_start FROM students;
-- UPPER and LOWER
SELECT
UPPER(first_name) AS upper_name,
LOWER(last_name) AS lower_name
FROM students;
-- TRIM
SELECT TRIM(' Hello ') AS trimmed_string;
-- LENGTH
SELECT first_name, LENGTH(first_name) AS name_length FROM students;
```
## Experiment 22: Database Connectivity Using PHP and MySQL
```php
<?php
// Database connection
$servername = "localhost";
$username = "username";
$password = "password";
$dbname = "student_management";
// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);
// Check connection
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
// Insert data
$sql = "INSERT INTO students (first_name, last_name, age) VALUES ('John', 'Doe', 20)";
if ($conn->query($sql) {
echo "New record created successfully";
} else {
echo "Error: " . $sql . "<br>" . $conn->error;
// Select data
$sql = "SELECT student_id, first_name, last_name FROM students";
$result = $conn->query($sql);
if ($result->num_rows > 0) {
while($row = $result->fetch_assoc()) {
echo "ID: " . $row["student_id"]. " - Name: " . $row["first_name"]. " " . $row["last_name"]. "<br>";
} else {
echo "0 results";
$conn->close();
?>
```
## Experiment 23: Train Ticket Reservation System
```sql
-- Database schema for train ticket reservation
CREATE TABLE trains (
train_id INT PRIMARY KEY,
train_name VARCHAR(100) NOT NULL,
source_station VARCHAR(50) NOT NULL,
destination_station VARCHAR(50) NOT NULL,
departure_time TIME,
arrival_time TIME
);
CREATE TABLE passengers (
passenger_id INT PRIMARY KEY AUTO_INCREMENT,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
age INT,
social_media_id VARCHAR(100) UNIQUE
);
CREATE TABLE bookings (
booking_id INT PRIMARY KEY AUTO_INCREMENT,
train_id INT,
passenger_id INT,
booking_date DATETIME DEFAULT CURRENT_TIMESTAMP,
seat_number VARCHAR(10),
status ENUM('confirmed', 'waiting', 'cancelled') DEFAULT 'confirmed',
FOREIGN KEY (train_id) REFERENCES trains(train_id),
FOREIGN KEY (passenger_id) REFERENCES passengers(passenger_id)
);
-- Query to find available trains
SELECT t.* FROM trains t
WHERE t.source_station = 'Mumbai'
AND t.destination_station = 'Delhi'
AND NOT EXISTS (
SELECT 1 FROM bookings b
WHERE b.train_id = t.train_id
AND b.status = 'confirmed'
GROUP BY b.train_id
HAVING COUNT(*) >= 200 -- assuming train capacity is 200
);
-- Book ticket through social media
INSERT INTO passengers (first_name, last_name, age, social_media_id)
VALUES ('Alice', 'Johnson', 25, 'twitter:alicej');
INSERT INTO bookings (train_id, passenger_id, seat_number)
VALUES (102, LAST_INSERT_ID(), 'A12');
```
## Experiment 24: College Admission Form
```sql
-- Database schema for college admission
CREATE TABLE programs (
program_id INT PRIMARY KEY,
program_name VARCHAR(100) NOT NULL,
duration_years INT,
total_seats INT
);
CREATE TABLE applicants (
applicant_id INT PRIMARY KEY AUTO_INCREMENT,
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
dob DATE,
gender ENUM('Male', 'Female', 'Other'),
address TEXT,
phone VARCHAR(15),
email VARCHAR(100) UNIQUE,
high_school_percentage DECIMAL(5,2)
);
CREATE TABLE applications (
application_id INT PRIMARY KEY AUTO_INCREMENT,
applicant_id INT,
program_id INT,
application_date DATETIME DEFAULT CURRENT_TIMESTAMP,
status ENUM('submitted', 'under_review', 'accepted', 'rejected') DEFAULT 'submitted',
FOREIGN KEY (applicant_id) REFERENCES applicants(applicant_id),
FOREIGN KEY (program_id) REFERENCES programs(program_id)
);
-- Submit new application
INSERT INTO applicants (first_name, last_name, dob, high_school_percentage)
VALUES ('Rahul', 'Sharma', '2000-05-15', 85.5);
INSERT INTO applications (applicant_id, program_id)
VALUES (LAST_INSERT_ID(), 101);
-- Query to check available programs with seats
SELECT p.*,
(p.total_seats - IFNULL(a.app_count, 0)) AS available_seats
FROM programs p
LEFT JOIN (
SELECT program_id, COUNT(*) AS app_count
FROM applications
WHERE status = 'accepted'
GROUP BY program_id
) a ON p.program_id = a.program_id
WHERE (p.total_seats - IFNULL(a.app_count, 0)) > 0;
```
## Experiment 25: QR Enabled Bus Ticket Booking System
```sql
-- Database schema for bus ticket booking
CREATE TABLE buses (
bus_id INT PRIMARY KEY,
bus_number VARCHAR(20) NOT NULL,
operator VARCHAR(100),
source_city VARCHAR(50) NOT NULL,
destination_city VARCHAR(50) NOT NULL,
departure_time DATETIME,
arrival_time DATETIME,
total_seats INT
);
CREATE TABLE passengers (
passenger_id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
phone VARCHAR(15),
email VARCHAR(100)
);
CREATE TABLE tickets (
ticket_id INT PRIMARY KEY AUTO_INCREMENT,
bus_id INT,
passenger_id INT,
seat_number VARCHAR(10),
booking_time DATETIME DEFAULT CURRENT_TIMESTAMP,
qr_code VARCHAR(255) UNIQUE,
status ENUM('booked', 'cancelled', 'used') DEFAULT 'booked',
FOREIGN KEY (bus_id) REFERENCES buses(bus_id),
FOREIGN KEY (passenger_id) REFERENCES passengers(passenger_id)
);
-- Book a ticket and generate QR code
INSERT INTO passengers (name, phone)
VALUES ('Priya Patel', '9876543210');
INSERT INTO tickets (bus_id, passenger_id, seat_number, qr_code)
VALUES (
205,
LAST_INSERT_ID(),
'B12',
CONCAT('BUS205-', LAST_INSERT_ID(), '-', FLOOR(RAND() * 1000000))
);
-- Verify ticket using QR code
SELECT t.ticket_id, b.bus_number, p.name, t.seat_number
FROM tickets t
JOIN buses b ON t.bus_id = b.bus_id
JOIN passengers p ON t.passenger_id = p.passenger_id
WHERE t.qr_code = 'BUS205-1-123456'
AND t.status = 'booked';
-- Update ticket status when scanned
UPDATE tickets
SET status = 'used'
WHERE qr_code = 'BUS205-1-123456';
```
This document provides a complete practical record for all 25 database experiments. Each section
includes relevant SQL queries with explanations that demonstrate the concepts covered in each
experiment.
