DHANALAKSHMI SRINIVASAN UNIVERSITY

SAMAYAPURAM, TRICHY - 621112

SCHOOL OF ENGINEERING AND

TECHNOLOGY

PRACTICAL RECORD

21IOTP1 DATABASE MANAGEMENT SYSTEMS LABORATORY

Name : ………………………………………………………..

Register No. : ………………………………………………………...

Semester : …………………………………………………….…...

Course : ……………………………………….

…………………
 DHANALAKSHMI SRINIVASAN
UNIVERSITY

SCHOOL OF ENGINEERING AND TECHNOLOGY

BONAFIDE CERTIFICATE

Name : ……………………………………………

Register No. : ……………………………………………

Department : ……………………………………………

Semester : ……………………………………………

Course Name : ……………………………………………

Course Code : ……………………………………………

Certified that this is a Bonafide Record of the Practical work done for the
above course in Laboratory during the period …..………………………..

Faculty in-charge Head of the Department

Submitted for the University Practical Examination held on

……………………………………………………………

Internal Examiner External Examiner

 CONTENTS
SL. DATE TITLE OF THE EXERCISE PAGE NO MARKS SIGNATURE
NO

Exp.No:1 CREATION OF A DATABASE AND WRITING SQL QUERIES

 Date: TO RETRIEVE INFORMATION FROM THE DATABASE

AIM

To study the database creation, Data definition commands, Data manipulation commands for
inserting, deleting ,updating and retrieving tables and Transaction Control statements from
the database.

DESCRIPTION
It is used to communicate with database. It is used to:

 Create an object
 Select an
object The commands used are:
 Create
 Select

Step 1: Connect to MySQL Server

You need to connect to your MySQL server using a MySQL client or a command-line
tool. For example, you can use the following command in the MySQL command-line client:

mysql -u your_username -p
You'll be prompted to enter your password.
Step 2: Create a Database
Once connected, you can create a new database using the CREATE DATABASE statement:

CREATING BASE TABLE

Description: To create a new table

Syntax:

CREATE TABLE <table_name> (column1 datatype , column2 datatype , ... );

Example:

SQL> CREATE TABLE employee (empno number(6),ename varchar2(20),job

varchar2(10),mgr number(4),deptno number(3),salary number(7,2));
DESCRIBING THE TABLE CREATED

Description: To view the table /shows the description of the table / format of the table
Syntax: Desc <table name>;

Example:

Desc employee:

RETRIEVE INFORMATION FROM THE DATABASE

SQL SELECT Statement

The most commonly used SQL command is SELECT statement. The SQL SELECT
statement is used to query or retrieve data from a table in the database. A query may retrieve
information from specified columns or from all of the columns in the table. To create a
simple SQL SELECT Statement, you must specify the column(s) name and the table name.
The whole query is called SQL SELECT Statement.

SELECT INFORMATION FROM TABLE

Syntax:

SELECT * FROM table name;

Example:
SELECT * FROM employee;

SELECT PARTICULAR COLUMNS FROM TABLE

SELECT column_list FROM table-name

 table-name is the name of the table from which the information is retrieved.
 column_list includes one or more columns from which data is retrieved.
 The code within the brackets is optional.

Example:
SELECT empno,ename FROM employee;

RESULT:
Thus the database was created and the SQL queries to retrieve information from the database
was executed successfully.
 Exp.No:2 PERFORMING INSERTION, DELETION, MODIFYING, ALTERING,
Date: UPDATING AND VIEWING RECORDS BASED ON CONDITION.

AIM:
To performing Insertion,Deletion,Modifying,Altering,Updating and Viewing records
based on condition.

SQL INSERT Statement

 The INSERT Statement is used to add new rows of data to a table

Inserting the data directly to a table. Syntax for SQL INSERT is:

INSERT INTO TABLE_NAME [ (col1, col2, col3,...colN)] VALUES (value1,

value2, value3,...valueN);

 col1, col2,...colN -- the names of the columns in the table into which you want
to insert data.

Inserting data to a table through a select statement.

Syntax for SQL INSERT is:
INSERT INTO table_name [(column1, column2, ... columnN)] SELECT
column1, column2, ...columnN FROM table_name [WHERE condition];

NOTE:

1) When adding a new row, you should ensure the datatype of the value and the
column matches

2) You follow the integrity constraints, if any, defined for the table.

SQL SELECT Statement

The most commonly used SQL command is SELECT statement. The SQL SELECT
statement is used to query or retrieve data from a table in the database. A query may retrieve
information from specified columns or from all of the columns in the table. To create a
simple SQL SELECT Statement, you must specify the column(s) name and the table name.
The whole query is called SQL SELECT Statement.

Syntax of SQL SELECT Statement:

SELECT column_list FROM table-name

[WHERE Clause]
[GROUP BY
clause]
 [HAVING clause]
[ORDER BY
clause];

 table-name is the name of the table from which the information is retrieved.
 column_list includes one or more columns from which data is retrieved.
 The code within the brackets is optional.

SQL UPDATE Statement

The UPDATE Statement is used to modify the existing rows in a table.

The Syntax for SQL UPDATE Command is:

UPDATE table_name
SET column_name1 = value1,
column_name2 = value2, ...
[WHERE condition]

 table_name - the table name which has to be updated.

 column_name1, column_name2.. - the columns that gets changed.
 value1, value2... - are the new values.

NOTE: In the Update statement, WHERE clause identifies the rows that get affected.
If you do not include the WHERE clause, column values for all the rows get affected.

SQL Delete Statement

The DELETE Statement is used to delete rows from a table.

The Syntax of a SQL DELETE statement is:

DELETE FROM table_name [WHERE condition];

 table_name -- the table name which has to be updated.

NOTE: The WHERE clause in the sql delete command is optional and it identifies the
rows in the column that gets deleted. If you do not include the WHERE clause all the rows in
the table is deleted, so be careful while writing a DELETE query without WHERE clause.

SQL TRUNCATE Statement

The SQL TRUNCATE command is used to delete all the rows from the table and free the
space containing the table.
Syntax to TRUNCATE a table:

TRUNCATE TABLE table_name;

For Example: To delete all the rows from employee table, the query would be like,

TRUNCATE TABLE employee;

Difference between DELETE and TRUNCATE Statements:

DELETE Statement: This command deletes only the rows from the table based on the
condition given in the where clause or deletes all the rows from the table if no condition is
specified. But it does not free the space containing the table.

