A

LAB MANUAL
OF
DATABASE MANAGEMENT SYSTEMS
II B.TECH II Semester

(HITS – R22)

Prepared By:

Mr. A . GOPI
Assistant Professor

DEPARTMENT OF CSE
(ARTIFICIAL INTELLIGENCE & MACHINE LEARNING)

HOLY MARY INSTITUTE OF TECHNOLOGY & SCIENCE

(UGC AUTONOMOUS)
Bogaram (V), Keesara (M), Medchal (D), T.S - 501301
LIST OF LAB EXERCISES

DATABASE MANAGEMENT SYSTEMS LAB

COURSE OBJECTIVES:
The course should enable the students to learn:
1. Discuss the basic database concepts, applications, data models, schemas and instances.
2. Design Entity Relationship model for a database.
3. Demonstrate the use of constraints and relational algebra operations.
4. Describe the basics of SQL and construct queries using SQL
5. Understand the importance of normalization in databases.
COURSE OUTCOMES:
At the end of the course the students are able to:
1. Use the basic concepts of Database Systems in Database design
2. Design a Database using ER Modeling
3. Apply normalization on database design to eliminate anomalies
4. Apply SQL queries and PL/SQL queries to interact with Database
5. Analyze database transactions and can control them by applying ACID properties.

S.No. NAME OF THE PROGRAMS Page

no.

1 WEEK -1 12
DDL Commands
Creation of Tables using SQL- Overview of using SQL tool and Data types in SQL
Altering Tables and
Dropping Tables
2 WEEK -2 13
Create Table with Primary key and Foreign Key& DML Commands
Creating Tables (along with Primary and Foreign keys), Practicing DML commands-
Insert,
Update
Delete.
3 WEEK -3 14
Selection Queries
Practicing Select command using following operations
AND, OR
ORDER BY
BETWEEN
LIKE
Apply CHECK constraint
4 WEEK -4 20
Aggregate Functions and Views
Practice Queries using following functions
COUNT,
SUM,
AVG,
MAX,
MIN,
 Apply constraint on aggregation using
GROUP BY,
HAVING,VIEWS Create, Modify and Drop
5 WEEK -5 21
Nested Queries
Practicing Nested Queries using
UNION,
INTERSECT,
CONSTRAINTS
IN
6 WEEK -6 22
Co- Related Nested Queries
Practicing Co – Related Nested Queries using
EXISTS
,NOT EXISTS. ANY, ALL
7 WEEK -7 24
Join Queries
Practicing Join Queries using
Inner join
Outer join
Equi join
Natural join
8 WEEK -8 25
Triggers
Practicing on Triggers - creation of trigger, Insertion using trigger, Deletion using
trigger, Updating using trigger.

9 WEEK -9 32
Procedures
Procedures- Creation of Stored Procedures, Execution of Procedure, and Modification
of Procedure.

10 WEEK -10
Cursors
Cursors- Declaring Cursor, Opening Cursor, Fetching the data, closing the cursor.

11 WEEK -11
PL/SQL Part 1
Practice PL/SQL –
block structure,
variables,
data types,
12 WEEK -12
PL/SQL Part 2
Practice PL/SQL –
operators,
control structures;
aseca

Case study 1: College Management

Case study 2: An Enterprise/Organization
Case study 3: Library Management system
Case study 4: Sailors and shipment system
Vision of the institute:

“Holy Mary Institute of Technology & science visualizes dissemination of knowledge

and skills to students, who would eventually contribute to the well being of the people of the
nation and global community.”

Mission of the institute:

To impart adequate fundamental knowledge in all basic sciences and engineering,

technical and inter-personal skills to students.

To make learning process exciting, stimulating and joyful.

To create environment conducive to excellent teaching – learning process.

To bring out creativity in students that would promote innovation, research and
entrepreneurship.

To contribute to advancement of engineering and technology that would help meet

societal needs.

To preserve and promote cultural heritage, humanistic and spiritual values promoting
peace and harmony in society.

Vision of the Department

To produce globally competent and socially responsible computer science

engineers contributing to the advancement of engineering and technology which
involves creativity and innovation by providing excellent learning environment
with world class facilities.

Mission of the Department

1. To be a center of excellence in instruction, innovation in research and scholarship,

and service to the stake holders, the profession, and the public.

2. To prepare graduates to enter a rapidly changing field as a competent computer

science engineer.

3. To prepare graduate capable in all phases of software development, possess a firm

understanding of hardware technologies, have the strong mathematical background
necessary for scientific computing, and be sufficiently well versed in general theory
to allow growth within the discipline as it advances.
4. To prepare graduates to assume leadership roles by possessing good
communication skills, the ability to work effectively as team members, and an
 appreciation for their social and ethical responsibility in a global setting.

PROGRAM EDUCATIONAL OBJECTIVES (PEOs): Program Educational Objectives

(PEOs) are broad statements that describe what graduates are expected to attain within
a few years of graduation. The PEOs for Computer Science and Engineering graduates
are:

PEO-I: To provide graduates with a good foundation in mathematics, sciences and

engineering fundamentals required to solve engineering problems that will facilitate
them to find employment in industry and/or to pursue postgraduate studies with an
appreciation for lifelong learning.

PEO-II: To provide graduates with analytical and problem solving skills to design
algorithms, other hardware/ software systems, and inculcate professional ethics,
interpersonal skills to work in a multi-cultural team.

PEO-III: To facilitate graduates get familiarized with state of the art software/hardware
tools, imbibing creativity and innovation that would enable them to develop cutting-edge
technologies of multi-disciplinary nature for societal development.

Program Outcomes (CSE)

PROGRAM OUTCOMES (POs): Program Outcomes (POs) describe what students are
expected to know and be able to do by the time of graduation to accomplish Program
Educational Objectives (PEOs). The Program Outcomes for Computer Science and
Engineering graduates are: Engineering Graduates would be able to:
PO 1:Engineering knowledge: Apply the knowledge of mathematics, science,
engineering fundamentals, and an engineering specialization to the solution of complex
engineering problems.
PO 2: Problem analysis: Identify, formulate, review research literature, and analyze
complex engineering problems reaching substantiated conclusions using first principles
of mathematics, natural sciences, and engineering sciences.
PO 3:Design/development of solutions: Design solutions for complex engineering
problems and design system components or processes that meet the specified needs
with appropriate consideration for the public health and safety, and the cultural, societal,
and environmental considerations.
PO 4: Conduct investigations of complex problems: Use research-based knowledge
and research methods including design of experiments, analysis and interpretation of
data, and synthesis of the information to provide valid conclusions.
PO 5:Modern tool usage: Create, select, and apply appropriate techniques, resources,
and modern engineering and IT tools including prediction and modeling to complex
engineering activities with an understanding of the limitations.
PO 6:The engineer and society: Apply reasoning informed by the contextual knowledge
to assess societal, health, safety, legal and cultural issues and the consequent
responsibilities relevant to the professional engineering practice.
PO 7:Environment and sustainability: Understand the impact of the professional
engineering solutions in societal and environmental contexts, and demonstrate the
knowledge of, and need for sustainable development.
PO 8: Ethics: Apply ethical principles and commit to professional ethics and
responsibilities and norms of the engineering practice.
PO 9:Individual and team work: Function effectively as an individual, and as a member
or leader in diverse teams, and in multidisciplinary settings.
PO 10: Communication: Communicate effectively on complex engineering activities
with the engineering community and with society at large, such as, being able to
comprehend and write effective reports and design documentation, make effective
presentations, and give and receive clear instructions.
PO 11:Project management and finance: Demonstrate knowledge and understanding of
the engineering and management principles and apply these to one’s own work, as a
member and leader in a team, to manage projects and in multidisciplinary environments.
PO 12: Life-long learning: Recognize the need for, and have the preparation and ability
to engage in independent and life-long learning in the broadest context of technological
change.
PROGRAM SPECIFIC OUTCOMES (PSOs):
PSO 1: To identify and define the computing requirements appropriate for its solution
under given constraints.
PSO 2: To follow the best practices, namely, SEI-CMM levels and 6-sigma which varies
from time to time for software development projects using open-ended programming
environments to produce software deliverables as per customer needs.
Lab Course Objectives

Course Objectives Develop ability to

Objective: The objective of this lab is to get an overview of the various machine learning
techniques and can able to demonstrate them using python.

Lab Course Outcomes

Course Outcomes After completion of the course, student would be able to
Course outcomes:

After the completion of the “Machine Learning” lab, the student can able to:
 understand complexity of Machine Learning algorithms and their limitations;
 understand modern notions in data analysis oriented computing;
 be capable of confidently applying common Machine Learning algorithms in
practice and implementing their own;
 Be capable of performing experiments in Machine Learning using real-world data.

Mapping of Lab Course with Programme Educational Objectives

Course
S.N Componen PEO 1 PEO 2 PEO 3
o t Code Course Semester

Profession
al
A1AM407P
1 1 2
1 Course C DBMS II

Mapping of Lab Course outcomes with Programme outcomes:

POs P P P P P P P P P P P P
O O O O O O O O O O O O
1 2 3 4 5 6 7 8 9 1 1 1
0 1 2
 Database Management Systems
EXP
NO.

1to 3 2 2 3 - - 3 - - - - 2
Discuss the basic database concepts, 12
applications, data models, schemas and
instances.

3,4 2 2 3 2 2 - 3 - 3 3 1 2
Design Entity Relationship model for a
database.

5,6 2 3 3 3 2 2 2 2 3 3 3 3
Demonstrate the use of constraints and
relational algebra operations.

8,5,10, 2 1 3 1 2 - 3 3 - 2 - 3
Describe the basics of SQL and construct 11,12,
queries using SQL. 9
Understand the importance of normalization in
databases.
 GENERAL LABORATORY INSTRUCTIONS

1. Students are advised to come to laboratory at least 5 minutes before (to the
starting time), those who come after 5 minutes will not be allowed into the lab.
2. Plan your task properly much before to the commencement, come prepare to the
lab with Synopsis/ program/experiment details.
3. Students should enter into the laboratory with :
a. Laboratory observation notes with all the details (Problem statement, Aim,
Algorithm, Procedures, program, Expected output ,etc) filled in for lab session.
b. Laboratory record updated up to the last session experiments and other
utensils(if any) needed in the lab.
4. Sign in the laboratory log in register, write the TIME-IN ,and occupy the computer
system allotted to you by the faculty.
5. Execute your task in the laboratory, and record the results /output in the lab
observation note book, and get certified by the concerned faculty.
6. All the students should be polite and cooperative with the laboratory staffs must
maintained the discipline and decency in the laboratory.
7. Computer labs are established with sophisticated and high end branded systems
which should be utilized properly.
8. Students / faculty must keep their mobile phones in SWITCHED OFF mode during
the lab sessions. Miss use of equipment, miss behaviors with the staff and
system etc,. will attract severe punishment.
9. Students must take the permission of the faculty in case of any urgency to out ; if
any body found loitering outside the lab /class without permission during the
work hours will be treated seriously and punish appropriately .
10. Student should LOGOFF / SHUTDOWN the computer systems before he/she
leaves the lab after completing the task (experiment) in all aspects. He/ She
must ensure the system/ seat is kept properly.

Head of the Department Principal

 SCHEME OF EVALUATION FOR EXTERNAL LABS

Correctness Conduct Model Results Viva

of write up Experiment Calculations and
and & Graphs
precautions observations
Marks: 20 Marks: 20 Marks: 15 Marks: 10 Marks:
10
Total Marks: 75 Marks

SCHEME OF EVALUATION FOR INTERNAL LABS

Day to Day Evaluation-----15 Marks Internal Exam------10 Marks
Unifor Observ Perfor Result Viva Correctn Conduct Model Result Viva
m ation& mance s Voce ess of Experime Calculati s and Voce
Record of Write up nt & ons Graph
experi and observati s
ment Precauti ons
ons
Mark Mark Mark Mark Mark Marks: Marks: Marks: Mark Mark
s: 2 s: 3 s: 3 s: 4 s: 3 2 2 2 s: 2 s: 2
Total Marks: 15+10=25 Marks
 WEEK 1
AIM:
DDL Commands
Creation of Tables using SQL- Overview of using SQL tool and Data types in SQL
Altering Tables and
Dropping Tables

PROGRAM:
Creation of Tables using SQL- Overview of using SQL tool and Data types in SQL
Creating a basic table involves naming the table and defining its columns and each
column's data type.
The SQL CREATE TABLE statement is used to create a new table.

Syntax
The basic syntax of the CREATE TABLE statement is as follows −
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);
CREATE TABLE is the keyword telling the database system what you want to do. In this
case, you want to create a new table. The unique name or identifier for the table follows
the CREATE TABLE statement.
Then in brackets comes the list defining each column in the table and what sort of data
type it is. The syntax becomes clearer with the following example.
A copy of an existing table can be created using a combination of the CREATE TABLE
statement and the SELECT statement. You can check the complete details at Create
Table Using another Table.

Example
The following code block is an example, which creates a CUSTOMERS table with an ID
as a primary key and NOT NULL are the constraints showing that these fields cannot be
NULL while creating records in this table −
SQL> CREATE TABLE CUSTOMERS(
ID INT NOT NULL,
NAME VARCHAR (20) NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR (25) ,
SALARY DECIMAL (18, 2),
PRIMARY KEY (ID)
);
You can verify if your table has been created successfully by looking at the message
displayed by the SQL server, otherwise you can use the DESC command as follows −
SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | NULL | |
| SALARY | decimal(18,2) | YES | | NULL | |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)
Now, you have CUSTOMERS table available in your database which you can use to store
the required information related to customers.
Altering Tables and
The SQL ALTER TABLE command is used to add, delete or modify columns in an
existing table. You should also use the ALTER TABLE command to add and drop various
constraints on an existing table.

