## 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 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,

);

```

## Experiment 3: DML Commands using INSERT, SELECT

```sql

-- Insert single record

INSERT INTO students (first_name, last_name, age, email)

VALUES ('John', 'Doe', 20, '[email protected]');

-- Insert multiple records

INSERT INTO students (first_name, last_name, age, email)

VALUES

('Jane', 'Smith', 21, '[email protected]'),

('Robert', 'Johnson', 22, '[email protected]');

-- 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

-- 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

-- 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

-- 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

-- 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;

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

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 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';

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 //

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)

-- 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)

-- 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

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);

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.