TRUNCATE statement: This command is used to delete all the rows from the table and free
the space containing the table.

SQL DROP Statement:

The SQL DROP command is used to remove an object from the database. If you drop a table,
all the rows in the table is deleted and the table structure is removed from the database. Once
a table is dropped we cannot get it back, so be careful while using DROP command. When a
table is dropped all the references to the table will not be valid.

Syntax to drop a sql table structure:

DROP TABLE table_name;

Difference between DROP and TRUNCATE Statement:

If a table is dropped, all the relationships with other tables will no longer be valid, the
integrity constraints will be dropped, grant or access privileges on the table will also be
dropped, if want use the table again it has to be recreated with the integrity constraints, access
privileges and the relationships with other tables should be established again. But, if a table is
truncated, the table structure remains the same, therefore any of the above problems will not
exist.

MODIFYING THE TABLE AND COLUMN DEFINITION

1) Adding a column

SQL> ALTER TABLE employee ADD dob date

2) Deleting the column

SQL> ALTER TABLE employee DROP COLUMN MGR ;

3) Modifying the column

SQL> ALTER TABLE employee MODIFY job varchar2(20);

PROGRAM:

mysql> desc customers;

+ + + + + + +
| Field | Type | Null | Key | Default | Extra |
+ + + + + + +
| CustID | int(11) | YES | | NULL | |
| CustName | varchar(255) | YES | | NULL | |
| Phonenumber | int(20) | YES | | NULL | |
| Address | varchar(255) | YES | | NULL | |
| city | varchar(255) | YES | | NULL | |
| country | varchar(255) | YES | | NULL | |
+ + + + + + +6
rows in set (0.01 sec)