Syntax
The basic syntax of an ALTER TABLE command to add a New Column in an existing
table is as follows.
ALTER TABLE table_name ADD column_name datatype;
The basic syntax of an ALTER TABLE command to DROP COLUMN in an existing table
is as follows.
ALTER TABLE table_name DROP COLUMN column_name;
The basic syntax of an ALTER TABLE command to change the DATA TYPE of a column
in a table is as follows.
ALTER TABLE table_name MODIFY COLUMN column_name datatype;
The basic syntax of an ALTER TABLE command to add a NOT NULL constraint to a
column in a table is as follows.
ALTER TABLE table_name MODIFY column_name datatype NOT NULL;
The basic syntax of ALTER TABLE to ADD UNIQUE CONSTRAINT to a table is as follows.
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);
The basic syntax of an ALTER TABLE command to ADD CHECK CONSTRAINT to a table
is as follows.
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);
The basic syntax of an ALTER TABLE command to ADD PRIMARY KEY constraint to a
table is as follows.
ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);
The basic syntax of an ALTER TABLE command to DROP CONSTRAINT from a table is
as follows.
ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;
If you're using MySQL, the code is as follows −
ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;
The basic syntax of an ALTER TABLE command to DROP PRIMARY KEY constraint
from a table is as follows.
ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;
If you're using MySQL, the code is as follows −
ALTER TABLE table_name
DROP PRIMARY KEY;

Example
Consider the CUSTOMERS table having the following records −
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Following is the example to ADD a New Column to an existing table −
ALTER TABLE CUSTOMERS ADD SEX char(1);
Now, the CUSTOMERS table is changed and following would be output from the SELECT
statement.
+----+---------+-----+-----------+----------+------+
| ID | NAME | AGE | ADDRESS | SALARY | SEX |
+----+---------+-----+-----------+----------+------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 | NULL |
| 2 | Ramesh | 25 | Delhi | 1500.00 | NULL |
| 3 | kaushik | 23 | Kota | 2000.00 | NULL |
| 4 | kaushik | 25 | Mumbai | 6500.00 | NULL |
| 5 | Hardik | 27 | Bhopal | 8500.00 | NULL |
| 6 | Komal | 22 | MP | 4500.00 | NULL |
| 7 | Muffy | 24 | Indore | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+
Following is the example to DROP sex column from the existing table.
ALTER TABLE CUSTOMERS DROP SEX;
Now, the CUSTOMERS table is changed and following would be the output from the
SELECT statement.
+----+---------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+---------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+---------+-----+-----------+----------+

Dropping Tables

The SQL DROP TABLE statement is used to remove a table definition and all the data,
indexes, triggers, constraints and permission specifications for that table.
NOTE − You should be very careful while using this command because once a table is
deleted then all the information available in that table will also be lost forever.

Syntax
The basic syntax of this DROP TABLE statement is as follows −
DROP TABLE table_name;

Example
Let us first verify the CUSTOMERS table and then we will delete it from the database as
shown below −
SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID | int(11) | NO | PRI | | |
| NAME | varchar(20) | NO | | | |
| AGE | int(11) | NO | | | |
| ADDRESS | char(25) | YES | | NULL | |
| SALARY | decimal(18,2) | YES | | NULL | |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)
This means that the CUSTOMERS table is available in the database, so let us now drop
it as shown below.
SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)
Now, if you would try the DESC command, then you will get the following error −
SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist
Here, TEST is the database name which we are using for our examples.

Viva Questions
1. Define SQL?

2. What is DDL ?

3. Explain Database Languages ?

 WEEK -2
AIM:
Create Table with Primary key and Foreign Key& DML Commands
Creating Tables (along with Primary and Foreign keys), Practicing DML commands-
Insert,
Update
Delete.

PROGRAM:

Syntax of SELECT DML command

1. SELECT column_Name_1, column_Name_2, ….., column_Name_N FROM Name_of_table;

Here, column_Name_1, column_Name_2, ….., column_Name_N are the names of those

columns whose data we want to retrieve from the table.

If we want to retrieve the data from all the columns of the table, we have to use the
following SELECT command:

1. SELECT * FROM table_name;

Examples of SELECT Command

Example 1: This example shows all the values of every column from the table.

1. SELECT * FROM Student;

This SQL statement displays the following values of the student table:

Student_ID Student_Name Student_Marks

BCA1001 Abhay 85

BCA1002 Anuj 75

BCA1003 Bheem 60
 BCA1004 Ram 79

BCA1005 Sumit 80

Example 2: This example shows all the values of a specific column from the table.

1. SELECT Emp_Id, Emp_Salary FROM Employee;

This SELECT statement displays all the values of Emp_Salary and Emp_Id column
of Employee table:

Emp_Id Emp_Salary

201 25000

202 45000

203 30000

204 29000

205 40000

Example 3: This example describes how to use the WHERE clause with the SELECT
DML command.

Let's take the following Student table:

Student_ID Student_Name Student_Marks

BCA1001 Abhay 80

BCA1002 Ankit 75

BCA1003 Bheem 80

BCA1004 Ram 79

BCA1005 Sumit 80
 If you want to access all the records of those students whose marks is 80 from the
above table, then you have to write the following DML command in SQL:

1. SELECT * FROM Student WHERE Stu_Marks = 80;

The above SQL query shows the following table in result:

Student_ID Student_Name Student_Marks

BCA1001 Abhay 80

BCA1003 Bheem 80

BCA1005 Sumit 80

INSERT DML Command

INSERT is another most important data manipulation command in Structured Query
Language, which allows users to insert data in database tables.

Syntax of INSERT Command

1. INSERT INTO TABLE_NAME ( column_Name1 , column_Name2 , column_Name3 , .... column_N

ameN ) VALUES (value_1, value_2, value_3, .... value_N ) ;

Examples of INSERT Command

Example 1: This example describes how to insert the record in the database table.

Let's take the following student table, which consists of only 2 records of the student.

Stu_Id Stu_Name Stu_Marks Stu_Age

101 Ramesh 92 20

201 Jatin 83 19

Suppose, you want to insert a new record into the student table. For this, you have to
write the following DML INSERT command:

1. INSERT INTO Student (Stu_id, Stu_Name, Stu_Marks, Stu_Age) VALUES (104, Anmol, 89, 19);
 UPDATE DML Command
UPDATE is another most important data manipulation command in Structured Query
Language, which allows users to update or modify the existing data in database tables.

Syntax of UPDATE Command

1. UPDATE Table_name SET [column_name1= value_1, ….., column_nameN = value_N] WHERE CO

NDITION;

Here, 'UPDATE', 'SET', and 'WHERE' are the SQL keywords, and 'Table_name' is the name
of the table whose values you want to update.

Examples of the UPDATE command

Example 1: This example describes how to update the value of a single field.

Let's take a Product table consisting of the following records:

Product_Id Product_Name Product_Price Product_Quantity

P101 Chips 20 20

P102 Chocolates 60 40

P103 Maggi 75 5

P201 Biscuits 80 20

P203 Namkeen 40 50

Suppose, you want to update the Product_Price of the product whose Product_Id is
P102. To do this, you have to write the following DML UPDATE command:

1. UPDATE Product SET Product_Price = 80 WHERE Product_Id = 'P102' ;

Example 2: This example describes how to update the value of multiple fields of the
database table.

Let's take a Student table consisting of the following records:

Stu_Id Stu_Name Stu_Marks Stu_Age

 101 Ramesh 92 20

201 Jatin 83 19

202 Anuj 85 19

203 Monty 95 21

102 Saket 65 21

103 Sumit 78 19

104 Ashish 98 20

Suppose, you want to update Stu_Marks and Stu_Age of that student whose Stu_Id is
103 and 202. To do this, you have to write the following DML Update command:

1. UPDATE Student SET Stu_Marks = 80, Stu_Age = 21 WHERE Stu_Id = 103 AND Stu_Id = 202;

DELETE DML Command

DELETE is a DML command which allows SQL users to remove single or multiple
existing records from the database tables.

This command of Data Manipulation Language does not delete the stored data
permanently from the database. We use the WHERE clause with the DELETE command
to select specific rows from the table.

Syntax of DELETE Command

1. DELETE FROM Table_Name WHERE condition;

Examples of DELETE Command

Example 1: This example describes how to delete a single record from the table.

Let's take a Product table consisting of the following records:

Product_Id Product_Name Product_Price Product_Quantity

P101 Chips 20 20
 P102 Chocolates 60 40

P103 Maggi 75 5

P201 Biscuits 80 20

P203 Namkeen 40 50

Suppose, you want to delete that product from the Product table whose Product_Id is
P203. To do this, you have to write the following DML DELETE command:

1. DELETE FROM Product WHERE Product_Id = 'P202' ;

Example 2: This example describes how to delete the multiple records or rows from
the database table.

Let's take a Student table consisting of the following records:

Stu_Id Stu_Name Stu_Marks Stu_Age

101 Ramesh 92 20

201 Jatin 83 19

202 Anuj 85 19

203 Monty 95 21

102 Saket 65 21

103 Sumit 78 19

104 Ashish 98 20

Suppose, you want to delete the record of those students whose Marks is greater than
70. To do this, you have to write the following DML Update command:

1. DELETE FROM Student WHERE Stu_Marks > 70 ;

Viva Questions:
1. Define SQL DB?

2. ?

3. Define dataset?

WEEK -3
AIM:

Selection Queries
Practicing Select command using following operations
AND, OR
ORDER BY
BETWEEN
LIKE
Apply CHECK constraint
PROGRAM:
The SQL AND, OR and NOT Operators
The WHERE clause can be combined with AND, OR, and NOT operators.

The AND and OR operators are used to filter records based on more than one condition:

 The AND operator displays a record if all the conditions separated by AND are TRUE.
 The OR operator displays a record if any of the conditions separated by OR is TRUE.

The NOT operator displays a record if the condition(s) is NOT TRUE.

AND Syntax
SELECT column1, column2, ...
FROM table_name
WHERE condition1 AND condition2 AND condition3 ...;

OR Syntax
SELECT column1, column2, ...
FROM table_name
WHERE condition1 OR condition2 OR condition3 ...;

NOT Syntax
SELECT column1, column2, ...
FROM table_name
WHERE NOT condition;

Demo Database
The table below shows the complete "Customers" table from the Northwind sample
database:

CustomerID CustomerName ContactName Address City Post

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 1220

2 Ana Trujillo Emparedados Ana Trujillo Avda. de la México D.F. 0502

y helados Constitución 2222
3 Antonio Moreno Taquería Antonio Moreno Mataderos 2312 México D.F. 0502

4 Around the Horn Thomas Hardy 120 Hanover Sq. London WA1

5 Berglunds snabbköp Christina Berguvsvägen 8 Luleå S-95

Berglund

6 Blauer See Delikatessen Hanna Moos Forsterstr. 57 Mannheim 6830

7 Blondel père et fils Frédérique 24, place Kléber Strasbourg 6700

Citeaux

8 Bólido Comidas Martín Sommer C/ Araquil, 67 Madrid 2802

preparadas

9 Bon app' Laurence 12, rue des Bouchers Marseille 1300

Lebihans

10 Bottom-Dollar Marketse Elizabeth 23 Tsawassen Blvd. Tsawassen T2F

Lincoln

11 B's Beverages Victoria Fauntleroy Circus London EC2

Ashworth

12 Cactus Comidas para Patricio Cerrito 333 Buenos 1010

llevar Simpson Aires

13 Centro comercial Francisco Chang Sierras de Granada México D.F. 0502

Moctezuma 9993
 14 Chop-suey Chinese Yang Wang Hauptstr. 29 Bern 3012

15 Comércio Mineiro Pedro Afonso Av. dos Lusíadas, 23 São Paulo 0543

AND Example
The following SQL statement selects all fields from "Customers" where country is
"Germany" AND city is "Berlin":

ExampleGet your own SQL Server

SELECT * FROM Customers
WHERE Country='Germany' AND City='Berlin';

OR Example
The following SQL statement selects all fields from "Customers" where city is "Berlin" OR
"München":

Example
SELECT * FROM Customers
WHERE City='Berlin' OR City='München';

The following SQL statement selects all fields from "Customers" where country is
"Germany" OR "Spain":

Example
SELECT * FROM Customers
WHERE Country='Germany' OR Country='Spain';

NOT Example
The following SQL statement selects all fields from "Customers" where country is NOT
"Germany":

Example
SELECT * FROM Customers
WHERE NOT Country='Germany';
Combining AND, OR and NOT
You can also combine the AND, OR and NOT operators.

The following SQL statement selects all fields from "Customers" where country is
"Germany" AND city must be "Berlin" OR "München" (use parenthesis to form complex
expressions):

Example
SELECT * FROM Customers
WHERE Country='Germany' AND (City='Berlin' OR City='München');

Example
SELECT * FROM Customers
WHERE NOT Country='Germany' AND NOT Country='USA';

The SQL ORDER BY Keyword

The ORDER BY keyword is used to sort the result-set in ascending or descending order.

The ORDER BY keyword sorts the records in ascending order by default. To sort the records
in descending order, use the DESC keyword.

ORDER BY Syntax
SELECT column1, column2, ...
FROM table_name
ORDER BY column1, column2, ... ASC|DESC;

