Experiment 1: Introduction to MySQL

Theory:

What is MySQL?

MySQL is an open-source Relational Database Management System (RDBMS) that is widely

used for managing structured data. It is based on Structured Query Language (SQL) and is known
for its reliability, performance, and ease of use. MySQL is commonly used in web applications,
business software, and enterprise applications where efficient data management is required.

Key Features of MySQL:

 Open-Source: Free to use and supported by a large developer community.

 Scalability: Can handle small to large databases efficiently.
 Cross-Platform Compatibility: Works on Windows, Linux, and macOS.
 Data Security: Provides user authentication and access control.
 ACID Compliance: Ensures reliable transactions using Atomicity, Consistency, Isolation,
and Durability (ACID) principles.
 Indexing: Uses indexes to improve query performance.

Understanding Databases in MySQL

A database is an organized collection of structured data stored electronically. MySQL allows the
creation and management of multiple databases. Each database contains tables, which store related
data in rows and columns.

Basic MySQL Architecture:

1. Databases → Collections of structured data.

2. Tables → Organized collections of related data.
3. Rows (Records) → Individual entries in a table.
4. Columns (Fields) → Attributes of each record.
5. Constraints → Rules that ensure data integrity (e.g., Primary Key, Foreign Key, Unique).
Basic Commands in MySQL

1. Checking MySQL Version

To verify the installed MySQL version, use:

SELECT VERSION();

2. Viewing Available Databases

List all databases present in the MySQL server:

SHOW DATABASES;

3. Creating a Database

A new database is created using:

CREATE DATABASE college_db;

4. Selecting a Database

To work with a database, we need to select it:

USE college_db;

5. Creating a Table

A table stores structured data inside a database. The following query creates a students table in
college_db:

CREATE TABLE students (student_id INT PRIMARY KEY,name VARCHAR(50),age

INT,course_id INT,email VARCHAR(100));
Explanation:

 student_id is the Primary Key, ensuring unique student identification.

 name stores the student's full name.
 age represents the student's age.
 course_id links to a specific course (Foreign Key in a future table).
 email stores the student’s contact email.
6. Viewing Tables in a Database

To check the available tables:

SHOW TABLES;

7. Checking Table Structure

To display the structure of a table:

DESCRIBE students;

8. Inserting Data into a Table

To add records to the students table:

INSERT INTO students (student_id, name, age, course_id,

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

9. Retrieving Data from a

Table To view all student records:

SELECT * FROM students;

10. Updating Data in a Table

To modify an existing record:

UPDATE students
SET age = 21
WHERE student_id = 1;

11. Deleting Data from a

Table To remove a specific

record: DELETE FROM students

WHERE student_id = 1;
12. Dropping a Table (Deleting the Table Structure)

DROP TABLE students;

13. Dropping a Database (Deleting the Entire Database)

DROP DATABASE college_db;

Common MySQL Data Types

Data Type Description Example Values
INT Integer (whole number) 1, 2, 3, 100
VARCHAR(n) Variable-length text "John", "Alice"
CHAR(n) Fixed-length text "A", "B", "Yes"
TEXT Large text field "This is a long paragraph."
DATE Stores a date '2024-01-01'
DATETIME Stores date and time '2024-01-01 10:30:00'
DECIMAL(m,d) Stores decimal numbers 99.99, 450.25

Advantages of Using MySQL

1. High Performance: MySQL is optimized for read and write operations.
2. Scalability: Supports small to enterprise-level databases.
3. Security: MySQL offers authentication and encryption.
4. Reliability: ACID-compliant transactions prevent data corruption.
5. Replication: Supports database replication for backup and high availability.
6. Ease of Use: Simple syntax and a large developer community.

Conclusion:
This experiment introduced the basics of MySQL, including database creation, table management,
data manipulation, and basic commands. Understanding these concepts is essential for managing
relational databases efficiently.
Experiment 2: Data Definition Language (DDL)
Commands
Objective: To understand DDL Commands.

Theory: DDL (Data Definition Language) consists of SQL commands used to define, modify, and
delete database structures such as tables, indexes, and schemas. It does not deal with the
manipulation of data but rather with the structure of database objects.

1. CREATE Command

The CREATE command is used to define new database objects such as databases, tables,
indexes, and views.

Creating a Database:

CREATE DATABASE college_db;

This command creates a new database named college_db.

Using the Database:

USE college_db;

This command selects college_db as the active database for executing further operations.

Creating a Table:

CREATE TABLE students (student_id INT PRIMARY KEY,name VARCHAR(50) NOT NULL,age
INT CHECK (age > 17),course_id INT,email VARCHAR(100) UNIQUE);

Creates a students table with constraints such as PRIMARY KEY, NOT NULL, CHECK, and
UNIQUE.

2. ALTER Command

The ALTER command is used to modify the structure of an existing database object, such as
adding or deleting columns in a table.
Adding a Column:

ALTER TABLE students ADD COLUMN phone_number VARCHAR(15);

Adds a new column phone_number to the students table.

Modifying a Column Data Type:

ALTER TABLE students MODIFY COLUMN age SMALLINT;

Changes the data type of the age column from INT to SMALLINT.

Renaming a Column:

ALTER TABLE students CHANGE COLUMN phone_number contact_number VARCHAR(15);

Renames phone_number to contact_number.

Dropping a Column:

ALTER TABLE students DROP COLUMN

contact_number; Removes the contact_number column from

the students table.

3. DROP Command

The DROP command is used to delete an entire database, table, or other database object
permanently.

Dropping a Table:

DROP TABLE students;

Deletes the students table and all its data.

Dropping a Database:

DROP DATABASE college_db;

Deletes the entire college_db database and all its tables.

4. TRUNCATE Command

The TRUNCATE command is used to delete all records from a table without removing the
structure of the table.

It is faster than DELETE because it does not log individual row deletions.

Truncating a Table:

TRUNCATE TABLE students;

Removes all records from the students table but keeps the table structure intact.

5. RENAME Command

The RENAME command is used to rename a database or table.

Renaming a Table:

RENAME TABLE students TO student_records;

Changes the table name from students to

student_records.

Conclusion

DDL commands help in defining and managing database structures effectively. They ensure proper
schema organization, facilitate modifications, and provide control over database objects. Unlike
DML commands, DDL commands primarily focus on structure rather than data manipulation.

Practice Questions:
Q1. Write an SQL query to create an employees table with the following columns:

employee_id (Primary Key), name (VARCHAR of length 50, Not Null), age (INTEGER, /* with a
CHECK constraint that age should be greater than 18*/), department_id (INTEGER, Foreign Key
referencing departments table), email (VARCHAR of length 100, Unique), salary (DECIMAL(10,2),
should not be NULL)
Q2. Write an SQL query to add a new column phone_number (VARCHAR 15) to the
employees table.

Q3. Write an SQL query to modify the phone_number column to make it NOT NULL.

Q4. Write an SQL query to rename the employees table to company_employees.

Q5. Write an SQL query to remove the phone_number column from the employees

table. Q6. Write an SQL query to create an index on the email column of the employees

table. Q7. Write an SQL query to delete the employees table completely from the

database.

Q8. Write an SQL query to remove all records from the employees table without deleting the
structure.

Q9. Write an SQL query to create a departments table with a default_budget column that has a
default value of 50000.

Q10. Write an SQL query to create a payroll table with the following constraints:

payroll_id as Primary Key, employee_id as Foreign Key referencing employees, pay_date should
not be NULL, payment_status should only allow values 'Pending', 'Completed', 'Failed'
Experiment 3: Data Manipulation Language (DML)
Objective: To understand DML Commands.

Theory:

DML commands are used to manage data stored in database tables. They allow users to insert,
update, delete, and retrieve data.

The WHERE clause is used in SQL to filter records that meet specific conditions. It is primarily
used with SELECT, UPDATE, DELETE, and other SQL statements to restrict the number of rows
affected by a query.

Operators Used in the WHERE Clause in MySQL

Operator Description Example Query (Using students Table)
= Equal SELECT * FROM students WHERE age = 20;
> Greater than SELECT * FROM students WHERE age > 18;
< Less than SELECT * FROM students WHERE age < 25;
>= Greater than or equal SELECT * FROM students WHERE age >= 20;
<= Less than or equal SELECT * FROM students WHERE age <= 22;
<> or != Not equal SELECT * FROM students WHERE course_id <> 101;
BETWEEN Between a certain SELECT * FROM students WHERE age BETWEEN 18
range AND 25;
LIKE Search for a pattern SELECT * FROM students WHERE name LIKE 'A%';
(Finds names starting with 'A')
IN Specify multiple SELECT * FROM students WHERE course_id IN (101,
values 102, 103);

1. Inserting Data (INSERT)

The INSERT statement is used to add new rows to a table.

INSERT INTO students (student_id, name, age, course_id,

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

Inserting Multiple Rows at Once

INSERT INTO students (student_id, name, age, course_id,
email) VALUES
(2, 'Alice', 22, 102, '[email protected]'),
(3, 'David', 21, 103, '[email protected]'),
(4, 'Sophia', 19, 101, '[email protected]');

Inserting Data Without Specifying All Columns

If some columns have default values or allow NULL, you can insert partial

data. INSERT INTO students (student_id, name, course_id)

VALUES (5, 'Emma', 102);

Explanation: Here, age and email are not provided, so they will either be NULL or take default
values.

2. Retrieving Data (SELECT)

The SELECT statement is used to retrieve data from a table.

Selecting All Columns

SELECT * FROM students;

Selecting Specific Columns

SELECT name, age FROM students;

Using WHERE to Filter Records

SELECT * FROM students WHERE course_id = 101;

Explanation: Fetches only students enrolled in course 101.

Using ORDER BY to Sort Data

SELECT * FROM students ORDER BY age DESC;

Explanation: Retrieves all students sorted by age in descending order.

Using LIMIT to Retrieve a Fixed Number of Records

SELECT * FROM students LIMIT 2;

Explanation: Fetches only the first 2 rows.

Using DISTINCT to Remove Duplicates

SELECT DISTINCT course_id FROM students;

Explanation: Lists all unique course IDs in the students table.

3. Updating Data (UPDATE)

The UPDATE statement is used to modify existing records in a table.

Updating a Single Column

UPDATE students SET age = 21 WHERE student_id = 1;

Updating Multiple Columns

UPDATE students
SET age = 23, email = '[email protected]'
WHERE student_id = 2;

Using Conditions to Update Multiple Rows

UPDATE students
SET course_id =
105
WHERE course_id = 101;

Explanation: Updates all students enrolled in course 101 to 105.

Increasing Age for All Students by 1

UPDATE students
SET age = age + 1;

Explanation: Increments the age of all students by 1.

4. Deleting Data (DELETE)

The DELETE statement removes existing rows from a table.

Deleting a Specific Student

DELETE FROM students WHERE student_id = 1;

Deleting All Students from a Specific Course

DELETE FROM students WHERE course_id = 102;

Deleting All Rows from the Table (But Keeping Table Structure)
DELETE FROM students;

Explanation: Deletes all student records, but the table remains.

Completely Removing All Data and Resetting Auto-Increment

TRUNCATE TABLE students;

Explanation: This removes all records and resets any auto-incrementing columns.

5. Additional DML Queries

Using LIKE for Pattern Matching

SELECT * FROM students WHERE name LIKE 'J%';

Explanation: Fetches all students whose names start with 'J'.

Using ORDER BY Clause

The ORDER BY clause is used to sort the result set in ascending (ASC) or descending (DESC)
order based on one or more columns.

SELECT * FROM students ORDER BY age DESC;

Explanation: Retrieves all students sorted by age in descending order.

Using IN for Multiple Conditions
SELECT * FROM students WHERE course_id IN (101, 103, 105);

Explanation: Retrieves students enrolled in any of these courses.

Using BETWEEN for Age Range

SELECT * FROM students WHERE age BETWEEN 20 AND 22;

Explanation: Retrieves students whose ages are between 20 and 22.

Using GROUP BY to Count Students in Each Course

SELECT course_id, COUNT(*) AS total_students
FROM students
GROUP BY course_id;

Explanation: Groups students by course and counts how many are in each course.

Using HAVING to Filter Groups

SELECT course_id, COUNT(*) AS total_students
FROM students
GROUP BY course_id
HAVING COUNT(*) >
2;

Explanation: Displays only courses with more than 2 students.

Conclusion: DML commands allow efficient manipulation of data within tables, enabling dynamic
data handling.

Practice Questions:

1. Insert a new employee into the employees table with the following details:
(Employee ID: 101, Name: Alice Age: 30, Department ID: 5, Email:
[email protected])
2. Retrieve all employee details from the employees table.
3. Update the age of the employee with employee_id = 101 to 32.
4. Delete the record of the employee with employee_id = 101.
5. Fetch the names and email addresses of employees who belong to department_id = 3.
6. Retrieve all employee details sorted by age in descending order.
7. Retrieve the top 5 youngest employees from the employees table.
8. Fetch details of employees working in department 2, 4, or 6.
9. Retrieve employees whose names start with "A".
10. Fetch details of employees whose age is between 25 and 40.
Experiment 5: To implement concept of Joins.
Objective: To implement concept of Joins.

Theory:

Subqueries and joins are essential SQL concepts used for retrieving data from multiple tables
based on related columns.
 Joins combine rows from two or more tables based on a related column, allowing
efficient data retrieval and analysis.
 SQL Operators like AND, OR, NOT, EXISTS, UNION, and SET operators enhance
query functionality and filtering capabilities.
Types of Joins:

1. INNER JOIN – Returns only matching rows from both tables.

2. LEFT JOIN (LEFT OUTER JOIN) – Returns all rows from the left table and matching
rows from the right table.
3. RIGHT JOIN (RIGHT OUTER JOIN) – Returns all rows from the right table and
matching rows from the left table.
4. FULL JOIN (FULL OUTER JOIN) – Returns all rows from both tables, with NULLs
for unmatched rows.
5. SELF JOIN – Joins a table to itself.
6. CROSS JOIN – Returns the Cartesian product of both tables.

Join Examples:

1. INNER JOIN – Retrieve student names and their enrolled courses:

SELECT students.name, courses.course_name

FROM students
INNER JOIN courses ON students.course_id = courses.course_id;

2. LEFT JOIN – Retrieve all students and their course names (if enrolled):

SELECT students.name, courses.course_name

FROM students
LEFT JOIN courses ON students.course_id = courses.course_id;

3. RIGHT JOIN – Retrieve all courses and the students enrolled in them:

SELECT students.name, courses.course_name

FROM students
RIGHT JOIN courses ON students.course_id = courses.course_id;

4. FULL JOIN – Retrieve all students and courses (including unmatched ones):

SELECT students.name, courses.course_name

FROM students
FULL OUTER JOIN courses ON students.course_id = courses.course_id;

5. SELF JOIN – Find students enrolled in the same course:

SELECT A.name AS Student1, B.name AS Student2,

A.course_id FROM students A
JOIN students B ON A.course_id = B.course_id AND A.student_id <> B.student_id;
Using AND, OR, and NOT Operators

1. Retrieve students enrolled in Computer Science or Mathematics:

SELECT * FROM students

WHERE course_id = (SELECT course_id FROM courses WHERE course_name = 'Computer
Science')
OR course_id = (SELECT course_id FROM courses WHERE course_name = 'Mathematics');

2. Retrieve students who are NOT in the 'Mathematics' course:

SELECT * FROM students

WHERE course_id NOT IN (SELECT course_id FROM courses WHERE course_name =
'Mathematics');

Using EXISTS Operator

1. Retrieve students who have enrolled in any course:

SELECT * FROM students WHERE EXISTS (SELECT 1 FROM courses WHERE

students.course_id = courses.course_id);

Using UNION Operator

The UNION operator combines the results of two SELECT queries, removing duplicates.

1. Retrieve all students and all instructors in a single list:

SELECT name FROM students UNION SELECT name FROM instructors;

Using SET Operators (UNION ALL, INTERSECT, MINUS)

1. UNION ALL – Retrieve all students and instructors (including duplicates):

SELECT name FROM students UNION ALL SELECT name FROM instructors;

2. INTERSECT – Retrieve names that exist in both students and instructors tables
(not supported in MySQL, alternative approach using INNER JOIN):
SELECT students.name FROM students
INNER JOIN instructors ON students.name = instructors.name;

3. MINUS (Not directly supported in MySQL, alternative approach using LEFT JOIN):

SELECT students.name FROM students

LEFT JOIN instructors ON students.name =
instructors.name WHERE instructors.name IS NULL;

Conclusion:
 Joins allow combining data across multiple tables efficiently.
 SQL operators like AND, OR, NOT, EXISTS, UNION, and SET Operators enhance
query performance and flexibility
Practice Questions:
1. Display employee names along with their department names by joining the
employees and departments tables.
2. Retrieve all employees along with their project names, ensuring that employees
without a project are also displayed.
3. Retrieve all projects along with the names of employees assigned to them, ensuring
that projects without employees are also included.
4. Retrieve a list of all employees and all projects, including those that do not have a
match in either table (simulate a FULL JOIN using UNION).
5. Retrieve employees who are assigned to at least one project using the EXISTS operator.
6. Retrieve a combined list of all employees and all clients without duplicates
using UNION.
7. Retrieve the names of employees who are also listed as clients using an INNER
JOIN (since MySQL does not support INTERSECT)

Experiment 7: Subqueries

Objective: To implement concept of Sub queries.

Theory:

Subqueries and joins are essential SQL concepts used for retrieving data from multiple tables
based on related columns.

 Subqueries (or nested queries) are queries within another SQL query. They return results
that are used by the main (outer) query.
.

Types of Subqueries:
 1. Single-row subqueries – Returns a single value.
2. Multi-row subqueries – Returns multiple values.
3. Correlated subqueries – The inner query depends on the outer query for each row.

Subquery Examples:

1. Finding students enrolled in 'Computer Science' course using a subquery:

SELECT * FROM students

WHERE course_id = (SELECT course_id FROM courses WHERE course_name = 'Computer

Science');

2. Fetch students whose age is greater than the average age:

SELECT * FROM students

WHERE age > (SELECT AVG(age) FROM students);

3. Retrieve students who have the same course as 'Alice':

SELECT * FROM students

WHERE course_id = (SELECT course_id FROM students WHERE name = 'Alice');

Conclusion:

 Subqueries help retrieve data conditionally from one or more tables.

Practice Questions:
1. Retrieve the names of employees who work in the same department as 'John' using
a subquery.
2. Find employees who earn more than the average salary of all employees.
3. Retrieve employees who have been assigned at least one project using a
correlated subquery.
4. Display employee names along with their department names by joining the
employees and departments tables.
5. Retrieve all employees along with their project names, ensuring that employees
without a project are also displayed.

Experiment 8: To implement concept of Index & Views.

Objective: To implement concept of Index & Views.

Theory:

A View is a virtual table that does not store data itself but presents data retrieved from one or more
underlying tables through a SELECT query. Views are used to simplify complex queries, enhance
security, and improve readability.

Key Advantages of Views:

1. Simplicity – Views allow users to interact with complex queries as if they were simple
tables.
2. Security – Views restrict access to specific columns or rows, hiding sensitive data
from unauthorized users.
3. Data Abstraction – The structure of the underlying tables can change without
affecting queries that use views.
4. Reusability – Views can be used repeatedly in queries without rewriting complex joins
or filters.

Creating and Managing Views in MySQL

1. Creating a Simple View

A view can be created using the CREATE VIEW statement. The following example creates a view
displaying student names, ages, and course details from the students table.
CREATE VIEW student_details AS
SELECT name, age, course_id FROM students;
 2. Accessing Data from a View

To retrieve data from a view, we use a SELECT statement just like we would for a normal table.
SELECT * FROM student_details;

3. Creating a View with a Join.

Views can be created using JOIN to combine data from multiple tables. The following query creates
a view showing student names along with their enrolled course names.
CREATE VIEW student_course_details AS
SELECT students.name, students.age, courses.course_name
FROM students
INNER JOIN courses ON students.course_id = courses.course_id;

4. Creating a View with a WHERE Clause

A view can include conditions to restrict data. The following query creates a view that includes only
students from the Computer Science course.

CREATE VIEW cs_students AS

SELECT name, age, course_id
FROM students
WHERE course_id = (SELECT course_id FROM courses WHERE course_name = 'Computer
Science');

5. Creating a View with Aggregated Data

A view can include aggregate functions like COUNT, SUM, AVG, etc. The following example
creates a view that displays the total number of students in each course.

CREATE VIEW course_student_count AS

SELECT courses.course_name, COUNT(students.student_id) AS total_students
FROM students
INNER JOIN courses ON students.course_id = courses.course_id
GROUP BY courses.course_name;

6. Updating Data Through a View

If a view is created from a single table without aggregate functions, it can be updated using an
UPDATE statement.

UPDATE student_details SET age = 21 WHERE name = 'John';

Note: If a view contains JOIN, GROUP BY, or DISTINCT, updating it directly might not be
allowed.

7. Deleting Data Through a View

Similarly, data can be deleted through a view if it is based on a single table.

DELETE FROM student_details WHERE name = 'Alice';

 8. Dropping a View

To delete a view, we use the DROP VIEW statement.

DROP VIEW student_details;

Conclusion:

 Views simplify complex queries by allowing users to access pre-defined query results
as tables.
 They enhance security by restricting direct access to certain columns or rows.
 Views are useful for creating reports and hiding complex joins from end-users.
 Updating or deleting data through views is possible, but not all views are updatable due
to their complexity.

Practice Questions:
1. Create a view to display employee name, age, and salary.
2. Create a view to display employee name and department name by joining
employees and departments tables.
3. Create a view to display employees who earn more than 55000.
4. Create a view that shows the total number of employees in each department.
5. Create a view that shows the average salary in each department.
6. Create a view that includes employees above the age of 30.
7. Create a view for employees working in the IT or Finance department using the
IN operator.
8. Create a view that excludes employees from the HR department using NOT IN.
9. Update the high_salary_employees view to change the salary of Alice to 65000.
Drop the view high_salary_employees

Experiment 9: To implement basics of PL/SQL.

 Objective: To implement basics of PL/SQL.

Theory: In this chapter, we will discuss the Basic Syntax of PL/SQL which is
a block-structured language; this means that the PL/SQL programs are
divided and written in logical blocks of code. Each block consists of three sub-
parts −
S.N
Sections & Description
o

Declarations
1 This section starts with the keyword DECLARE. It is an optional section and defines
all variables, cursors, subprograms, and other elements to be used in the program.

Executable Commands
This section is enclosed between the keywords BEGIN and END and it is a mandatory
2 section. It consists of the executable PL/SQL statements of the program. It should have
at least one executable line of code, which may be just a NULL command to
indicate that nothing should be executed.

Exception Handling
3 This section starts with the keyword EXCEPTION. This optional section
contains exception(s) that handle errors in the program.
Every PL/SQL statement ends with a semicolon (;). PL/SQL blocks can be
nested within other PL/SQL blocks using BEGIN and END. Following is the
basic structure of a PL/SQL block −
DECLARE
<declarations section>
BEGIN
<executable command(s)>
EXCEPTION
<exception handling>
END;

The 'Hello World' Example

DECLARE
message varchar2(20):= 'Hello, World!';
BEGIN
dbms_output.put_line(message);
END;
/
The end; line signals the end of the PL/SQL block. To run the code from the
SQL command line, you may need to type / at the beginning of the first blank
line after the last line of the code. When the above code is executed at the
SQL prompt, it produces the following result −
Hello World

Conclusion: PL/SQL procedure successfully completed.

A View is a virtual table that does not store data itself but presents data retrieved from one or more
underlying tables through a SELECT query. Views are used to simplify complex queries, enhance
security, and improve readability.