mysql> insert into customers ( CustID,CustName,

Phonenumber,Address,City,Country) values (111,'aaa',1234567890,'h
street','dgl','india');
Query OK, 1 row affected (0.00 sec)

mysql> insert into customers ( CustID,CustName,

Phonenumber,Address,City,Country) values (222,'bbb',1234567891,'a
street','karur','india');
Query OK, 1 row affected (0.00 sec)

mysql> insert into customers ( CustID,CustName,

Phonenumber,Address,City,Country) values (333,'ccc',1234567892,'b
street','trichy','india');
Query OK, 1 row affected (0.00 sec)
mysql> insert into customers ( CustID,CustName,
Phonenumber,Address,City,Country) values (444,'ddd',1234567893,'c
street','tanjore','US');
Query OK, 1 row affected (0.00 sec)
mysql> insert into customers ( CustID,CustName,
Phonenumber,Address,City,Country) values (555,'eee',1234567894,'c
street','newyork','US');
Query OK, 1 row affected (0.00 sec)

mysql> insert into customers ( CustID,CustName,

Phonenumber,Address,City,Country) values (666,'fff',1234567895,'d street','san
francisco','US');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT CustName, City, Country FROM Customers;

+ + + +
| CustName | City | Country |
+ + + +
| aaa | dgl | india |
| bbb | karur | india |
| ccc | trichy | india |
| ddd | tanjore | US |
| eee | newyork | US |
| fff | san francisco | US |
+ + +
+ 6 rows in set (0.00
sec)

mysql> select * from customers;

+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 111 | aaa | 1234567890 | h street | dgl | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 333 | ccc | 1234567892 | b street | trichy | india |
| 444 | ddd | 1234567893 | c street | tanjore | US |
| 555 | eee | 1234567894 | c street | newyork | US |
| 666 | fff | 1234567895 | d street | san francisco | US |
+ + + + + +
+ 6 rows in set (0.00 sec)
mysql> SELECT Country FROM Customers;
+--------+
| Country |
+ +
| india |
| india |
| india |
| US |
| US |
| US |
+ +
6 rows in set (0.00 sec)

mysql> SELECT DISTINCT Country FROM Customers;

+ +
| Country |
+ +
| india |
| US |
+ +
2 rows in set (0.00 sec)

mysql> SELECT COUNT(DISTINCT Country) FROM Customers;

+ +
| COUNT(DISTINCT Country) |
+ +
| 2|
+

+ 1 row in set (0.00

sec)
mysql> select * from Customers where country = 'india';
+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 111 | aaa | 1234567890 | h street | dgl | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 333 | ccc | 1234567892 | b street | trichy | india |
+ + + + + +
+ 3 rows in set (0.00 sec)

mysql> SELECT * FROM Customers WHERE Country = 'Newyork' AND City =

'US';
Empty set (0.00 sec)

mysql> SELECT * FROM Customers WHERE Country = 'US' AND City =

'Newyork';
+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 555 | eee | 1234567894 | c street | newyork | US |
+ + + + + +
+ 1 row in set (0.00 sec)
mysql> SELECT * FROM Customers WHERE Country = 'india' OR City =
'trichy';
+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 111 | aaa | 1234567890 | h street | dgl | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 333 | ccc | 1234567892 | b street | trichy | india |
+ + + + + + +
3 rows in set (0.00 sec)

mysql> SELECT * FROM Customers WHERE NOT Country = 'india' AND NOT
Country = 'US';
Empty set (0.00 sec)
mysql> SELECT * FROM Customers WHERE NOT Country = 'US';
+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 111 | aaa | 1234567890 | h street | dgl | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 333 | ccc | 1234567892 | b street | trichy | india |
+ + + + + + +
3 rows in set (0.00 sec)

mysql> SELECT * FROM Customers ORDER BY City DESC;

+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 333 | ccc | 1234567892 | b street | trichy | india |
| 444 | ddd | 1234567893 | c street | tanjore | US |
| 666 | fff | 1234567895 | d street | san francisco | US |
| 555 | eee | 1234567894 | c street | newyork | US |
| 222 | bbb | 1234567891 | a street | karur | india |
| 111 | aaa | 1234567890 | h street | dgl | india |
+ + + + + + +
6 rows in set (0.00 sec)

mysql> SELECT * FROM Customers ORDER BY Country ASC, CustName DESC;

+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 333 | ccc | 1234567892 | b street | trichy | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 111 | aaa | 1234567890 | h street | dgl | india |
| 666 | fff | 1234567895 | d street | san francisco | US |
| 555 | eee | 1234567894 | c street | newyork | US |
| 444 | ddd | 1234567893 | c street | tanjore | US |
+ + + + + +
+ 6 rows in set (0.00 sec)

mysql> SELECT * FROM Customers ORDER BY CustName DESC;

+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 666 | fff | 1234567895 | d street | san francisco | US |
| 555 | eee | 1234567894 | c street | newyork | US |
| 444 | ddd | 1234567893 | c street | tanjore | US |
| 333 | ccc | 1234567892 | b street | trichy | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 111 | aaa | 1234567890 | h street | dgl | india |
+ + + + + +
+ 6 rows in set (0.00 sec)

mysql> SELECT CustomerName, CustID, Address FROM Customers WHERE

Address IS NOT NULL;
ERROR 1054 (42S22): Unknown column 'CustomerName' in 'field list'
mysql> SELECT CustName, CustID, Address FROM Customers WHERE Address
IS NOT NULL;
+ + + +
| CustName | CustID | Address |
+ + + +
| aaa | 111 | h street |
| bbb | 222 | a street |
| ccc | 333 | b street |
| ddd | 444 | c street |
| eee | 555 | c street |
| fff | 666 | d street |
+ + +
+ 6 rows in set
(0.00 sec)

mysql> UPDATE Customers SET CustName = 'ggg', City = 'Frankfurt' WHERE

CustID = 111;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from customers;

+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 111 | ggg | 1234567890 | h street | Frankfurt | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 333 | ccc | 1234567892 | b street | trichy | india |
| 444 | ddd | 1234567893 | c street | tanjore | US |
| 555 | eee | 1234567894 | c street | newyork | US |
| 666 | fff | 1234567895 | d street | san francisco | US |
+ + + + + +
+ 6 rows in set (0.00 sec)
mysql> DELETE FROM Customers WHERE City='tanjore';
Query OK, 1 row affected (0.00 sec)

mysql> select * from customers;

+ + + + + + +
| CustID | CustName | Phonenumber | Address | city | country |
+ + + + + + +
| 111 | ggg | 1234567890 | h street | Frankfurt | india |
| 222 | bbb | 1234567891 | a street | karur | india |
| 333 | ccc | 1234567892 | b street | trichy | india |
| 555 | eee | 1234567894 | c street | newyork | US |
| 666 | fff | 1234567895 | d street | san francisco | US |
+ + + + + +
+ 5 rows in set (0.00 sec)

mysql> ALTER TABLE customers ADD DateOfBirth date;

Query OK, 0 rows affected (0.13 sec)
Records: 0 Duplicates: 0 Warnings:
0

mysql> select * from customers;

+ + + + + + + +
| CustID | CustName | Phonenumber | Address | city | country | DateOfBirth |
+ + + + + + + +
| 111 | ggg | 1234567890 | h street | Frankfurt | india | NULL |
| 222 | bbb | 1234567891 | a street | karur | india | NULL |
| 333 | ccc | 1234567892 | b street | trichy | india | NULL |
| 555 | eee | 1234567894 | c street | newyork | US | NULL |
| 666 | fff | 1234567895 | d street | san francisco | US | NULL |
+ + + + + + +
+ 5 rows in set (0.00 sec)

mysql> ALTER TABLE customers MODIFY COLUMN DateOfBirth year;

Query OK, 5 rows affected (0.06
sec) Records: 5 Duplicates: 0
Warnings: 0 mysql> desc customers;
+ + + + + + +
| Field | Type | Null | Key | Default | Extra |
+ + + + + + +
| CustID | int(11) | YES | | NULL | |
| CustName | varchar(255) | YES | | NULL | |
| Phonenumber | int(20) | YES | | NULL | |
| Address | varchar(255) | YES | | NULL | |
| city | varchar(255) | YES | | NULL | |
| country | varchar(255) | YES | | NULL | |
| DateOfBirth | year(4) | YES | | NULL | |
+ + + + + +
+ 7 rows in set (0.00 sec)

mysql> UPDATE Customers SET DateOfBirth = '1994' WHERE CustID = 111;

Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> UPDATE Customers SET DateOfBirth = '1995' WHERE CustID = 222;

Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> UPDATE Customers SET DateOfBirth = '1996' WHERE CustID = 333;

Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> UPDATE Customers SET DateOfBirth = '1997' WHERE CustID = 444;

Query OK, 0 rows affected (0.00 sec)
Rows matched: 0 Changed: 0 Warnings: 0

mysql> UPDATE Customers SET DateOfBirth = '1998' WHERE CustID = 555;

Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> UPDATE Customers SET DateOfBirth = '1999' WHERE CustID = 666;

Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from customers;

+ + + + + + + +
| CustID | CustName | Phonenumber | Address | city | country | DateOfBirth |
+ + + + + + + +
| 111 | ggg | 1234567890 | h street | Frankfurt | india | 1994 |
| 222 | bbb | 1234567891 | a street | karur | india | 1995 |
| 333 | ccc | 1234567892 | b street | trichy | india | 1996 |
 | 555 | eee | 1234567894 | c street | newyork | US | 1998 |
| 666 | fff | 1234567895 | d street | san francisco | US | 1999 |
+ + + + + + +
+ 5 rows in set (0.00 sec)

RESULT:
Thus, the SQL queries to performing insertion, deletion, modifying, altering, updating and
viewing records based on condition were executed successfully.
 Exp.No:3 CREATION OF VIEWS, SYNONYMS, SEQUENCE, INDEXES,
Date: SAVE POINT

AIM:

To Study the Creation of Views, Synonyms, Sequence, Indexes and Save point.

VIEWS:

A view is the tailored presentation af data contained in one or more table and can also
be said as restricted view to the datas in the tables. A view is a “virtual table” or a “stored
query” which takes the output of a query and treats it as a table. The table upon which a view
is created is called as base table.

A view is a logical table based on a table or another view. A view contains no data of
its own but is like a window through which data from tables can be viewed or changed. The
tables on which a view is based are called base tables. The view is stored as a SELECT
statement in the data dictionary

Advantages of a view:
a. Additional level of table security.

b. Hides data complexity.

c. Simplifies the usage by combinig multiple tables into a single table.

d. Provides datas in different perspective.

Syntax:

Create [or replace ] view <view name> [column alis names] as <query> [with <options>
conditions];

Types of view:

1. Horizontal view: enforced by where cause

2. Vertical View: enforced by selecting the required columns

Here's an example of creating a simple view:

CREATE VIEW myview AS
SELECT column1, column2
 FROM mytable
WHERE condition;

mysql> CREATE VIEW Indian_Customers AS SELECT CustName, Phonenumber,city

FROM Customers WHERE Country = 'india';
Query OK, 0 rows affected (0.01 sec)

mysql> select * from Indian_customers;

+ + + +
| CustName | Phonenumber | city |
+ + + +
| ggg | 1234567890 | Frankfurt |
| bbb | 1234567891 | karur |
| ccc | 1234567892 | trichy |
+ + +
+ 3 rows in set (0.00
sec)
mysql> CREATE OR REPLACE VIEW Indian_Customers AS SELECT CustName,
Phonenumber, Address, CustID FROM Customers WHERE Country = 'india';
Query OK, 0 rows affected (0.01 sec)

mysql> select * from Indian_customers;

+ + + + +
| CustName | Phonenumber | Address | CustID |
+ + + + +
| ggg | 1234567890 | h street | 111 |
| bbb | 1234567891 | a street | 222 |
| ccc | 1234567892 | b street | 333 |
+ + + +
+ 3 rows in set (0.00 sec)
mysql> drop view indian_customers;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from Indian_customers;

ERROR 1146 (42S02): Table 'testdb.indian_customers' doesn't exist

INDEX

Indexes (or Keys) can be created on selected column(s) to facilitate fast search. Without
index, a "SELECT * FROM products WHERE productID=x" needs to match with
the productID column of all the records in the products table. If productID column is indexed
(e.g., using a binary tree), the matching can be greatly improved (via the binary tree search).
You should index columns which are frequently used in the WHERE clause; and
as JOIN columns.

The drawback about indexing is cost and space. Building and maintaining indexes require
computations and memory spaces. Indexes facilitate fast search but deplete the performance
on modifying the table (INSERT/UPDATE/DELETE), and need to be justified.

Nevertheless, relational databases are typically optimized for queries and retrievals, but NOT
for updates.
In MySQL, the keyword KEY is synonym to INDEX.
In MySQL, indexes can be built on:
1. a single column (column-index)
2. a set of columns (concatenated-index)
3. on unique-value column (UNIQUE INDEX or UNIQUE KEY)
4. on a prefix of a column for strings (VARCHAR or CHAR), e.g., first 5 characters.
There can be more than one indexes in a table. Index are automatically built on the
primary- key column(s).
You can build index via CREATE TABLE, CREATE INDEX or ALTER TABLE.

CREATE TABLE tableName (

......
[UNIQUE] INDEX|KEY indexName (columnName, ...),
-- The optional keyword UNIQUE ensures that all values in this column are distinct
-- KEY is synonym to INDEX
......
PRIMAY KEY (columnName, ...) -- Index automatically built on PRIMARY KEY column
);

CREATE [UNIQUE] INDEX indexName ON tableName(columnName, ...);

ALTER TABLE tableName ADD UNIQUE|INDEX|PRIMARY KEY indexName

(columnName, ...)

SHOW INDEX FROM tableName;

Example
mysql> CREATE TABLE employees (
emp_no INT UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(50) NOT NULL,
gender ENUM ('M','F') NOT NULL,
birth_date DATE NOT NULL,
hire_date DATE NOT NULL,
PRIMARY KEY (emp_no) -- Index built automatically on primary-key column
);
mysql> DESCRIBE employees;
+ + + + + + +
| Field | Type | Null | Key | Default | Extra |
+ + + + + + +
| emp_no | int(10) unsigned | NO | PRI | NULL | auto_increment |
| name | varchar(50) | NO | | NULL | |
| gender | enum('M','F') | NO | | NULL | |
| birth_date | date | NO | | NULL | |
| hire_date | date | NO | | NULL | |
+ + + + + + +

mysql> SHOW INDEX FROM employees \G

*************************** 1. row ***************************
Table: employees
Non_unique: 0
Key_name: PRIMARY
Seq_in_index: 1
Column_name: emp_no
.......

mysql> CREATE TABLE departments (

dept_no CHAR(4) NOT NULL,
dept_name VARCHAR(40) NOT NULL,
PRIMARY KEY (dept_no), -- Index built automatically on primary-key column
UNIQUE INDEX (dept_name) -- Build INDEX on this unique-value column
);

mysql> DESCRIBE departments;

+ + + + + + +
| Field | Type | Null | Key | Default | Extra |
+ + + + + + +
| dept_no | char(4) | NO | PRI | NULL | |
| dept_name | varchar(40) | NO | UNI | NULL | |
+ + + + + + +

mysql> SHOW INDEX FROM departments \G

*************************** 1. row ***************************
Table: departments
Non_unique: 0
Key_name: PRIMARY
Seq_in_index: 1
Column_name: dept_no
.......
*************************** 2. row ***************************
 Table: departments
Non_unique: 0
Key_name: dept_name
Seq_in_index: 1
Column_name: dept_name
.......

-- Many-to-many junction table between employees and

departments mysql> CREATE TABLE dept_emp (
emp_no INT UNSIGNED NOT NULL,
dept_no CHAR(4) NOT NULL,
from_date DATE NOT NULL,
to_date DATE NOT NULL,
INDEX (emp_no), -- Build INDEX on this non-unique-value column
INDEX (dept_no), -- Build INDEX on this non-unique-value column
FOREIGN KEY (emp_no) REFERENCES employees (emp_no)
ON DELETE CASCADE ON UPDATE CASCADE,
FOREIGN KEY (dept_no) REFERENCES departments (dept_no)
ON DELETE CASCADE ON UPDATE CASCADE,
PRIMARY KEY (emp_no, dept_no) -- Index built automatically
);

mysql> DESCRIBE dept_emp;

+ + + + + + +
| Field | Type | Null | Key | Default | Extra |
+ + + + + + +
| emp_no | int(10) unsigned | NO | PRI | NULL | |
| dept_no | char(4) | NO | PRI | NULL | |
| from_date | date | NO | | NULL | |
| to_date | date | NO | | NULL | |
+ + + + + + +

mysql> SHOW INDEX FROM dept_emp \G

*************************** 1. row ***************************
Table: dept_emp
Non_unique: 0
Key_name: PRIMARY
Seq_in_index: 1
Column_name: emp_no
........
*************************** 2. row ***************************
Table: dept_emp
Non_unique: 0
Key_name: PRIMARY
 Seq_in_index: 2
Column_name: dept_no
........
*************************** 3. row ***************************
Table: dept_emp
Non_unique: 1
Key_name: emp_no
Seq_in_index: 1
Column_name: emp_no
........
*************************** 4. row ***************************
Table: dept_emp
Non_unique: 1
Key_name: dept_no
Seq_in_index: 1
Column_name: dept_no
........

SEQUENCE
A sequence in MySQL is an arrangement of integers generated in the ascending order (1,
2, 3, and so on) on specific demand. Sequences are used in the databases to generate unique
numbers. Many applications require each row of a table to contain a distinct value, such as
student roll number in student_table, employee numbers in HR, customer ID in CRM, etc. To
fulfill this type of arrangement, we use sequences that provide an easy way to generate them.
MySQL does not provide any built-in function to create a sequence for a table's rows or
columns. But we can generate it via SQL query. In this article, we are going to describe how
to create a sequence in MySQL using SQL query.

Create Sequence Using AUTO_INCREMENT

The simplest way for creating a sequence in MySQL is by defining the column
as AUTO_INCREMENT during table creation, which should be a primary key column.

The following are the rules which should be considered when we use the
AUTO_INCREMENT attribute for the column:

o We can create only one AUTO_INCREMENT column in each table, and the data
type of this column is an integer.
o The AUTO_INCREMENT column should also have either PRIMARY or
UNIQUE KEY indexing.
o The AUTO_INCREMENT column must contain NOT NULL However, MySQL
automatically adds the NOT NULL constraint to the column implicitly when we
set the column as an AUTO_INCREMENT attribute.
 MySQL does not have a native sequence object like some other databases (e.g., Oracle).
Instead, you can use the AUTO_INCREMENT attribute for columns to achieve a
similar effect.
CREATE TABLE mytable (
id INT AUTO_INCREMENT PRIMARY KEY,
data VARCHAR(255)
);

Increment by
 Specify the interval between the sequence numbers.
 Value can be positive or negative but can’t be zero.
 If the value is POSITIVE it is INCREMENT SEQUENCE.
 If the value is NEGATIVE it is DECREMENT SEQUENCE.
 Default increment is 1.

Start with n
Specify the starting value of sequence.
Default value is 1.

Min value
Specify the min value of sequence.

No min value
Specify a minimum value of 1 for ascending sequence.
-1026 for descending sequence.

Max value
Specify the max value of sequence.
No max value
Specify the maximum value of 1027 for ascending sequence.
-1 for descending sequence.

Cycle
Specify the sequence will continue to generate value after reaching either maximum or
minimum value.

No cycle
Specify sequence can’t generate value after reaching max or min value. Default is
NO CYCLE.

Cache
Cache is a buffer.
 It specifies the No. of integer to keep in memory.
Default cache is 20.
Minimum cache is 2.

Order
This guarantees that sequence Numbers are generated in the order of request.

No order
This does not guarantee that sequence Numbers are generated in the order of request.

Alter is available in sequence.

The START WITH OPTION can’t be changed using ALTER SEQUENCE.
To change START WITH OPTION, drop the SEQUENCE and then recreate the sequence.

>ALTER sequence (seq_name)

[Increment by n
Max value n
Min value n
Cycle
Cache];

EXAMPLE:
mysql> CREATE TABLE Insects (
-> Id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> Name VARCHAR(30) NOT NULL,
-> Type VARCHAR(30) NOT NULL,
-> Origin VARCHAR(30) NOT NULL
-> );
ERROR 1046 (3D000): No database
selected mysql> show databases;
+-------------------+
| Database |
+-------------------+
| information_schema |
| employee |
| mysql |
| performance_schema |
| sakila |
| sys |
| testdb |
| world |
+-------------------+
8 rows in set (0.01 sec)

mysql> use sys;

Database changed
mysql> CREATE TABLE Insects (
-> Id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> Name VARCHAR(30) NOT NULL,
-> Type VARCHAR(30) NOT NULL,
-> Origin VARCHAR(30) NOT NULL
-> );
Query OK, 0 rows affected (0.04 sec)

mysql> INSERT INTO Insects (Name, Type, Origin) VALUES

-> ('Cockroach', 'Crawling', 'Kitchen'),
-> ('Mosquito', 'Flying', 'Driveway'),
-> ('Spider' ,'Crawling', 'Court yard'),
-> ('Grasshopper', 'Flying', 'Front
yard'); Query OK, 4 rows affected (0.01 sec)
Records: 4 Duplicates: 0 Warnings: 0

mysql> SELECT * FROM Insects;

+----+-------------+----------+------------+
| Id | Name | Type | Origin |
+----+-------------+----------+------------+
| 1 | Cockroach | Crawling | Kitchen |
| 2 | Mosquito | Flying | Driveway |
| 3 | Spider | Crawling | Court yard |
| 4 | Grasshopper | Flying | Front yard |
+----+-------------+----------+------------+
4 rows in set (0.00 sec)

mysql> INSERT INTO Insects (Id, Name, Type, Origin) VALUES

-> (6, 'Bee', 'Flying', 'Court yard'),
-> (7, 'Ant', 'Crawling', 'Front yard');
Query OK, 2 rows affected (0.00 sec)
Records: 2 Duplicates: 0 Warnings: 0

mysql> SELECT * FROM Insects;

+----+-------------+----------+------------+
| Id | Name | Type | Origin |
+----+-------------+----------+------------+
| 1 | Cockroach | Crawling | Kitchen |
| 2 | Mosquito | Flying | Driveway |
| 3 | Spider | Crawling | Court yard |
| 4 | Grasshopper | Flying | Front yard |
| 6 | Bee | Flying | Court yard |
| 7 | Ant | Crawling | Front yard |
+----+-------------+----------+------------+
6 rows in set (0.00 sec)

mysql> DELETE FROM Insects WHERE Id = 6;

Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO Insects (Name, Type, Origin) VALUES

-> ('Cricket', 'Crawling', 'Front yard');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM Insects;

+----+-------------+----------+------------+
| Id | Name | Type | Origin |
+----+-------------+----------+------------+
| 1 | Cockroach | Crawling | Kitchen |
| 2 | Mosquito | Flying | Driveway |
| 3 | Spider | Crawling | Court yard |
| 4 | Grasshopper | Flying | Front yard |
| 7 | Ant | Crawling | Front yard |
| 8 | Cricket | Crawling | Front yard |
+----+-------------+----------+------------+
6 rows in set (0.00 sec)

mysql> UPDATE Insects SET Name = 'Bee', Id = 2 WHERE Id = 3;

ERROR 1062 (23000): Duplicate entry '2' for key 'PRIMARY'
mysql> UPDATE Insects SET Name = 'Bee', Id = 5 WHERE Id = 3;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0

SYNONYM

 A synonym is an alternative name for objects such as tables, views, sequences, stored
procedures and other database objects.
 We can avoid the entry of SCHEMA.
 DML operation performed on synonym will affect the table.
 The main functionality of synonym is to access the database objects between different
schemas without using the schema names.
  In MySQL, there is no direct support for synonyms as it exists in some other database
systems like Oracle. However, you can achieve similar functionality using views or
by creating an alias for a table or a column.
Using Views:
You can create a view that selects data from a table and then use the view as if it were a synonym.
-- Create a view as a synonym
CREATE VIEW my_synonym AS
SELECT column1, column2
FROM my_table
WHERE condition;

-- Use the view

SELECT * FROM my_synonym;
Using Table or Column Aliases:
You can also use aliases for tables and columns to achieve a similar effect.

-- Create an alias for a table

CREATE TABLE my_alias AS SELECT * FROM my_table;

-- Use the alias

SELECT * FROM my_alias;

-- Create an alias for a column

SELECT column1 AS col_alias FROM my_table;

SAVEPOINTS
In MySQL, you can use savepoints within transactions to create points that you can roll back to if
needed. Savepoints are particularly useful when you want to perform partial rollbacks within
a transaction. Here's an example:

-- Start a transaction
START TRANSACTION;

-- Execute some SQL statements

INSERT INTO your_table (column1, column2) VALUES (value1, value2);

-- Create a savepoint
SAVEPOINT my_savepoint;

-- Execute more SQL statements

UPDATE your_table SET column1 = new_value WHERE condition;
-- Roll back to the savepoint if needed
ROLLBACK TO my_savepoint;

-- Continue with more SQL statements

-- Commit the transaction

COMMIT;

Explanation:
1. START TRANSACTION: Begins a new transaction.
2. SAVEPOINT my_savepoint: Creates a savepoint with the name
my_savepoint. This allows you to roll back to this point within the transaction.
3. ROLLBACK TO my_savepoint: Rolls back the transaction to the savepoint named
my_savepoint. This will undo changes made after the savepoint.
4. COMMIT: If everything is as expected and you want to make the
changes permanent, you can commit the transaction.

To use the COMMIT statement at the end of your transaction if you want to make the
changes permanent. If you encounter issues or want to discard the changes made after a
savepoint, you can use ROLLBACK TO my_savepoint.

RESULT:
Thus the SQL queries for Views, Synonyms, Sequence, Indexes and Save point. were
executed successfully.
 Exp.No:4 CREATING AN EMPLOYEE DATABASE TO SET VARIOUS
Date: CONSTRAINTS.

Aim:
To create an employee database to set various constraints.

Theory & Concepts:

SQL Constraints are the rules applied to a data columns or the complete table to limit the type
of data that can go into a table. When you try to perform any INSERT, UPDATE, or
DELETE operation on the table, RDBMS will check whether that data violates any existing
constraints and if there is any violation between the defined constraint and the data action, it
aborts the operation and returns an error.
We can define a column level or a table level constraints.

There are five different types of SQL

constraints. They are:

 Primary Key Constraint: this ensures all rows have a unique value
and cannot be NULL, often used as an identifier of a table’s row.
 Foreign Key Constraint: this ensures that values in a column (or
several columns) match values in another table’s column/s.
 Unique Constraint: this ensures all rows have a unique value.
 Not Null Constraint: this ensures a value cannot be NULL.
 Check Constraint: this ensures a value meets a specific condition.

We can create constraints on a table at the time of a table creation using the CREATE
TABLE statement, or after the table is created, we can use the ALTER TABLE statement to
create or delete table constraints.

CREATE TABLE table_name

( column1 datatype constraint,
column2 datatype constraint,
....
columnN datatype constraint
);
QUERIES:

mysql> CREATE TABLE IF NOT EXISTS Departments (

-> DepartmentID INT PRIMARY KEY,
-> DepartmentName VARCHAR(50) NOT NULL
-> );
Query OK, 0 rows affected (0.04 sec)

mysql> CREATE TABLE IF NOT EXISTS Employees (

-> EmployeeID INT PRIMARY KEY,
-> FirstName VARCHAR(50) NOT NULL,
-> LastName VARCHAR(50) NOT NULL,
-> DepartmentID INT,
-> Salary DECIMAL(10, 2),
-> CONSTRAINT fk_department
-> FOREIGN KEY (DepartmentID)
-> REFERENCES Departments(DepartmentID)
-> ON DELETE SET NULL
-> );
Query OK, 0 rows affected (0.07 sec)

mysql> INSERT INTO Departments (DepartmentID, DepartmentName) VALUES

-> (1, 'HR'),
-> (2, 'IT'),
-> (3, 'Finance');
Query OK, 3 rows affected (0.01 sec)
Records: 3 Duplicates: 0 Warnings: 0

mysql> INSERT INTO Employees (EmployeeID, FirstName, LastName, DepartmentID,

Salary) VALUES
-> (1, 'John', 'Doe', 1, 50000.00),
-> (2, 'Jane', 'Smith', 2, 60000.00),
-> (3, 'Bob', 'Johnson', 1, 55000.00);
Query OK, 3 rows affected (0.01 sec)
Records: 3 Duplicates: 0 Warnings:
0

mysql> ALTER TABLE Employees

-> ADD CONSTRAINT uc_employee_id UNIQUE (EmployeeID);
Query OK, 0 rows affected (0.03 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> ALTER TABLE Employees

-> ADD CONSTRAINT chk_salary CHECK (Salary >= 0);
Query OK, 0 rows affected (0.01 sec)
Records: 0 Duplicates: 0 Warnings:
0

RESULT:
Thus the employee database to set various constraints were created and executed
successfully.
 Exp.No:5
CREATING RELATIONSHIP BETWEEN THE DATABASES.
Date:

Aim:
To create the relationship between the databases.

Theory & Concepts:

In MySQL, databases do not directly have relationships with each other. Relationships are
established between tables within the same database using foreign key constraints. However,
if you want to establish a relationship between tables in different databases, you can fully
qualify the table names when defining foreign key constraints.

Here's an example:

-- Create the first database

CREATE DATABASE IF NOT EXISTS Database1;
USE Database1;

-- Create a table in Database1

CREATE TABLE IF NOT EXISTS Table1
( ID INT PRIMARY KEY,
Name VARCHAR(50)
);

-- Insert sample data into Table1

INSERT INTO Table1 (ID, Name) VALUES (1, 'Item1');

-- Create the second database

CREATE DATABASE IF NOT EXISTS Database2;
USE Database2;

-- Create a table in Database2

CREATE TABLE IF NOT EXISTS Table2
( ID INT PRIMARY KEY,
Description VARCHAR(50),
ReferenceID INT,
FOREIGN KEY (ReferenceID) REFERENCES Database1.Table1(ID)
);

-- Insert sample data into Table2

INSERT INTO Table2 (ID, Description, ReferenceID) VALUES (1, 'Description1', 1);
In this example:
 Two databases, Database1 and Database2, are created.
 Table1 is created in Database1 with a primary key.
 Table2 is created in Database2 with a foreign key (ReferenceID) that references
the primary key of Table1 in Database1. The reference is qualified with the
database name (Database1.Table1).
 Sample data is inserted into both tables.
When querying Table2, you would need to fully qualify the table name to reference Table1
from Database1.

RESULT:
Thus, the relationship between databases has been created.
 Exp.No:6
STUDY OF PL/SQL
Date:
Aim:
To study the basics of PL/SQL.

Theory & Concepts:

PL/SQL is the procedural extension to SQL with design features of programming

languages. Data manipulation and query statements of SQL are included within procedural
units of code.
Benefits of PL/SQL:

PL/SQL can improve the performance of an application. The benefits differ

depending on the execution environment:
 PL/SQL can be used to group SQL statements together within a single block and to
send the entire block to the server in a single call thereby reducing networking traffic.
Without PL/SQL, the SQL statements are sent to the Oracle server one at a time. Each SQL
statement results in another call to the Oracle server and higher performance overhead. In a
network environment, the overhead can become significant.
 PL/SQL can also operate with Oracle server application development tools such as
Oracle forms and Oracle reports.
PL/SQL Block Structure:
Every unit of PL/SQL comprises one or more blocks. These blocks can be entirely
separate or nested one within another. The basic units (procedures, functions, and anonymous
blocks) that make up a PL/SQL program are logical blocks which can contain any number of
nested sub-blocks. Therefore one block can represent a small part of another block, which in
turn can be part of the whole unit of code.
Identifiers/Variables:
In PL/SQL, you can use identifiers to do the following:
 Declare variables, cursors, constants and exceptions and then use them in SQL and
procedural statements.
 Declare variables belonging to scalar, reference, composite and large object (LOB)
data types.
 Declare variables dynamically based on the data structure of tables and columns in
the database.

PL/SQL Block Syntax:

DECLARE [Optional]
Variables, cursors, user defined exceptions
BEGIN [Mandatory]
- SQL Statements –
- PL/SQL Statements –
 Exception [Optional]
-- Actions to be performed when errors occur ----
END [Mandatory];
Anonymous, procedure and function blocks:
Anonymous:
- No name.
- Starts with DECLARE statement.
Procedure:
- No return.
- PROCEDURE name IS
Function:
- Returns a value
- FUNCTION name RETURN data-type IS
Programming Constructs:
Declaring Variables:
Identifier [CONSTANT] data-type [NOT NULL] [:= | DEFAULT expr];
Assignment:
Identifier := expr;
IF Statement:
IF condition THEN
Statements;
[ELSE IF condition
THEN
Statements;]
[ELSE
Statements;]
END IF;
CASE Statement:
CASE selector
WHEN expression1 THEN result1
WHEN expression2 THEN
result2
....
....
WHEN expression THEN resultn
[ELSE resultn1;]
END;
BASIC Loops:
LOOP
Statement 1;
....
....
EXIT [WHEN condition];
END LOOP;
WHILE Statement:
WHILE condition LOOP
Statement1;
....
....
END LOOP;
FOR Statement:
FOR counter IN [REVERSE]
Lower_bound..upper_bound LOOP
Statement1;
....
....
END LOOP;

RESULT:
Thus the fundamentals of PL/SQL were studied
 Exp.No:7 WRITE A PL/SQL BLOCK TO SATISFY SOME CONDITIONS
Date: BY ACCEPTING INPUT FROM THE USER

AIM:
To implement the PL/SQL block that satisfy some conditions by accepting input from
the user.

i.) Write a program in PL/SQL for addition of two numbers.

DELIMITER //

CREATE PROCEDURE calculate_sum(IN a INT, IN b INT)

BEGIN
DECLARE no1 INT;
DECLARE no2 INT;

SET no1 = a;
SET no2 =
b;

SELECT CONCAT('Sum:', (no1 + no2)) AS result;

END //

DELIMITER ;

-- Call the stored procedure with input values

CALL calculate_sum(10, 2);

Sum:12

PL/SQL procedure successfully completed.

ii.) Write a program in PL/SQL for addition of 1 to 100 numbers.

DELIMITER //

-- Drop the procedure if it already exists

DROP PROCEDURE IF EXISTS calculate_sum;

CREATE PROCEDURE calculate_sum()

BEGIN
DECLARE a INT;
DECLARE s1 INT DEFAULT 0;
 SET a = 1;

WHILE a <= 100 DO

SET s1 = s1 + a;
SET a = a + 1;
END WHILE;

SELECT CONCAT('Sum between 1 to 100 is ', s1) AS

result; END //

DELIMITER ;

-- Call the stored

procedure CALL
calculate_sum();

Sum between 1 to 100 is 5050

PL/SQL procedure successfully completed.

iii.) Write a program in PL/SQL for Reverse of a Number

DELIMITER //

CREATE PROCEDURE reverse_number(IN n INT)

BEGIN
DECLARE rev INT DEFAULT 0;
DECLARE r INT;

SET n = ABS(n); -- Handle negative numbers by taking the absolute value

WHILE n > 0 DO
SET r = n % 10;
SET rev = (rev * 10) + r;
SET n = TRUNCATE(n / 10);
END WHILE;

SELECT CONCAT('Reverse is ', rev) AS result;

END //

DELIMITER ;
-- Call the stored procedure with input values
CALL reverse_number(12345);
OUTPUT:
Enter value for n:
1235 old 8: n:=&n;
new 8: n:=1235;
reverse is 5321
PL/SQL procedure successfully completed.

RESULT:

Thus the PL/SQL programs were written and executed to accept the input from the
users.
 Exp.No:8 WRITE A PL/SQL BLOCK THAT HANDLES ALL TYPES OF
Date: EXCEPTIONS

Program with user defined exception:

DELIMITER //

CREATE PROCEDURE perform_division()

BEGIN
DECLARE a INT;
DECLARE b INT;
DECLARE c
FLOAT;

DECLARE divide_zero CONDITION FOR SQLSTATE '45000';

SET a = &a;
SET b =
&b;

DECLARE EXIT HANDLER FOR SQLEXCEPTION

BEGIN
SELECT 'Error: ' || SQLSTATE AS result;
END;

IF b = 0 THEN
SIGNAL divide_zero SET MESSAGE_TEXT = 'b could not be zero';
ELSE
SET c = a / b;
SELECT CONCAT('Division is ', c) AS result;
END IF;
END //

DELIMITER

-- Call the stored procedure with input values

CALL perform_division();

OUTPUT
b could not be zero.

For the customer relation Customers(ID, Name, Age Address, Salary). Write a PL/SQL
block to input customerid and display address and salary. Use exception to display “ No
such customer” when data not found.
DELIMITER //

CREATE PROCEDURE display_customer_info(IN cc_id INT)

BEGIN
DECLARE c_id INT;
DECLARE c_name VARCHAR(255);
DECLARE c_addr VARCHAR(255);

SET c_id = cc_id;

DECLARE ex_invalid_id CONDITION FOR SQLSTATE '45000';

DECLARE no_such_customer CONDITION FOR SQLSTATE '02000';

IF c_id <= 0 THEN

SIGNAL ex_invalid_id;
ELSE
BEGIN
SELECT name, address INTO c_name, c_addr
FROM customers
WHERE id = c_id;

SELECT CONCAT('Name: ', c_name) AS

result; SELECT CONCAT('Address: ', c_addr)
AS result; END;
END IF;

EXCEPTION
WHEN ex_invalid_id THEN
SELECT 'ID must be greater than zero!' AS
result; WHEN no_such_customer THEN
SELECT 'No such customer!' AS result;
WHEN OTHERS THEN
SELECT 'Error!' AS result;
END //

DELIMITER ;

-- Call the stored procedure with input values

CALL display_customer_info(1);
 OUTPUT
Enter the value of c_id:-50
ID must be greater than zero

RESULT
Hence, the PL/SQL block for handling all types of exceptions were executed
successfully.
 Exp.No:9
CREATION OF PROCEDURES
Date:

Aim :
To create stored procedures to encapsulate a series of SQL statements into a
reusable and callable routine

DELIMITER ;
Let's break down the syntax:
 DELIMITER //: This changes the statement delimiter to // temporarily. This
is necessary because the default delimiter is ;, and procedures contain
multiple SQL statements.
 CREATE PROCEDURE procedure_name: This declares the start of the
procedure definition, where procedure_name is the name you want to give
to your stored procedure.
 (parameter1 datatype, parameter2 datatype, ...): This is where you can define
input parameters for your stored procedure. Each parameter consists of a
name and a data type.
 BEGIN and END: These keywords enclose the body of the stored
procedure, where you can write one or more SQL statements.
 //: This is the custom delimiter that we set at the beginning. It marks the end
of the stored procedure definition.
 DELIMITER ;: This changes the statement delimiter back to the default
(;). Here's an example of a simple stored procedure that selects data from a table:
sqlCopy code
DELIMITER //
CREATE PROCEDURE GetEmployee(IN employee_id INT)
BEGIN
SELECT * FROM employees WHERE id = employee_id;
END //
DELIMITER ;
In this example, the GetEmployee stored procedure takes an employee_id as input and
selects all columns from the employees table where the id matches the provided
parameter.
To call the stored procedure, you can use the following syntax:
CALL GetEmployee(123);
Replace 123 with the actual employee ID you want to retrieve.

PROCEDURES – SYNTAX
create or replace procedure (argument {in,out,inout} datatype ) {is,as} variable declaration;
constant declaration;
begin
PL/SQL subprogram body;
exception
exception PL/SQL block; end;

CREATING THE TABLE ‘ITITEMS’ AND DISPLAYING THE CONTENTS

-- Create the ITItems table
CREATE TABLE IF NOT EXISTS ITItems (
ItemID INT PRIMARY KEY,
ItemName VARCHAR(255),
ItemType VARCHAR(50),
Quantity INT
);

-- Insert some sample data into ITItems

INSERT INTO ITItems (ItemID, ItemName, ItemType, Quantity) VALUES
(1, 'Laptop', 'Electronics', 10),
(2, 'Printer', 'Electronics', 5),
(3, 'Desk Chair', 'Furniture', 20);

-- Display the contents of the ITItems table

SELECT * FROM ITItems;

In this example:
1. A new database MyDatabase is created (if it doesn't already exist), and it is
selected for use.
2. A table named ITItems is created with columns ItemID, ItemName, ItemType, and
Quantity. The ItemID column is designated as the primary key.
3. Sample data is inserted into the ITItems table.
4. The SELECT * FROM ITItems; statement is used to display the contents of the
ITItems table.

RESULT:

Hence, the procedure for the sample database has been created for the tables.
 Exp.No:10
CREATION OF DATABASE TRIGGERS AND FUNCTIONS
Date:

Creating a Trigger:

Here's an example of creating a trigger that automatically updates a timestamp column

(last_updated) whenever a row in a table is updated:

-- Create a new database (if not exists)

CREATE DATABASE IF NOT EXISTS MyDatabase;
USE MyDatabase;

-- Create a table
CREATE TABLE IF NOT EXISTS MyTable (
ID INT PRIMARY KEY,
Data VARCHAR(255),
LastUpdated TIMESTAMP
);

-- Create a trigger
DELIMITER //
CREATE TRIGGER update_timestamp
BEFORE UPDATE ON MyTable
FOR EACH ROW
SET NEW.LastUpdated = NOW();
//
DELIMITER ;

In this example:
 A table named MyTable is created with columns ID, Data, and LastUpdated.
 The update_timestamp trigger is created. It fires before an update operation
on MyTable and sets the LastUpdated column to the current timestamp.

Creating a Function:
Here's an example of creating a simple function that calculates the square of a number:

-- Create a new database (if not exists)

CREATE DATABASE IF NOT EXISTS MyDatabase;
USE MyDatabase;

-- Create a function
DELIMITER //
CREATE FUNCTION CalculateSquare(input_number INT)
RETURNS INT
BEGIN
DECLARE result INT;
SET result = input_number * input_number;
RETURN result;
END //
DELIMITER ;

In this example:
 The CalculateSquare function is created. It takes an integer parameter input_number,
calculates the square, and returns the result.

RESULT:

Hence, the function and trigger for the sample database is created and executed successfully.