Demo Database
Below is a selection from the "Customers" table in the Northwind sample database:

CustomerID CustomerName ContactName Address City PostalCod

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

 2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la México 05021
helados Constitución 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

4 Around the Horn Thomas Hardy 120 Hanover Sq. London WA1 1DP

ORDER BY Example
The following SQL statement selects all customers from the "Customers" table, sorted by
the "Country" column:

Example
SELECT * FROM Customers
ORDER BY Country;

ORDER BY DESC Example

The following SQL statement selects all customers from the "Customers" table, sorted
DESCENDING by the "Country" column:

Example
SELECT * FROM Customers
ORDER BY Country DESC;

The SQL BETWEEN Operator

The BETWEEN operator selects values within a given range. The values can be numbers,
text, or dates.

The BETWEEN operator is inclusive: begin and end values are included.

BETWEEN Syntax
SELECT column_name(s)
FROM table_name
WHERE column_name BETWEEN value1 AND value2;
Demo Database
Below is a selection from the "Products" table in the Northwind sample database:

ProductID ProductName SupplierID CategoryID Unit

1 Chais 1 1 10 boxes x 20 bags

2 Chang 1 1 24 - 12 oz bottles

3 Aniseed Syrup 1 2 12 - 550 ml bottles

4 Chef Anton's Cajun Seasoning 1 2 48 - 6 oz jars

BETWEEN Example
The following SQL statement selects all products with a price between 10 and 20:

Example
SELECT * FROM Products
WHERE Price BETWEEN 10 AND 20;

NOT BETWEEN Example

To display the products outside the range of the previous example, use NOT BETWEEN:

Example
SELECT * FROM Products
WHERE Price NOT BETWEEN 10 AND 20;

BETWEEN with IN Example

The following SQL statement selects all products with a price between 10 and 20. In
addition; do not show products with a CategoryID of 1,2, or 3:

Example
SELECT * FROM Products
WHERE Price BETWEEN 10 AND 20
AND CategoryID NOT IN (1,2,3);

BETWEEN Text Values Example

The following SQL statement selects all products with a ProductName between Carnarvon
Tigers and Mozzarella di Giovanni:

Example
SELECT * FROM Products
WHERE ProductName BETWEEN 'Carnarvon Tigers' AND 'Mozzarella di Giovanni'
ORDER BY ProductName;

NOT BETWEEN Text Values Example

The following SQL statement selects all products with a ProductName not between
Carnarvon Tigers and Mozzarella di Giovanni:

Example
SELECT * FROM Products
WHERE ProductName NOT BETWEEN 'Carnarvon Tigers' AND 'Mozzarella di Giovanni'
ORDER BY ProductName;

BETWEEN Dates Example

The following SQL statement selects all orders with an OrderDate between '01-July-1996'
and '31-July-1996':

Example
SELECT * FROM Orders
WHERE OrderDate BETWEEN #07/01/1996# AND #07/31/1996#;

OR:

Example
SELECT * FROM Orders
WHERE OrderDate BETWEEN '1996-07-01' AND '1996-07-31';
The SQL LIKE Operator
The LIKE operator is used in a WHERE clause to search for a specified pattern in a column.

There are two wildcards often used in conjunction with the LIKE operator:

 The percent sign (%) represents zero, one, or multiple characters

 The underscore sign (_) represents one, single character

Note: MS Access uses an asterisk (*) instead of the percent sign (%), and a question mark
(?) instead of the underscore (_).

The percent sign and the underscore can also be used in combinations!

LIKE Syntax
SELECT column1, column2, ...
FROM table_name
WHERE columnN LIKE pattern;

Tip: You can also combine any number of conditions using AND or OR operators.

Here are some examples showing different LIKE operators with '%' and '_' wildcards:

LIKE Operator Description

WHERE CustomerName LIKE 'a%' Finds any values that start with "a"

WHERE CustomerName LIKE '%a' Finds any values that end with "a"

WHERE CustomerName LIKE '%or%' Finds any values that have "or" in any position

WHERE CustomerName LIKE '_r%' Finds any values that have "r" in the second position

WHERE CustomerName LIKE 'a_%' Finds any values that start with "a" and are at least 2 characters
 WHERE CustomerName LIKE 'a__%' Finds any values that start with "a" and are at least 3 characters

SQL LIKE Examples

The following SQL statement selects all customers with a CustomerName starting with "a":

Example
SELECT * FROM Customers
WHERE CustomerName LIKE 'a%';

The following SQL statement selects all customers with a CustomerName ending with "a":

Example
SELECT * FROM Customers
WHERE CustomerName LIKE '%a';

The following SQL statement selects all customers with a CustomerName that have "or" in
any position:

Example
SELECT * FROM Customers
WHERE CustomerName LIKE '%or%';

The following SQL statement selects all customers with a CustomerName that have "r" in
the second position:

Example
SELECT * FROM Customers
WHERE CustomerName LIKE '_r%';

The following SQL statement selects all customers with a CustomerName that starts with
"a" and are at least 3 characters in length:

Example
SELECT * FROM Customers
WHERE CustomerName LIKE 'a__%';

The following SQL statement selects all customers with a ContactName that starts with "a"
and ends with "o":
Example
SELECT * FROM Customers
WHERE ContactName LIKE 'a%o';

The following SQL statement selects all customers with a CustomerName that does NOT
start with "a":

Example
SELECT * FROM Customers
WHERE CustomerName NOT LIKE 'a%';

SQL CHECK Constraint

The CHECK constraint is used to limit the value range that can be placed in a column.

If you define a CHECK constraint on a column it will allow only certain values for this
column.

If you define a CHECK constraint on a table it can limit the values in certain columns based
on values in other columns in the row.

SQL CHECK on CREATE TABLE

The following SQL creates a CHECK constraint on the "Age" column when the "Persons"
table is created. The CHECK constraint ensures that the age of a person must be 18, or
older:

MySQL:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CHECK (Age>=18)
);

SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int CHECK (Age>=18)
);
To allow naming of a CHECK constraint, and for defining a CHECK constraint on multiple
columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

CREATE TABLE Persons (

ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
City varchar(255),
CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes')
);

SQL CHECK on ALTER TABLE

To create a CHECK constraint on the "Age" column when the table is already created, use
the following SQL:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CHECK (Age>=18);

To allow naming of a CHECK constraint, and for defining a CHECK constraint on multiple
columns, use the following SQL syntax:

MySQL / SQL Server / Oracle / MS Access:

ALTER TABLE Persons

ADD CONSTRAINT CHK_PersonAge CHECK (Age>=18 AND City='Sandnes');

DROP a CHECK Constraint

To drop a CHECK constraint, use the following SQL:

SQL Server / Oracle / MS Access:

ALTER TABLE Persons

DROP CONSTRAINT CHK_PersonAge;

MySQL:

ALTER TABLE Persons

DROP CHECK CHK_PersonAge;

Viva Questions:
 WEEK -4
AIM

Aggregate Functions and Views

Practice Queries using following functions
COUNT,
SUM,
AVG,
MAX,
MIN,

Apply constraint on aggregation using

GROUP BY,
HAVING, VIEWS Create, Modify and Drop
PROGRAM:

The SQL COUNT(), AVG() and SUM()

Functions
The COUNT() function returns the number of rows that matches a specified criterion.

COUNT() Syntax
SELECT COUNT(column_name)
FROM table_name
WHERE condition;
The AVG() function returns the average value of a numeric column.

AVG() Syntax
SELECT AVG(column_name)
FROM table_name
WHERE condition;

The SUM() function returns the total sum of a numeric column.

SUM() Syntax
SELECT SUM(column_name)
FROM table_name
WHERE condition;

Demo Database
Below is a selection from the "Products" table in the Northwind sample database:

ProductID ProductName SupplierID CategoryID Unit

1 Chais 1 1 10 boxes x 20 bags

2 Chang 1 1 24 - 12 oz bottles

3 Aniseed Syrup 1 2 12 - 550 ml bottles

4 Chef Anton's Cajun Seasoning 2 2 48 - 6 oz jars

5 Chef Anton's Gumbo Mix 2 2 36 boxes

COUNT() Example
The following SQL statement finds the number of products:

Example
SELECT COUNT(ProductID)
FROM Products;

Note: NULL values are not counted.

AVG() Example
The following SQL statement finds the average price of all products:

Example
SELECT AVG(Price)
FROM Products;

Note: NULL values are ignored.

Demo Database
Below is a selection from the "OrderDetails" table in the Northwind sample database:

OrderDetailID OrderID ProductID Quantity

1 10248 11 12

2 10248 42 10

3 10248 72 5

4 10249 14 9
 5 10249 51 40

SUM() Example
The following SQL statement finds the sum of the "Quantity" fields in the "OrderDetails"
table:

Example
SELECT SUM(Quantity)
FROM OrderDetails;

Note: NULL values are ignored.

The SQL MIN() and MAX() Functions

The MIN() function returns the smallest value of the selected column.

The MAX() function returns the largest value of the selected column.

MIN() Syntax
SELECT MIN(column_name)
FROM table_name
WHERE condition;

MAX() Syntax
SELECT MAX(column_name)
FROM table_name
WHERE condition;

Demo Database
Below is a selection from the "Products" table in the Northwind sample database:

ProductID ProductName SupplierID CategoryID Unit

 1 Chais 1 1 10 boxes x 20 bags

2 Chang 1 1 24 - 12 oz bottles

3 Aniseed Syrup 1 2 12 - 550 ml bottles

4 Chef Anton's Cajun Seasoning 2 2 48 - 6 oz jars

5 Chef Anton's Gumbo Mix 2 2 36 boxes

MIN() Example
The following SQL statement finds the price of the cheapest product:

Example
SELECT MIN(Price) AS SmallestPrice
FROM Products;

MAX() Example
The following SQL statement finds the price of the most expensive product:

Example
SELECT MAX(Price) AS LargestPrice
FROM Products;

The SQL GROUP BY Statement

The GROUP BY statement groups rows that have the same values into summary rows, like
"find the number of customers in each country".

The GROUP BY statement is often used with aggregate functions

(COUNT(), MAX(), MIN(), SUM(), AVG()) to group the result-set by one or more columns.
GROUP BY Syntax
SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
ORDER BY column_name(s);

Demo Database
Below is a selection from the "Customers" table in the Northwind sample database:

CustomerI CustomerName ContactName Address City PostalCo

D de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la Constitución México 05021

helados 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

4 Around the Horn Thomas Hardy 120 Hanover Sq. London WA1 1DP

SQL GROUP BY Examples

The following SQL statement lists the number of customers in each country:

ExampleGet your own SQL Server

SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country;
The following SQL statement lists the number of customers in each country, sorted high to
low:

Example
SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country
ORDER BY COUNT(CustomerID) DESC;

Demo Database
Below is a selection from the "Orders" table in the Northwind sample database:

OrderID CustomerID EmployeeID OrderDate ShipperID

10248 90 5 1996-07-04 3

10249 81 6 1996-07-05 1

10250 34 4 1996-07-08 2

And a selection from the "Shippers" table:

ShipperID ShipperName

1 Speedy Express

2 United Package

3 Federal Shipping
GROUP BY With JOIN Example
The following SQL statement lists the number of orders sent by each shipper:

Example
SELECT Shippers.ShipperName, COUNT(Orders.OrderID) AS NumberOfOrders FROM Orders
LEFT JOIN Shippers ON Orders.ShipperID = Shippers.ShipperID
GROUP BY ShipperName;

The SQL HAVING Clause

The HAVING clause was added to SQL because the WHERE keyword cannot be used with
aggregate functions.

HAVING Syntax
SELECT column_name(s)
FROM table_name
WHERE condition
GROUP BY column_name(s)
HAVING condition
ORDER BY column_name(s);

Demo Database
Below is a selection from the "Customers" table in the Northwind sample database:

CustomerI CustomerName ContactName Address City PostalCo

D de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la Constitución México 05021

helados 2222 D.F.
 3 Antonio Moreno Taquería Antonio Moreno Mataderos 2312 México 05023
D.F.

4 Around the Horn Thomas Hardy 120 Hanover Sq. London WA1 1DP

5 Berglunds snabbköp Christina Berguvsvägen 8 Luleå S-958 22

Berglund

SQL HAVING Examples

The following SQL statement lists the number of customers in each country. Only include
countries with more than 5 customers:

Example
SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country
HAVING COUNT(CustomerID) > 5;

The following SQL statement lists the number of customers in each country, sorted high to
low (Only include countries with more than 5 customers):

Example
SELECT COUNT(CustomerID), Country
FROM Customers
GROUP BY Country
HAVING COUNT(CustomerID) > 5
ORDER BY COUNT(CustomerID) DESC;

More HAVING Examples

The following SQL statement lists the employees that have registered more than 10 orders:

Example
SELECT Employees.LastName, COUNT(Orders.OrderID) AS NumberOfOrders
FROM (Orders
 INNER JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID)
GROUP BY LastName
HAVING COUNT(Orders.OrderID) > 10;

The following SQL statement lists if the employees "Davolio" or "Fuller" have registered
more than 25 orders:

Example
SELECT Employees.LastName, COUNT(Orders.OrderID) AS NumberOfOrders
FROM Orders
INNER JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID
WHERE LastName = 'Davolio' OR LastName = 'Fuller'
GROUP BY LastName
HAVING COUNT(Orders.OrderID) > 25;

Test

Viva Questions:

WEEK -5
AIM
Nested Queries
Practicing Nested Queries using
UNION,
INTERSECT,
CONSTRAINTS
IN

Program:

The SQL UNION Operator

The UNION operator is used to combine the result-set of two or more SELECT statements.

 Every SELECT statement within UNION must have the same number of columns
 The columns must also have similar data types
 The columns in every SELECT statement must also be in the same order
UNION Syntax
SELECT column_name(s) FROM table1
UNION
SELECT column_name(s) FROM table2;

UNION ALL Syntax

The UNION operator selects only distinct values by default. To allow duplicate values,
use UNION ALL:

SELECT column_name(s) FROM table1

UNION ALL
SELECT column_name(s) FROM table2;

Note: The column names in the result-set are usually equal to the column names in the
first SELECT statement.

Demo Database
In this tutorial we will use the well-known Northwind sample database.

Below is a selection from the "Customers" table:

CustomerID CustomerName ContactName Address City PostalCo

de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la México 05021

helados Constitución 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

And a selection from the "Suppliers" table:

 SupplierID SupplierName ContactName Address City PostalCod

1 Exotic Liquid Charlotte Cooper 49 Gilbert St. London EC1 4SD

2 New Orleans Cajun Delights Shelley Burke P.O. Box 78934 New Orleans 70117

3 Grandma Kelly's Homestead Regina Murphy 707 Oxford Rd. Ann Arbor 48104

SQL UNION Example

The following SQL statement returns the cities (only distinct values) from both the
"Customers" and the "Suppliers" table:

ExampleGet your own SQL Server

SELECT City FROM Customers
UNION
SELECT City FROM Suppliers
ORDER BY City;

Note: If some customers or suppliers have the same city, each city will only be listed once,
because UNION selects only distinct values. Use UNION ALL to also select duplicate values!

SQL UNION ALL Example

The following SQL statement returns the cities (duplicate values also) from both the
"Customers" and the "Suppliers" table:

Example
SELECT City FROM Customers
UNION ALL
SELECT City FROM Suppliers
ORDER BY City;
SQL UNION With WHERE
The following SQL statement returns the German cities (only distinct values) from both the
"Customers" and the "Suppliers" table:

Example
SELECT City, Country FROM Customers
WHERE Country='Germany'
UNION
SELECT City, Country FROM Suppliers
WHERE Country='Germany'
ORDER BY City;

SQL UNION ALL With WHERE

The following SQL statement returns the German cities (duplicate values also) from both
the "Customers" and the "Suppliers" table:

Example
SELECT City, Country FROM Customers
WHERE Country='Germany'
UNION ALL
SELECT City, Country FROM Suppliers
WHERE Country='Germany'
ORDER BY City;

Another UNION Example

The following SQL statement lists all customers and suppliers:

Example
SELECT 'Customer' AS Type, ContactName, City, Country
FROM Customers
UNION
SELECT 'Supplier', ContactName, City, Country
FROM Suppliers;

Notice the "AS Type" above - it is an alias. SQL Aliases are used to give a table or a column a
temporary name. An alias only exists for the duration of the query. So, here we have created
a temporary column named "Type", that list whether the contact person is a "Customer" or a
"Supplier".

SQL Create Constraints

Constraints can be specified when the table is created with the CREATE TABLE statement,
or after the table is created with the ALTER TABLE statement.

Syntax
CREATE TABLE table_name (
column1 datatype constraint,
column2 datatype constraint,
column3 datatype constraint,
....
);

SQL Constraints
SQL constraints are used to specify rules for the data in a table.

Constraints are used to limit the type of data that can go into a table. This ensures the
accuracy and reliability of the data in the table. If there is any violation between the
constraint and the data action, the action is aborted.

Constraints can be column level or table level. Column level constraints apply to a column,
and table level constraints apply to the whole table.

The following constraints are commonly used in SQL:

 NOT NULL - Ensures that a column cannot have a NULL value

 UNIQUE - Ensures that all values in a column are different
 PRIMARY KEY - A combination of a NOT NULL and UNIQUE. Uniquely identifies each
row in a table
 FOREIGN KEY - Prevents actions that would destroy links between tables
 CHECK - Ensures that the values in a column satisfies a specific condition
 DEFAULT - Sets a default value for a column if no value is specified
 CREATE INDEX - Used to create and retrieve data from the database very quickly

The SQL IN Operator

The IN operator allows you to specify multiple values in a WHERE clause.

The IN operator is a shorthand for multiple OR conditions.

 IN Syntax
SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1, value2, ...);

or:

SELECT column_name(s)
FROM table_name
WHERE column_name IN (SELECT STATEMENT);

Demo Database
The table below shows the complete "Customers" table from the Northwind sample
database:

ustomerI CustomerName ContactName Address City PostalCod Count

e

Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209 Germa

y

Ana Trujillo Emparedados y Ana Trujillo Avda. de la Constitución México 05021 Mexic
helados 2222 D.F.

Antonio Moreno Taquería Antonio Moreno Mataderos 2312 México 05023 Mexic
D.F.

Around the Horn Thomas Hardy 120 Hanover Sq. London WA1 1DP UK

Berglunds snabbköp Christina Berguvsvägen 8 Luleå S-958 22 Sw

Berglund
IN Operator Examples
The following SQL statement selects all customers that are located in "Germany", "France"
or "UK":

ExampleGet your own SQL Server

SELECT * FROM Customers
WHERE Country IN ('Germany', 'France', 'UK');

The following SQL statement selects all customers that are NOT located in "Germany",
"France" or "UK":

Example
SELECT * FROM Customers
WHERE Country NOT IN ('Germany', 'France', 'UK');

The following SQL statement selects all customers that are from the same countries as the
suppliers:

Example
SELECT * FROM Customers
WHERE Country IN (SELECT Country FROM Suppliers);

Viva Questions:
 WEEK -6
AIM

Co- Related Nested Queries

Practicing Co – Related Nested Queries using
EXISTS
,NOT EXISTS. ANY, ALL

Program:

The SQL EXISTS Operator

The EXISTS operator is used to test for the existence of any record in a subquery.

The EXISTS operator returns TRUE if the subquery returns one or more records.

EXISTS Syntax
SELECT column_name(s)
FROM table_name
WHERE EXISTS
(SELECT column_name FROM table_name WHERE condition);

Demo Database
Below is a selection from the "Products" table in the Northwind sample database:

ProductID ProductName SupplierID CategoryID Unit

1 Chais 1 1 10 boxes x 20 bags

 2 Chang 1 1 24 - 12 oz bottles

3 Aniseed Syrup 1 2 12 - 550 ml bottles

4 Chef Anton's Cajun Seasoning 2 2 48 - 6 oz jars

5 Chef Anton's Gumbo Mix 2 2 36 boxes

And a selection from the "Suppliers" table:

SupplierI SupplierName ContactName Address City PostalCo

D e

1 Exotic Liquid Charlotte 49 Gilbert St. London EC1 4SD

Cooper

2 New Orleans Cajun Shelley Burke P.O. Box 78934 New 70117
Delights Orleans

3 Grandma Kelly's Regina Murphy 707 Oxford Rd. Ann Arbor 48104
Homestead

4 Tokyo Traders Yoshi Nagase 9-8 Sekimai Tokyo 100

Musashino-shi

SQL EXISTS Examples

The following SQL statement returns TRUE and lists the suppliers with a product price less
than 20:
Example
SELECT SupplierName
FROM Suppliers
WHERE EXISTS (SELECT ProductName FROM Products WHERE Products.SupplierID =
Suppliers.supplierID AND Price < 20);

The following SQL statement returns TRUE and lists the suppliers with a product price equal
to 22:

Example
SELECT SupplierName
FROM Suppliers
WHERE EXISTS (SELECT ProductName FROM Products WHERE Products.SupplierID =
Suppliers.supplierID AND Price = 22);

The SQL ANY and ALL Operators

The ANY and ALL operators allow you to perform a comparison between a single column
value and a range of other values.

The SQL ANY Operator

The ANY operator:

 returns a boolean value as a result

 returns TRUE if ANY of the subquery values meet the condition

ANY means that the condition will be true if the operation is true for any of the values in the
range.

ANY Syntax
SELECT column_name(s)
FROM table_name
WHERE column_name operator ANY
(SELECT column_name
FROM table_name
WHERE condition);

Note: The operator must be a standard comparison operator (=, <>, !=, >, >=, <, or <=).
The SQL ALL Operator
The ALL operator:

 returns a boolean value as a result

 returns TRUE if ALL of the subquery values meet the condition
 is used with SELECT, WHERE and HAVING statements

ALL means that the condition will be true only if the operation is true for all values in the
range.

ALL Syntax With SELECT

SELECT ALL column_name(s)
FROM table_name
WHERE condition;

ALL Syntax With WHERE or HAVING

SELECT column_name(s)
FROM table_name
WHERE column_name operator ALL
(SELECT column_name
FROM table_name
WHERE condition);

Note: The operator must be a standard comparison operator (=, <>, !=, >, >=, <, or <=).

Demo Database
Below is a selection from the "Products" table in the Northwind sample database:

ProductID ProductName SupplierID CategoryID Unit

1 Chais 1 1 10 boxes x 20 bags

2 Chang 1 1 24 - 12 oz bottles
 3 Aniseed Syrup 1 2 12 - 550 ml bottles

4 Chef Anton's Cajun Seasoning 2 2 48 - 6 oz jars

5 Chef Anton's Gumbo Mix 2 2 36 boxes

6 Grandma's Boysenberry Spread 3 2 12 - 8 oz jars

7 Uncle Bob's Organic Dried Pears 3 7 12 - 1 lb pkgs.

8 Northwoods Cranberry Sauce 3 2 12 - 12 oz jars

9 Mishi Kobe Niku 4 6 18 - 500 g pkgs.

And a selection from the "OrderDetails" table:

OrderDetailID OrderID ProductID Quantity

1 10248 11 12

2 10248 42 10

3 10248 72 5

4 10249 14 9
 5 10249 51 40

6 10250 41 10

7 10250 51 35

8 10250 65 15

9 10251 22 6

10 10251 57 15

SQL ANY Examples

The following SQL statement lists the ProductName if it finds ANY records in the
OrderDetails table has Quantity equal to 10 (this will return TRUE because the Quantity
column has some values of 10):

Example
SELECT ProductName
FROM Products
WHERE ProductID = ANY
(SELECT ProductID
FROM OrderDetails
WHERE Quantity = 10);

The following SQL statement lists the ProductName if it finds ANY records in the
OrderDetails table has Quantity larger than 99 (this will return TRUE because the Quantity
column has some values larger than 99):

Example
SELECT ProductName
FROM Products
WHERE ProductID = ANY
(SELECT ProductID
FROM OrderDetails
WHERE Quantity > 99);

The following SQL statement lists the ProductName if it finds ANY records in the
OrderDetails table has Quantity larger than 1000 (this will return FALSE because the
Quantity column has no values larger than 1000):

Example
SELECT ProductName
FROM Products
WHERE ProductID = ANY
(SELECT ProductID
FROM OrderDetails
WHERE Quantity > 1000);

Viva Questions:

WEEK -7
AIM

Join Queries
Practicing Join Queries using
Inner join
Outer join
Equi join
Natural join
Program:
SQL JOIN
A JOIN clause is used to combine rows from two or more tables, based on a related column
between them.

Let's look at a selection from the "Orders" table:

OrderID CustomerID OrderDate

10308 2 1996-09-18

10309 37 1996-09-19

10310 77 1996-09-20

Then, look at a selection from the "Customers" table:

CustomerID CustomerName ContactName Cou

1 Alfreds Futterkiste Maria Anders Germ

2 Ana Trujillo Emparedados y helados Ana Trujillo Mex

3 Antonio Moreno Taquería Antonio Moreno Mex

Notice that the "CustomerID" column in the "Orders" table refers to the "CustomerID" in the
"Customers" table. The relationship between the two tables above is the "CustomerID"
column.

Then, we can create the following SQL statement (that contains an INNER JOIN), that
selects records that have matching values in both tables:
Example
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers ON Orders.CustomerID=Customers.CustomerID;

and it will produce something like this:

OrderID CustomerName Order

10308 Ana Trujillo Emparedados y helados 9/18/

10365 Antonio Moreno Taquería 11/27

10383 Around the Horn 12/16

10355 Around the Horn 11/15

10278 Berglunds snabbköp 8/12/

Different Types of SQL JOINs

Here are the different types of the JOINs in SQL:

 (INNER) JOIN: Returns records that have matching values in both tables
 LEFT (OUTER) JOIN: Returns all records from the left table, and the matched
records from the right table
 RIGHT (OUTER) JOIN: Returns all records from the right table, and the matched
records from the left table
 FULL (OUTER) JOIN: Returns all records when there is a match in either left or right
table
SQL INNER JOIN Keyword
The INNER JOIN keyword selects records that have matching values in both tables.

INNER JOIN Syntax

SELECT column_name(s)
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;

Demo Database
In this tutorial we will use the well-known Northwind sample database.

Below is a selection from the "Orders" table:

OrderID CustomerID EmployeeID OrderDate ShipperID

 10308 2 7 1996-09-18 3

10309 37 3 1996-09-19 1

10310 77 8 1996-09-20 2

And a selection from the "Customers" table:

CustomerID CustomerName ContactName Address City PostalCo

de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la México 05021

helados Constitución 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

SQL INNER JOIN Example

The following SQL statement selects all orders with customer information:

Example
SELECT Orders.OrderID, Customers.CustomerName
FROM Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID;

Note: The INNER JOIN keyword selects all rows from both tables as long as there is a
match between the columns. If there are records in the "Orders" table that do not have
matches in "Customers", these orders will not be shown!

JOIN Three Tables

The following SQL statement selects all orders with customer and shipper information:

Example
SELECT Orders.OrderID, Customers.CustomerName, Shippers.ShipperName
FROM ((Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID)
INNER JOIN Shippers ON Orders.ShipperID = Shippers.ShipperID);

SQL LEFT JOIN Keyword

The LEFT JOIN keyword returns all records from the left table (table1), and the matching
records from the right table (table2). The result is 0 records from the right side, if there is no
match.

LEFT JOIN Syntax

SELECT column_name(s)
FROM table1
LEFT JOIN table2
ON table1.column_name = table2.column_name;

Note: In some databases LEFT JOIN is called LEFT OUTER JOIN.

Demo Database
In this tutorial we will use the well-known Northwind sample database.

Below is a selection from the "Customers" table:

 CustomerID CustomerName ContactName Address City PostalCo
de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la México 05021

helados Constitución 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

And a selection from the "Orders" table:

OrderID CustomerID EmployeeID OrderDate ShipperID

10308 2 7 1996-09-18 3

10309 37 3 1996-09-19 1

10310 77 8 1996-09-20 2

SQL LEFT JOIN Example

The following SQL statement will select all customers, and any orders they might have:

Example
SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID
ORDER BY Customers.CustomerName;

Note: The LEFT JOIN keyword returns all records from the left table (Customers), even if
there are no matches in the right table (Orders).

SQL RIGHT JOIN Keyword

The RIGHT JOIN keyword returns all records from the right table (table2), and the matching
records from the left table (table1). The result is 0 records from the left side, if there is no
match.

RIGHT JOIN Syntax

SELECT column_name(s)
FROM table1
RIGHT JOIN table2
ON table1.column_name = table2.column_name;

Note: In some databases RIGHT JOIN is called RIGHT OUTER JOIN.

Demo Database
In this tutorial we will use the well-known Northwind sample database.

Below is a selection from the "Orders" table:

OrderID CustomerID EmployeeID OrderDate ShipperID

10308 2 7 1996-09-18 3

10309 37 3 1996-09-19 1
 10310 77 8 1996-09-20 2

And a selection from the "Employees" table:

EmployeeID LastName FirstName BirthDate Photo

1 Davolio Nancy 12/8/1968 EmpID1.pic

2 Fuller Andrew 2/19/1952 EmpID2.pic

3 Leverling Janet 8/30/1963 EmpID3.pic

SQL RIGHT JOIN Example

The following SQL statement will return all employees, and any orders they might have
placed:

Example
SELECT Orders.OrderID, Employees.LastName, Employees.FirstName
FROM Orders
RIGHT JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID
ORDER BY Orders.OrderID;

Note: The RIGHT JOIN keyword returns all records from the right table (Employees), even if
there are no matches in the left table (Orders).

SQL FULL OUTER JOIN Keyword

The FULL OUTER JOIN keyword returns all records when there is a match in left (table1) or
right (table2) table records.

Tip: FULL OUTER JOIN and FULL JOIN are the same.
FULL OUTER JOIN Syntax
SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name = table2.column_name
WHERE condition;

Note: FULL OUTER JOIN can potentially return very large result-sets!

Demo Database
In this tutorial we will use the well-known Northwind sample database.

Below is a selection from the "Customers" table:

CustomerID CustomerName ContactName Address City PostalCo

de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la México 05021

helados Constitución 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

And a selection from the "Orders" table:

 OrderID CustomerID EmployeeID OrderDate ShipperID

10308 2 7 1996-09-18 3

10309 37 3 1996-09-19 1

10310 77 8 1996-09-20 2

SQL FULL OUTER JOIN Example

The following SQL statement selects all customers, and all orders:

SELECT Customers.CustomerName, Orders.OrderID

FROM Customers
FULL OUTER JOIN Orders ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName;

A selection from the result set may look like this:

CustomerName OrderID

Null 10309

Null 10310

Alfreds Futterkiste Null

Ana Trujillo Emparedados y helados 10308

Antonio Moreno Taquería Null

Note: The FULL OUTER JOIN keyword returns all matching records from both tables whether
the other table matches or not. So, if there are rows in "Customers" that do not have
matches in "Orders", or if there are rows in "Orders" that do not have matches in
"Customers", those rows will be listed as well.

SQL Self Join

A self join is a regular join, but the table is joined with itself.

Self Join Syntax

SELECT column_name(s)
FROM table1 T1, table1 T2
WHERE condition;

T1 and T2 are different table aliases for the same table.

Demo Database
In this tutorial we will use the well-known Northwind sample database.

Below is a selection from the "Customers" table:

CustomerID CustomerName ContactName Address City PostalCo

de

1 Alfreds Futterkiste Maria Anders Obere Str. 57 Berlin 12209

2 Ana Trujillo Emparedados y Ana Trujillo Avda. de la México 05021

helados Constitución 2222 D.F.

3 Antonio Moreno Taquería Antonio Mataderos 2312 México 05023

Moreno D.F.

SQL Self Join Example

The following SQL statement matches customers that are from the same city:

Example
SELECT A.CustomerName AS CustomerName1,
B.CustomerName AS CustomerName2, A.City
FROM Customers A, Customers B
WHERE A.CustomerID <> B.CustomerID
AND A.City = B.City
ORDER BY A.City;

Viva Questions:
 WEEK -8
AIM

Triggers
Practicing on Triggers - creation of trigger, Insertion using trigger, Deletion using trigger, Updating using
trigger.
Program:

One of the most used scenarios for triggers is to maintain a log of changes in a given
table. In such case, there is no point on having three different triggers, each one firing
on INSERT, UPDATE and DELETE operations. Fortunately we have the chance to use
one single trigger for all of those operations. The only drawback is that you have to add
logic to know what event fired the trigger. With a bit of ingenuity and using the
INSERTED and DELETED pseudo tables we can know the type of operation that fired the
trigger by comparing the number of rows of each pseudo table.

To give you an example, suppose the INSERTED pseudo table contains rows and the
DELETED pseudo table is empty then we know that the event that fired the trigger was
an INSERT statement. In opposition, if the DELETED pseudo table has rows and the
INSERTED pseudo table is empty then the statement that fired the trigger was a DELETE.
But if both INSERTED and DELETED have rows then the statement that fired the trigger
was an UPDATE.

Let's create a table to use in this example.

CREATE TABLE NestingTest

(
NestingTestID INT IDENTITY(1, 1),
Test INT NULL
);

Now on the code section below you will see a simple trigger that has the logic to
determine which statement was responsible for firing the trigger and prints the
statement type.

CREATE OR ALTER TRIGGER TR_IUD_NestingTest ON NestingTest

FOR INSERT, UPDATE, DELETE
AS
DECLARE @Operation VARCHAR(15)

IF EXISTS (SELECT 0 FROM inserted)

BEGIN
IF EXISTS (SELECT 0 FROM deleted)
BEGIN
SELECT @Operation = 'UPDATE'
END ELSE
BEGIN
SELECT @Operation = 'INSERT'
 END
END ELSE
BEGIN
SELECT @Operation = 'DELETE'
END
PRINT @Operation

To test the trigger we can use the code below.

INSERT INTO dbo.NestingTest

(Test) VALUES (0);

UPDATE dbo.NestingTest
SET Test = 1
WHERE NestingTestID = 1;

DELETE FROM dbo.NestingTest

WHERE NestingTestID = 1;

Types of Triggers
SQL Server has three types of triggers:

 DML (Data Manipulation Language) Triggers

 DDL (Data Definition Language) Triggers
 Logon Triggers

DML Triggers allow us to execute code in response to data modification. In other words,
they allow us to run additional code in response of the execution of an insert, update or
delete statement.

DDL Triggers give us the possibility to execute code in response of changes in the
structure of a database, like dropping or creating a table; or a server event like when
someone logs in. DDL Triggers can be split into two different types according to where
they are scoped.

 Database Scoped DDL Triggers

 Server Scoped DDL Triggers

Logon Triggers are a particular case of Server Scoped DDL triggers that fire in response
to the LOGON event that's raised when a user's session is being established.

Additional Information
 How to View Triggers in SQL Server Management Studio.

 DML Triggers
 This type of trigger is the most known and used by developers. As you may
already know, DML stands for Data Manipulation Language and refers to the SQL
instructions that changes data. Those instructions are INSERT, UPDATE and
DELETE. Basically, DML triggers can be defined as pieces of code written mostly
in Transact SQL language whose execution is not performed manually by the
user and instead is run automatically in response to DML events.
 DML Triggers are associated to a table or view and to any of the DML events
 (INSERT, UPDATE and DELETE). Something to remark is that a trigger can only be
associated with one single table or view, but can be associated to more than one
DML event. For instance, you could have a trigger that is associated with a table
that fires in response to INSERT and UPDATE events, we will see this further on
in the tutorial.
 To create a trigger we need to use the CREATE TRIGGER statement.
 In this code section you will see the basic CREATE TRIGGER syntax.
 CREATE TRIGGER trigger_name

 ON { Table name or view name }

 { FOR | AFTER | INSTEAD OF }

 { [INSERT], [UPDATE] , [DELETE] }

 Additionally the next table describes each of the arguments of the CREATE
TRIGGER syntax.

Argument Description
Indicates when the trigger must fire. FOR or AFTER occurs after the insert,
FOR | AFTER | INSTEAD OF delete or update occurs. INSTEAD OF occurs instead of the insert, delete or
update operation from occurring.
[INSERT], [UPDATE], [DELETE] The DML event (or list of events) that will cause the trigger to fire.

 Let's create a sample table, so we can create our first trigger.

 USE [SampleDB]

 GO

 CREATE TABLE Employees(

 EmployeeID INT IDENTITY(1,1) PRIMARY KEY,

 EmployeeName VARCHAR(50) NOT NULL,

 EmployeeAddress VARCHAR(50) NOT NULL,

 MonthSalary NUMERIC(10,2) NOT NULL

 )

 INSERT INTO dbo.Employees

 (

 EmployeeName,

 EmployeeAddress,
 MonthSalary

 )

 VALUES

 ( 'Mark Smith',

 'Ocean Dr 1234',

 10000

 ),

 ( 'Joe Wright',

 'Evergreen 1234',

 10000

 ),

 ( 'John Doe',

 'International Dr 1234',

 10000

 ),

 ( 'Peter Rodriguez',

 '74 Street 1234',

 10000

 );

 In the code below you will see the most basic DML trigger we can make, which
will return "Hello World". This trigger will show a "Hello World!" line every time a
row is added to the Employees table.
 USE [SampleDB]

 GO

 CREATE TRIGGER [dbo].[TR_Employees] ON [dbo].[Employees]

 FOR INSERT

 AS

 SELECT 'Hello World!'

  GO

 In order to test this trigger we need to insert some data into the Employees table.
We can do so with the next script.
 SELECT * FROM dbo.Employees

 GO

 INSERT INTO dbo.Employees ( EmployeeName , EmployeeAddress ,MonthSalary )

 VALUES ( 'Paul Martinez' , '22 Street 4217', 4000)

 GO

 SELECT * FROM dbo.Employees

 GO

 On the next image you can see the execution of the previous script. Notice that
when the INSERT statement executes it prints a "Hello World!" message.

Viva Questions:
 WEEK -9
AIM

Procedures
Procedures- Creation of Stored Procedures, Execution of Procedure, and Modification of Procedure
Program:

Stored Procedure in SQL Server

A stored procedure is a group of one or more pre-compiled SQL statements into a
logical unit. It is stored as an object inside the database server. It is a subroutine or a
subprogram in the common computing language that has been created and stored in
the database. Each procedure in SQL Server always contains a name, parameter lists,
and Transact-SQL statements. The SQL Database Server stores the stored procedures
as named objects. We can invoke the procedures by using triggers, other procedures,
and applications such as Java, Python, PHP, etc. It can support almost all relational
database systems.

SQL Server builds an execution plan when the stored procedure is called the first time
and stores them in the cache memory. The plan is reused by SQL Server in subsequent
executions of the stored procedure, allowing it to run quickly and efficiently.

Features of Stored Procedures in SQL Server

The following are the features of stored procedure in SQL Server:

o Reduced Traffic: A stored procedure reduces network traffic between the application
and the database server, resulting in increased performance. It is because instead of
sending several SQL statements, the application only needs to send the name of the
stored procedure and its parameters.
o Stronger Security: The procedure is always secure because it manages which processes
and activities we can perform. It removes the need for permissions to be granted at the
database object level and simplifies the security layers.
o Reusable: Stored procedures are reusable. It reduces code inconsistency, prevents
unnecessary rewrites of the same code, and makes the code transparent to all
applications or users.
 o Easy Maintenance: The procedures are easier to maintain without restarting or
deploying the application.
o Improved Performance: Stored Procedure increases the application performance. Once
we create the stored procedures and compile them the first time, it creates an execution
plan reused for subsequent executions. The procedure is usually processed quicker
because the query processor does not have to create a new plan.
o Types of Stored Procedures
o SQL Server categorizes the stored procedures mainly in two types:

1. User-defined Stored Procedures

2. System Stored Procedures

User-defined Stored Procedures

Database developers or database administrators build user-defined stored procedures.
These procedures provide one or more SQL statements for selecting, updating, or
removing data from database tables. A stored procedure specified by the user accepts
input parameters and returns output parameters. DDL and DML commands are used
together in a user-defined procedure.

We can further divide this procedure into two types:

o T-SQL Stored Procedures: Transact-SQL procedures are one of the most popular types
of SQL Server procedures. It takes parameters and returns them. These procedures
handle INSERT, UPDATE, and DELETE statements with or without parameters and output
row data.
o CLR Stored Procedures: The SQL Server procedures are a group of SQL commands, and
the CLR indicates the common language runtime. CLR stored procedures are made up of
the CLR and a stored procedure, which is written in a CLR-based language like VB.NET or
C#. CLR procedures are .Net objects that run in the SQL Server database's memory.

System Stored Procedures

The server's administrative tasks depend primarily on system stored procedures. When
SQL Server is installed, it creates system procedures. The system stored procedures
prevent the administrator from querying or modifying the system and database catalog
tables directly. Developers often ignore system stored procedures.

SQL Server Stored Procedures Syntax

The following are the basic syntax to create stored procedures in SQL Server:

1. CREATE PROCEDURE [schema_name].procedure_name

2. @parameter_name data_type,
3. ....
4. parameter_name data_type
5. AS
6. BEGIN
7. -- SQL statements
8. -- SELECT, INSERT, UPDATE, or DELETE statement
9. END

Parameter Explanations
The stored procedure syntax has the following parameters:

Schema_name: It is the name of your database or schema. By default, a procedure is

associated with the current database, but we can also create it into another database by
specifying the DB name.

Procedure_Name: It represents the name of your stored procedure that should be

meaningful names so that you can identify them quickly. It cannot be the system
reserved keywords.

Parameter_Name: It represents the number of parameters. It may be zero or more

based upon the user requirements. We must ensure that we used the appropriate data
type. For example, @Name VARCHAR(50).

SET NOCOUNT ON in Stored Procedure

In some cases, we use the SET NOCOUNT ON statement in the stored procedure. This
statement prevents the message that displays the number of rows affected by SQL
queries from being shown. NOCOUNT denotes that the count is turned off. It means
that if SET NOCOUNT ON is set, no message would appear indicating the number of
rows affected.

How to execute/call a stored procedure?

We can use the EXEC command to call/execute stored procedures in SQL Server. The
following syntax illustrates the execution of a stored procedure:

1. EXEC procedure_name;
2. Or,
3. EXECUTE procedure_name;

If we are using the SSMS, we need to use the below steps to execute stored procedures:

1. Navigate to the Programmability -> Stored Procedures.

2. Next, select the Stored Procedure menu and expand it. You will see the available stored
 procedures.
3. Right-click on the stored procedure you want to execute and choose
the Execute Stored Procedure
4. The Execute Procedure window will appear. If the procedure has any parameters, we
must assign/pass them before clicking OK to execute it. If no parameters are defined,
click OK to run the procedure.

Stored Procedure Simple Example

We can create a stored procedure in SQL Server in two ways:

o Using T-SQL Query

o Using SQL Server Management Studio

We will take a student table to demonstrate the stored procedure examples. This table
has the following data:

The below example uses the CREATE PROCEDURE SQL statement for creating a stored
procedure that displays the student's list in the increasing order of a salary from the
STUDENT table in the selected database:

1. CREATE PROCEDURE studentList

2. AS
3. BEGIN
4. SELECT name, age, salary
5. FROM STUDENT
6. ORDER BY salary;
7. END;

In this syntax, the studentList is the name of the stored procedure, and the AS keyword
distinguishes the stored procedure's heading and body. The BEGIN and END keywords
that accompany a single statement in a stored procedure are optional. However, it's a
good idea to include them to make the code more understandable.

When we run this statement, and everything is correct, the following message will
appear: "Commands completed successfully." It indicates that the stored procedure
 was successfully compiled and saved to the database system.

We can execute this procedure by using the below command:

1. EXEC studentList;

It will return the output as follows:

If we are using the SSMS, use the following steps for creating the stored procedure:

Step 1: Select the Database -> Programmability -> Stored Procedures.

Step 2: Right-click on the Stored Procedures folder to open the menu and then select
the New -> Stored Procedure option as follows:
Step 3: When we select the New Stored Procedure option, we will get the new query
window containing the default Stored Procedure Template. Here, we can add the
procedure name, parameters (if any), and the SQL query we want to use.

How to rename stored procedures in SQL Server?

SQL Server does not allow us to change the name of a stored procedure. Because
renaming a stored procedure does not modify the name of the corresponding object in
the sys.sql_modules. Therefore, if we need to change the existing stored procedure,
simply DROP and recreate it with a new name.

o Using T-SQL Query

o Using SQL Server Management Studio

Modify Stored Procedures using SSMS

The following steps help to learn how we can modify or make changes in stored
procedures:

Step 1: Navigate to the Database -> Programmability -> Stored Procedures.

Step 2: Expand the Stored Procedures folder, right-click on the stored procedure that
you want to modify, and then select the Modify option as follows:
 Step 3: Once we click the Modify option, we will get a new query window with an
auto-generated ALTER PROCEDURE code. Here we can make changes as per our needs.

Modify Stored Procedures using T-SQL Query

SQL Server provides an ALTER PROCEDURE statement to make modifications in the
existing stored procedures. If we want to modify the above created stored procedure,
we can write the ALTER PROCEDURE statement as follows:

1. ALTER PROCEDURE [dbo].[studentList]

2. AS
3. BEGIN
4. SET NOCOUNT ON;
5. SELECT name, salary
6. FROM STUDENT
7. ORDER BY salary;
8. END;
 Let's run the procedure to check whether we have successfully updated
the studentList procedure or not. Using the EXECUTE statement, we will get the below
output where we can see that our stored procedure is successfully modified.

How to list all stored procedures in SQL Server?

When we have several procedures, it is very important to list all procedures. Because
sometimes the procedure names are the same in many databases. In that case, this
query is very useful. We can list all stored procedure in the current database as follows:

1. SELECT * FROM sys.procedures;

The best way for listing all user-defined stored procedures in a database is to use
the ROUTINES information schema view as below:

1. SELECT ROUTINE_SCHEMA, ROUTINE_NAME

2. FROM INFORMATION_SCHEMA.ROUTINES
3. WHERE ROUTINE_TYPE = 'PROCEDURE';

OR,

1. SELECT *
2. FROM db_name.INFORMATION_SCHEMA.ROUTINES
3. WHERE ROUTINE_TYPE = 'PROCEDURE'

Another way to return a list of stored procedures is to query the sys.objects system
catalog view.

1. SELECT
2. SCHEMA_NAME(schema_id) AS [Schema],
3. name
4. FROM sys.objects
5. WHERE type = 'P';

How to delete/drop stored procedures in SQL Server?

We can delete the stored procedure in SQL Server permanently. SQL Server removes the
stored procedure in two ways:

o Using T-SQL Query

o Using SQL Server Management Studio

DROP Stored Procedures using SSMS

The following steps help to learn how we can delete stored procedures:

Step 1: Go to the Database -> Programmability -> Stored Procedures.

Step 2: Expand the Stored Procedures folder, right-click on the stored procedure that
you want to remove, and then select the Delete option as follows:

Step 3: Once we click the Delete option, we will get a Delete Object window. We can
check the dependencies by clicking on the Show Dependencies button and then click OK
to remove the stored procedure.
 Delete Stored Procedures using T-SQL Query
SQL Server provides a DROP PROCEDURE statement to remove the existing stored
procedures. We can write the DROP PROCEDURE statement as follows:

1. IF OBJECT_ID ('procedure_name', 'P') IS NOT NULL

2. DROP PROCEDURE procedure_name;

NOTE: It's a good idea to use IF OBJECT ID ('procedure name', 'P') IS NOT NULL to see if the
stored procedure exists in the database.

Input Parameters in Stored Procedure

SQL Server allows us to create input parameters stored procedures. This type of stored
procedure can enable us to pass one or more parameters to get the filtered result. Let
us understand it with the help of an example. Consider the following 'customer' table:
 The below statement creates a stored procedure with an input parameter:

1. CREATE PROCEDURE getEmployeeDetails (@States VARCHAR(50))

2. AS
3. BEGIN
4. SET NOCOUNT ON;
5. SELECT c_name, email, state
6. FROM customer
7. WHERE state = @States
8. END

If we want to execute this stored procedure, we need to pass the value for
the @States parameter. We can pass the parameter value in any of the following ways:

1. EXEC [dbo].[getEmployeeDetails] 'California';

2.
3. --OR we can write
4.
5. EXEC [dbo].[getEmployeeDetails] @States = 'New York';

We will get the output as below:

 Output Parameters in Stored Procedure
SQL Server enables us to provide many output parameters in a stored procedure. These
output parameters can be of any valid data type, such as integer, date, or character. We
can use the below syntax to create an output parameter in the stored procedure:

1. parameter_name data_type OUTPUT

Let us understand how to use Output Parameters in a stored procedure with the help of
an example. The following statement will create a procedure called countStudent, in
which we will declare an integer type variable called @StudentCount and use
the OUTPUT keyword. The procedure uses the COUNT function to find the number of
students in the STUDENT table, and then the value is assigned to the output parameter.

1. CREATE PROCEDURE countStudent (@StudentCount INT OUTPUT)

2. AS
3. BEGIN
4. SELECT @StudentCount = COUNT(Id)FROM STUDENT;
5. END;

Now, we will execute the stored procedure. Here, we need to pass the output
parameter @StudentaCouns as follows:

1. -- Declare an Int Variable that corresponds to the Output parameter in SP

2. DECLARE @TotalStudents INT
3.
4. -- Don't forget to use the keyword OUTPUT
5. EXEC [dbo].[countStudent] @TotalStudents OUTPUT
6.
7. -- Print the result
8. PRINT @TotalStudents

We will get the following output:

 Temporary Stored Procedure
We can create temporary procedures in the same way as we can create temporary
tables. The tempdb database is used to create these procedures. We can divide the
temporary procedures into two types:

o Local Temporary Stored Procedures

o Global Temporary Procedures.

Local Temporary Stored Procedures: We can create this type of procedure by using the
# as prefix and accessed only in the session in which they were created. When the
connection is closed, this process is immediately terminated.

Here's an example of how to create a local temporary procedure:

1. CREATE PROCEDURE #Temp

2. AS
3. BEGIN
4. PRINT 'Local temp procedure'
5. END

Global Temporary Stored Procedure: We can create this type of procedure by using the
## as a prefix and accessed from any sessions. When the connection that was used to
create the procedure is closed, this procedure is automatically terminated.

Here's an example of how to create a global temporary procedure:

1. CREATE PROCEDURE ##TEMP

2. AS
3. BEGIN
4. PRINT 'Global temp procedure'
5. END

Viva Questions:
 WEEK -10
AIM

Cursors
Cursors- Declaring Cursor, Opening Cursor, Fetching the data, closing the cursor.

Program:

A cursor is a pointer to this context area. PL/SQL controls the context area through a
cursor. A cursor holds the rows (one or more) returned by a SQL statement. The set of
rows the cursor holds is referred to as the active set.
You can name a cursor so that it could be referred to in a program to fetch and process
the rows returned by the SQL statement, one at a time. There are two types of cursors −

 Implicit cursors
 Explicit cursors

Implicit Cursors
Implicit cursors are automatically created by Oracle whenever an SQL statement is
executed, when there is no explicit cursor for the statement. Programmers cannot
control the implicit cursors and the information in it.
Whenever a DML statement (INSERT, UPDATE and DELETE) is issued, an implicit cursor
is associated with this statement. For INSERT operations, the cursor holds the data that
needs to be inserted. For UPDATE and DELETE operations, the cursor identifies the
rows that would be affected.
In PL/SQL, you can refer to the most recent implicit cursor as the SQL cursor, which
always has attributes such as %FOUND, %ISOPEN, %NOTFOUND, and %ROWCOUNT.
The SQL cursor has additional
attributes, %BULK_ROWCOUNT and %BULK_EXCEPTIONS, designed for use with
the FORALL statement. The following table provides the description of the most used
attributes −

S.No Attribute & Description

%FOUND
1 Returns TRUE if an INSERT, UPDATE, or DELETE statement affected one or
more rows or a SELECT INTO statement returned one or more rows.
Otherwise, it returns FALSE.

2 %NOTFOUND
 The logical opposite of %FOUND. It returns TRUE if an INSERT, UPDATE, or
DELETE statement affected no rows, or a SELECT INTO statement
returned no rows. Otherwise, it returns FALSE.

%ISOPEN
3
Always returns FALSE for implicit cursors, because Oracle closes the SQL
cursor automatically after executing its associated SQL statement.

%ROWCOUNT
4
Returns the number of rows affected by an INSERT, UPDATE, or DELETE
statement, or returned by a SELECT INTO statement.

Any SQL cursor attribute will be accessed as sql%attribute_name as shown below in the
example.
Example
We will be using the CUSTOMERS table we had created and used in the previous
chapters.
Select * from customers;

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
+----+----------+-----+-----------+----------+
The following program will update the table and increase the salary of each customer by
500 and use the SQL%ROWCOUNT attribute to determine the number of rows affected
−
DECLARE
total_rows number(2);
BEGIN
UPDATE customers
SET salary = salary + 500;
IF sql%notfound THEN
dbms_output.put_line('no customers selected');
ELSIF sql%found THEN
total_rows := sql%rowcount;
dbms_output.put_line( total_rows || ' customers selected ');
END IF;
END;
/
When the above code is executed at the SQL prompt, it produces the following result −
6 customers selected

PL/SQL procedure successfully completed.

If you check the records in customers table, you will find that the rows have been
updated −
Select * from customers;

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2500.00 |
| 2 | Khilan | 25 | Delhi | 2000.00 |
| 3 | kaushik | 23 | Kota | 2500.00 |
| 4 | Chaitali | 25 | Mumbai | 7000.00 |
| 5 | Hardik | 27 | Bhopal | 9000.00 |
| 6 | Komal | 22 | MP | 5000.00 |
+----+----------+-----+-----------+----------+

Explicit Cursors
Explicit cursors are programmer-defined cursors for gaining more control over
the context area. An explicit cursor should be defined in the declaration section of the
PL/SQL Block. It is created on a SELECT Statement which returns more than one row.
The syntax for creating an explicit cursor is −
CURSOR cursor_name IS select_statement;
Working with an explicit cursor includes the following steps −

 Declaring the cursor for initializing the memory

 Opening the cursor for allocating the memory
 Fetching the cursor for retrieving the data
 Closing the cursor to release the allocated memory

Declaring the Cursor

Declaring the cursor defines the cursor with a name and the associated SELECT
statement. For example −
CURSOR c_customers IS
SELECT id, name, address FROM customers;

Opening the Cursor

Opening the cursor allocates the memory for the cursor and makes it ready for fetching
the rows returned by the SQL statement into it. For example, we will open the above
defined cursor as follows −
OPEN c_customers;
Fetching the Cursor
Fetching the cursor involves accessing one row at a time. For example, we will fetch
rows from the above-opened cursor as follows −
FETCH c_customers INTO c_id, c_name, c_addr;

Closing the Cursor

Closing the cursor means releasing the allocated memory. For example, we will close
the above-opened cursor as follows −
CLOSE c_customers;
Example
Following is a complete example to illustrate the concepts of explicit cursors &minua;
DECLARE
c_id customers.id%type;
c_name customers.name%type;
c_addr customers.address%type;
CURSOR c_customers is
SELECT id, name, address FROM customers;
BEGIN
OPEN c_customers;
LOOP
FETCH c_customers into c_id, c_name, c_addr;
EXIT WHEN c_customers%notfound;
dbms_output.put_line(c_id || ' ' || c_name || ' ' || c_addr);
END LOOP;
CLOSE c_customers;
END;
/
When the above code is executed at the SQL prompt, it produces the following result −
1 Ramesh Ahmedabad
2 Khilan Delhi
3 kaushik Kota
4 Chaitali Mumbai
5 Hardik Bhopal
6 Komal MP

PL/SQL procedure successfully completed.

Viva Questions:
 WEEK -11
AIM

PL/SQL Part 1
Practice PL/SQL –
block structure,
variables,
data types,
Program:

In PL/SQL, the code is not executed in single line format, but it is always
executed by grouping the code into a single element called Blocks. In this
tutorial, you are going to learn about these blocks.

Blocks contain both PL/SQL as well as SQL instruction. All these instruction
will be executed as a whole rather than executing a single instruction at a time.

In this tutorial, you will learn:

 What is PL/SQL block?

 Block Structure
 PL/SQL Block Syntax
 Types of PL/SQL block

Block Structure
PL/SQL blocks have a pre-defined structure in which the code is to be grouped.
Below are different sections of PL/SQL blocks.

1. Declaration section
2. Execution section
3. Exception-Handling section

The below picture illustrates the different PL/SQL block and their section
order.
Declaration Section
This is the first section of the PL/SQL blocks. This section is an optional part.
This is the section in which the declaration of variables, cursors, exceptions,
subprograms, pragma instructions and collections that are needed in the
block will be declared. Below are few more characteristics of this part.

EXPLORE MORELearn Java Programming with Beginners Tutorial08:32

Linux Tutorial for Beginners: Introduction to Linux Operating...01:35

What is Integration Testing Software Testing Tutorial03:04

What is JVM (Java Virtual Machine) with Architecture JAVA...02:24

 How to write a TEST CASE Software Testing Tutorial01:08

Seven Testing Principles Software Testing05:01 Linux File

Permissions Commands with Examples13:29 How to use Text tool

in Photoshop CC Tutorial08:32 What is NoSQL Database

Tutorial02:00 Important Linux Commands for Beginners Linux

Tutorial15:03

 This particular section is optional and can be skipped if no declarations

are needed.
 This should be the first section in a PL/SQL block, if present.
 This section starts with the keyword ‘DECLARE’ for triggers and
anonymous block. For other subprograms, this keyword will not be
present. Instead, the part after the subprogram name definition marks
the declaration section.
 This section should always be followed by execution section.

Execution Section
Execution part is the main and mandatory part which actually executes the
code that is written inside it. Since the PL/SQL expects the executable
statements from this block this cannot be an empty block, i.e., it should have
at least one valid executable code line in it. Below are few more
characteristics of this part.

 This can contain both PL/SQL code and SQL code.

 This can contain one or many blocks inside it as a nested block.
 This section starts with the keyword ‘BEGIN’.
 This section should be followed either by ‘END’ or Exception-Handling
section (if present)
Exception-Handling Section:
The exception is unavoidable in the program which occurs at run-time and to
handle this Oracle has provided an Exception-handling section in blocks. This
section can also contain PL/SQL statements. This is an optional section of
the PL/SQL blocks.

 This is the section where the exception raised in the execution block is
handled.
 This section is the last part of the PL/SQL block.
 Control from this section can never return to the execution block.
 This section starts with the keyword ‘EXCEPTION’.
 This section should always be followed by the keyword ‘END’.

The Keyword ‘END’ marks the end of PL/SQL block.

PL/SQL Block Syntax

Below is the syntax of the PL/SQL block structure.

DECLARE --optional
<declarations>

BEGIN --mandatory
<executable statements. At least one executable statement is mandatory>

EXCEPTION --optional
<exception handles>
END; --mandatory
/
Note: A block should always be followed by ‘/’ which sends the information to
the compiler about the end of the block.

Types of PL/SQL block

PL/SQL blocks are of mainly two types.

1. Anonymous blocks
2. Named Blocks

Anonymous blocks:
Anonymous blocks are PL/SQL blocks which do not have any names assigned
to them. They need to be created and used in the same session because they
will not be stored in the server as database objects.

Since they need not store in the database, they need no compilation steps.
They are written and executed directly, and compilation and execution happen
in a single process.

Below are few more characteristics of Anonymous blocks.

 These blocks don’t have any reference name specified for them.
 These blocks start with the keyword ‘DECLARE’ or ‘BEGIN’.
 Since these blocks do not have any reference name, these cannot be
stored for later purpose. They shall be created and executed in the
same session.
 They can call the other named blocks, but call to anonymous block is
not possible as it is not having any reference.
 It can have nested block in it which can be named or anonymous. It can
also be nested in any blocks.
 These blocks can have all three sections of the block, in which
execution section is mandatory, the other two sections are optional.

Named blocks:
Named blocks have a specific and unique name for them. They are stored as
the database objects in the server. Since they are available as database
objects, they can be referred to or used as long as it is present on the server.
The compilation process for named blocks happens separately while creating
them as a database objects.

Below are few more characteristics of Named blocks.

 These blocks can be called from other blocks.

 The block structure is same as an anonymous block, except it will never
 start with the keyword ‘DECLARE’. Instead, it will start with the keyword
‘CREATE’ which instruct the compiler to create it as a database object.
 These blocks can be nested within other blocks. It can also contain
nested blocks.
 Named blocks are basically of two types:

1. Procedure
2. Function

We will learn more about these named blocks in “Procedure” and “Function”
topics in later tutorial.

PL/SQL Variables
A variable is a meaningful name which facilitates a programmer to store data
temporarily during the execution of code. It helps you to manipulate data in PL/SQL
programs. It is nothing except a name given to a storage area. Each variable in the
PL/SQL has a specific data type which defines the size and layout of the variable's
memory.

A variable should not exceed 30 characters. Its letter optionally followed by more letters,
dollar signs, numerals, underscore etc.

1. It needs to declare the variable first in the declaration section of a PL/SQL block before
using it.

2. By default, variable names are not case sensitive. A reserved PL/SQL keyword cannot be
used as a variable name.

How to declare variable in PL/SQL

You must declare the PL/SQL variable in the declaration section or in a package as a
global variable. After the declaration, PL/SQL allocates memory for the variable's value
and the storage location is identified by the variable name.

Following is the syntax for declaring variable:

1. variable_name [CONSTANT] datatype [NOT NULL] [:= | DEFAULT initial_value]

Here, variable_name is a valid identifier in PL/SQL and datatype must be valid PL/SQL
data type. A data type with size, scale or precision limit is called a constrained
declaration. The constrained declaration needs less memory than unconstrained
declaration.

Example:

Radius Number := 5;
 Date_of_birth date;

Declaration Restrictions:
In PL/SQL while declaring the variable some restrictions hold.

o Forward references are not allowed i.e. you must declare a constant or variable before
referencing it in another statement even if it is a declarative statement.
val number := Total - 200;
Total number := 1000;
The first declaration is illegal because the TOTAL variable must be declared before using
it in an assignment expression.
o Variables belonging to the same datatype cannot be declared in the same statement.
N1, N2, N3 Number;
It is an illegal declaration.

Naming rules for PL/SQL variables

The variable in PL/SQL must follow some naming rules like other programming
languages.

o The variable_name should not exceed 30 characters.

o Variable name should not be the same as the table table's column of that block.
o The name of the variable must begin with ASCII letter. The PL/SQL is not case sensitive
so it could be either lowercase or uppercase. For example: v_data and V_DATA refer to
the same variables.
o You should make your variable easy to read and understand, after the first character, it
may be any number, underscore (_) or dollar sign ($).
o NOT NULL is an optional specification on the variable.

Initializing Variables in PL/SQL

Evertime you declare a variable, PL/SQL defines a default value NULL to it. If you want
to initialize a variable with other value than NULL value, you can do so during the
declaration, by using any one of the following methods.

o The DEFAULT keyword

o The assignment operator

1. counter binary_integer := 0;
2. greetings varchar2(20) DEFAULT 'Hello JavaTpoint';
 You can also specify NOT NULL constraint to avoid NULL value. If you specify the NOT
NULL constraint, you must assign an initial value for that variable.

You must have a good programming skill to initialize variable properly otherwise,
sometimes program would produce unexpected result.

Example of initilizing variable

Let's take a simple example to explain it well:

1. DECLARE
2. a integer := 30;
3. b integer := 40;
4. c integer;
5. f real;
6. BEGIN
7. c := a + b;
8. dbms_output.put_line('Value of c: ' || c);
9. f := 100.0/3.0;
10. dbms_output.put_line('Value of f: ' || f);
11. END;

After the execution, this will produce the following result:

Value of c: 70
Value of f: 33.333333333333333333

PL/SQL procedure successfully completed.

Variable Scope in PL/SQL:

PL/SQL allows nesting of blocks. A program block can contain another inner block. If
you declare a variable within an inner block, it is not accessible to an outer block. There
are two types of variable scope:

o Local Variable: Local variables are the inner block variables which are not accessible to
outer blocks.
o Global Variable: Global variables are declared in outermost block.

Example of Local and Global variables

Let's take an example to show the usage of Local and Global variables in its simple
form:

1. DECLARE
2. -- Global variables
3. num1 number := 95;
4. num2 number := 85;
5. BEGIN
6. dbms_output.put_line('Outer Variable num1: ' || num1);
7. dbms_output.put_line('Outer Variable num2: ' || num2);
8. DECLARE
9. -- Local variables
10. num1 number := 195;
11. num2 number := 185;
12. BEGIN
13. dbms_output.put_line('Inner Variable num1: ' || num1);
14. dbms_output.put_line('Inner Variable num2: ' || num2);
15. END;
16. END;
17. /

After the execution, this will produce the following result:

Outer Variable num1: 95

Outer Variable num2: 85
Inner Variable num1: 195
Inner Variable num2: 185

PL/SQL procedure successfully completed.

Variable Attributes:
When you declare a PL/SQL variable to hold the column values, it must be of correct
data types and precision, otherwise error will occur on execution. Rather than hard
coding the data type and precision of a variable. PL/SQL provides the facility to declare
a variable without having to specify a particular data type using %TYPE and %ROWTYPE
attributes. These two attributes allow us to specify a variable and have that variable
data type be defined by a table/view column or a PL/SQL package variable.

A % sign servers as the attribute indicator. This method of declaring variables has an
advantage as the user is not concerned with writing and maintaining code.

Following are the types of Variable Attributes in PL/SQL.

o %TYPE:

The %TYPE attribute is used to declare variables according to the already declared
variable or database column. It is used when you are declaring an individual variable, not
a record. The data type and precision of the variable declared using %TYPE attribute is
the same as that of the column that is referred from a given table. This is particularly
 useful when declaring variables that will hold database values. When using the %TYPE
keyword, the name of the columns and the table to which the variable will correspond
must be known to the user. These are then prefixed with the variable name. If some
previously declared variable is referred then prefix that variable name to the %TYPE
attribute.

The syntax for declaring a variable with %TYPE is:

1. <var_name> <tab_name>.<column_name>%TYPE;

Where <column_name> is the column defined in the <tab_name>.

Consider a declaration.

SALARY EMP.SAL % TYPE;

1. This declaration will declare a variable SALARY that has the same data type as column S
DECLARE
2. SALARY EMP.SAL % TYPE;
3. ECODE EMP.empno % TYPE;
4. BEGIN
5. Ecode :=&Ecode;
6. Select SAL into SALARY from EMP where EMPNO = ECODE;
7. dbms_output.put_line('Salary of ' || ECODE || 'is = || salary');
8. END;

After the execution, this will produce the following result:

Enter value for ecode: 7499

Salary of 7499 is = 1600
PL/SQL procedure successfully completed.

o %ROWTYPE:

The %ROWTYPE attribute is used to declare a record type that represents a row in a
table. The record can store an entire row or some specific data selected from the table.
A column in a row and corresponding fields in a record have the same name and data
types.

The syntax for declaring a variable with %ROWTYPE is:

1. <var_name> <tab_name>.ROW%TYPE;

Where <variable_name> is the variable defined in the <tab_name>.

AL of the EMP table.

EMPLOYEE EMP. % ROW TYPE;

 This declaration will declare a record named EMPLOYEE having fields with the same
name and data types as that of columns in the EMP table. You can access the elements
of EMPLOYEE record as

EMPLOYEE.SAL := 10000;

EMPLOYEE.ENAME := ‘KIRAN’;

Example:

1. DECLARE
2. EMPLOYEE EMP. % ROW TYPE;
3. BEGIN
4. EMPLOYEE.EMPNO := 2092;
5. 5 EMPLOYEE.ENAME := 'Sanju';
6. Insert into EMP where (EMPNO, ENAME) Values (employee.empno, employee.ename);
7. dbms_output.put_line('Row Inserted');
8. END;

After the execution, this will produce the following result:

Row Inserted
PL/SQL procedure successfully completed.

Advantages:
o If you don’t know the data type at the time of declaration. The data type assigned
to the associated variables will be determined dynamically at run time.
o If the data type of the variable you are referencing changes the %TYPE or
%ROWTYPE variable changes at run time without having to rewrite variable
declarations. For example: if the ENAME column of an EMP table is changed
from a VARCHAR2(10) to VRACHAR2(15) then you don’t need to modify the
PL/SQL code.

Viva Questions:
 WEEK -12
AIM

PL/SQL Part 2
Practice PL/SQL –
operators,
control structures;
 aseca

Case study 1: College Management

Case study 2: An Enterprise/Organization
Case study 3: Library Management system
Case study 4: Sailors and shipment system

Program:

we will discuss operators in PL/SQL. An operator is a symbol that tells the compiler to
perform specific mathematical or logical manipulation. PL/SQL language is rich in
built-in operators and provides the following types of operators −

 Arithmetic operators
 Relational operators
 Comparison operators
 Logical operators
 String operators
Here, we will understand the arithmetic, relational, comparison and logical operators
one by one. The String operators will be discussed in a later chapter − PL/SQL - Strings.

Arithmetic Operators
Following table shows all the arithmetic operators supported by PL/SQL. Let us
assume variable A holds 10 and variable B holds 5, then −
Show Examples

Operator Description Example

+ Adds two operands A + B will give 15

- Subtracts second operand from the first A - B will give 5

* Multiplies both operands A * B will give 50

/ Divides numerator by de-numerator A / B will give 2

** Exponentiation operator, raises one operand to the A ** B will give

power of other 100000

Relational Operators
Relational operators compare two expressions or values and return a Boolean result.
Following table shows all the relational operators supported by PL/SQL. Let us
assume variable A holds 10 and variable B holds 20, then −
Show Examples

Operator Description Example

Checks if the values of two operands are equal or not, if (A = B) is not

=
yes then condition becomes true. true.

!=
Checks if the values of two operands are equal or not, if (A != B) is
<> values are not equal then condition becomes true. true.
~=

Checks if the value of left operand is greater than the (A > B) is not
> value of right operand, if yes then condition becomes true.
true.

Checks if the value of left operand is less than the value (A < B) is
<
of right operand, if yes then condition becomes true. true.

Checks if the value of left operand is greater than or equal (A >= B) is

>= to the value of right operand, if yes then condition not true.
becomes true.

Checks if the value of left operand is less than or equal to (A <= B) is

<= the value of right operand, if yes then condition becomes true
true.

Comparison Operators
Comparison operators are used for comparing one expression to another. The result is
always either TRUE, FALSE or NULL.
Show Examples

Operator Description Example

The LIKE operator compares a

If 'Zara Ali' like 'Z% A_i'
character, string, or CLOB value to a
returns a Boolean true,
LIKE pattern and returns TRUE if the value
whereas, 'Nuha Ali' like 'Z%
matches the pattern and FALSE if it
A_i' returns a Boolean false.
does not.

BETWEEN The BETWEEN operator tests whether a If x = 10 then, x between 5

 and 20 returns true, x
value lies in a specified range. x
between 5 and 10 returns
BETWEEN a AND b means that x >= a
true, but x between 11 and
and x <= b.
20 returns false.

If x = 'm' then, x in ('a', 'b', 'c')

The IN operator tests set membership. x
returns Boolean false but x
IN IN (set) means that x is equal to any
in ('m', 'n', 'o') returns Boolean
member of set.
true.

The IS NULL operator returns the

BOOLEAN value TRUE if its operand is
If x = 'm', then 'x is null'
IS NULL NULL or FALSE if it is not NULL.
returns Boolean false.
Comparisons involving NULL values
always yield NULL.

Logical Operators
Following table shows the Logical operators supported by PL/SQL. All these operators
work on Boolean operands and produce Boolean results. Let us assume variable
A holds true and variable B holds false, then −
Show Examples

Operator Description Examples

Called the logical AND operator. If both the operands are (A and B) is
and
true then condition becomes true. false.

Called the logical OR Operator. If any of the two operands (A or B) is

or
is true then condition becomes true. true.

Called the logical NOT Operator. Used to reverse the not (A and B)
not logical state of its operand. If a condition is true then is true.
Logical NOT operator will make it false.

PL/SQL Operator Precedence

Operator precedence determines the grouping of terms in an expression. This affects
how an expression is evaluated. Certain operators have higher precedence than others;
for example, the multiplication operator has higher precedence than the addition
operator.
For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher
precedence than +, so it first gets multiplied with 3*2 and then adds into 7.
Here, operators with the highest precedence appear at the top of the table, those with
the lowest appear at the bottom. Within an expression, higher precedence operators will
be evaluated first.
The precedence of operators goes as follows: =, <, >, <=, >=, <>, !=, ~=, ^=, IS NULL, LIKE,
BETWEEN, IN.
Show Examples

Operator Operation

** exponentiation

+, - identity, negation

*, / multiplication, division

+, -, || addition, subtraction, concatenation

comparison

NOT logical negation

AND conjunction

OR inclusion

Control Structures in PL/SQL

Procedural computer programs use the basic control structures.
 The selection structure tests a condition, then executes one sequence of statements
instead of another, depending on whether the condition is true or false. A condition is any
variable or expression that returns a BOOLEAN value (TRUE or FALSE).
 The iteration structure executes a sequence of statements repeatedly as long as a
condition holds true.
 The sequence-structure simply executes a sequence of statements in the order in which
they occur.

Want to know more about SQL? Read this extensive SQL Tutorial and enhance your
knowledge!

Testing Conditions: IF and CASE Statements

The IF statement executes a sequence of statements depending on the value of a
condition. There are three forms of IF statements: IF-THEN, IF-THEN-ELSE, and
IF-THEN-ELSIF.
The CASE statement is a compact way to evaluate a single condition and choose
between many alternative actions. It makes sense to use CASE when there are three or
more alternatives to choose from.

 Using the IF-THEN Statement

The simplest form of IF statement associates a condition with a sequence of

statements enclosed by the keywords THEN and END IF (not ENDIF)
The sequence of statements is executed only if the condition is TRUE. If the condition is
FALSE or NULL, the IF statement does nothing. In either case, control passes to the next
statement.
Example: Using a Simple IF-THEN Statement
DECLARE
sales NUMBER(8,2) := 10100;
quota NUMBER(8,2) := 10000;
bonus NUMBER(6,2);
emp_id NUMBER(6) := 120;
BEGIN
IF sales > (quota + 200) THEN
bonus := (sales - quota)/4;
UPDATE employees SET salary = salary + bonus WHERE employee_id = emp_id;
END IF;
END;
/

Get 100% Hike!

Master Most in Demand Skills Now !

S u b m it

 Using CASE Statements

Like the IF statement, the CASE statement selects one sequence of statements to
execute. However, to select the sequence, the CASE statement uses a selector rather
than multiple Boolean expressions. A selector is an expression whose value is used to
select one of several alternatives.
Example: Using the CASE-WHEN Statement
DECLARE
grade CHAR(1);
BEGIN
grade := 'B';
CASE grade
WHEN 'A' THEN DBMS_OUTPUT.PUT_LINE('Excellent');
WHEN 'B' THEN DBMS_OUTPUT.PUT_LINE('Very Good');
WHEN 'C' THEN DBMS_OUTPUT.PUT_LINE('Good');
WHEN 'D' THEN DBMS_OUTPUT.PUT_LINE('Fair');
WHEN 'F' THEN DBMS_OUTPUT.PUT_LINE('Poor');
ELSE DBMS_OUTPUT.PUT_LINE('No such grade');
END CASE;
END;
/

Controlling Loop Iterations: LOOP and EXIT

Statements
LOOP statements execute a sequence of statements multiple times. There are three
forms of LOOP statements: LOOP, WHILE-LOOP, and FOR-LOOP.

 Using the LOOP Statement

The simplest form of LOOP statement is the basic loop, which encloses a sequence of
statements between the keywords LOOP and END LOOP, as follows:
LOOP
sequence_of_statements
END LOOP;

With each iteration of the loop, the sequence of statements is executed, then control
resumes at the top of the loop. You use an EXIT statement to stop looping and prevent
an infinite loop. You can place one or more EXIT statements anywhere inside a loop, but
not outside a loop. There are two forms of EXIT statements: EXIT and
EXIT-WHEN.

 Using the EXIT Statement

The EXIT statement forces a loop to complete unconditionally. When an EXIT statement
is encountered, the loop completes immediately and control passes to the next
statement.

 Using the EXIT-WHEN Statement

The EXIT-WHEN statement lets a loop complete conditionally. When the EXIT statement
is encountered, the condition in the WHEN clause is evaluated. If the condition is true,
the loop completes and control passes to the next statement after the loop.

 Labeling a PL/SQL Loop

Like PL/SQL blocks, loops can be labeled. The optional label, an undeclared identifier
enclosed by double angle brackets, must appear at the beginning of the LOOP
statement. The label name can also appear at the end of the LOOP statement. When
you nest labeled loops, use ending label names to improve readability.

 Using the WHILE-LOOP Statement

The WHILE-LOOP statement executes the statements in the loop body as long as a
condition is true:
WHILE condition LOOP
sequence_of_statements
END LOOP;

Come to Intellipaat’s Community if you have queries!

Using the FOR-LOOP Statement

Simple FOR loops iterate over a specified range of integers. The number of iterations is
known before the loop is entered. A double dot (..) serves as the range operator. The
range is evaluated when the FOR loop is first entered and is never re-evaluated. If the
lower bound equals the higher bound, the loop body is executed once.
Example: Using a Simple FOR LOOP Statement
DECLARE
p NUMBER := 0;
BEGIN
FOR k IN 1..500 LOOP -- calculate pi with 500 terms
p := p + ( ( (-1) ** (k + 1) ) / ((2 * k) - 1) );
END LOOP;
p := 4 * p;
DBMS_OUTPUT.PUT_LINE( 'pi is approximately : ' || p ); -- print result
END;
/

Sequential Control: GOTO and NULL Statements

The GOTO statement is seldom needed. Occasionally, it can simplify logic enough to
warrant its use. The NULL statement can improve readability by making the meaning
and action of conditional statements clear.
Overuse of GOTO statements can result in code that is hard to understand and maintain.
Use GOTO statements sparingly. For example, to branch from a deeply nested structure
to an error-handling routine, raise an exception rather than use a GOTO statement.

 Using the GOTO Statement

The GOTO statement branches to a label unconditionally. The label must be unique
within its scope and must precede an executable statement or a PL/SQL block. When
executed, the GOTO statement transfers control to the labeled statement or block. The
labeled statement or block can be down or up in the sequence of statements.
Example: Using a Simple GOTO Statement
DECLARE
p VARCHAR2(30);
n PLS_INTEGER := 37; -- test any integer > 2 for prime
BEGIN
FOR j in 2..ROUND(SQRT(n)) LOOP
IF n MOD j = 0 THEN -- test for prime
p := ' is not a prime number'; -- not a prime number
GOTO print_now;
END IF;
END LOOP;
p := ' is a prime number';
<<print_now>>
DBMS_OUTPUT.PUT_LINE(TO_CHAR(n) || p);
END;
/

Check out the top PL/SQL Interview Questions to learn what is expected from PL/SQL
professionals!

 Using the NULL Statement

The NULL statement does nothing and passes control to the next statement. Some
languages refer to such instruction as a no-op (no operation).
Example: Using the NULL Statement to Show No Action
DECLARE
v_job_id VARCHAR2(10);
v_emp_id NUMBER(6) := 110;
BEGIN
SELECT job_id INTO v_job_id FROM employees WHERE employee_id = v_emp_id;
IF v_job_id = 'SA_REP' THEN
UPDATE employees SET commission_pct = commission_pct * 1.2;
ELSE
NULL; -- do nothing if not a sales representative
END IF;
END;
/

Viva Questions: