BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

MODULE – 4
Chapter-1 :- SQL: Advanced Queries

4.1 MORE COMPLEX SQL QUERIES

1. Comparisons Involving NULL and Three-Valued Logic:
 NULL is used to represent a missing value that usually has one of the 3 different interpretations.
o value unknown (exists but is not known or it is not known whether a value exists or
not),
o value not available (exists but is purposely withheld), or
o attribute not applicable (undefined for this tuple).
Examples:
1. Unknown value: A particular person has a date of birth but it is not known, so it is
represented by NULL in the database.

2. Unavailable or withheld value: A person has a home phone but does not want it to be
listed, so it is withheld and represented as NULL in the database.
3. Not applicable attribute: An attribute LastCollegeDegree would be NULL for a person who
has no college degrees, because it does not apply to that person.

 SQL does not distinguish between the different meanings of NULL.

 In general, each NULL value is considered to be different from every other NULL value in the
database records.
 When a record with NULL is involved in a comparison operation, the result is considered to
be UNKNOWN (it may be TRUE or it may be FALSE). Hence, SQL uses a 3-valued logic
with values TRUE, FALSE and UNKNOWN.
 The results or truth values of three-valued logical expressions when the logical connectives
AND, OR and NOT are used are showed in the table below.
(a)
AND TRUE FALSE UNKNOWN
TRUE TRUE FALSE UNKNOWN
FALSE FALSE FALSE FALSE
UNKNOWN UNKNOWN FALSE UNKNOWN (c)
(b) NOT
OR TRUE FALSE UNKNOWN
TRUE FALSE
TRUE TRUE TRUE TRUE
FALSE TRUE
FALSE TRUE FALSE UNKNOWN
UNKNOWN UNKNOWN
UNKNOWN TRUE UNKNOWN UNKNOWN

In (a) and (b), the rows and columns represent the values of the results of 2 three valued Boolean
expressions which would appear in the WHERE clause of an SQL query. Each expression result would
have a value of true, false, or unknown.

Dept. of ISE, RNSIT Page 1

BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 In select-project-join queries, the general rule is that only those combinations of tuples that evaluate
the logical expression of the query to TRUE are selected. Tuple combinations that evaluate to FALSE
or UNKNOWN are not selected. There are exceptions to that rule for certain operations such as outer
joins.

 SQL allows queries that check whether an attribute value is NULL.

 SQL uses the comparison operators IS or IS NOT to compare an attribute value to NULL. SQL
considers each NULL value as being distinct from every other NULL value, so equality comparison is
not appropriate. It follows that when a join condition is specified, tuples with NULL values for the join
attributes are not included in the result (unless it is an outer join).

Query 1: Retrieve the names of all employees who do not have supervisors.

SELECT Fname, Lname FROM EMPLOYEE

WHERE Super ssn IS NULL;

2. Nested Queries, Tuples, and Set / Multiset Comparisons:

 Some queries require that existing values in the database be fetched and then used in a comparison
condition.

 Nested queries are complete select-from-where blocks within another SQL query. That other query
is called the outer query. The nested queries can also appear in the WHERE clause of the FROM
clause or other SQL clauses as needed.

 The comparison operator IN compares a value v with a set (or multiset) of values V and evaluates to
TRUE if v is one of the elements in V.

Query 4 A: Same as query 4.

SELECT DISTINCT Pnumber
FROM PROJECT
WHERE Pnumber IN
(SELECT Pnumber
FROM PROJECT, DEPARTMENT, EMPLOYEE
WHERE D n u m = D n u m b e r AND M g r s s n = S s n AND Ln a m e = ' S m i t h ' )
OR

Pnumber IN
(SELECT Pno
FROM WORKS ON, EMPLOYEE
WHERE Essn=Ssn AND Lname='Smith');

Dept. of ISE, RNSIT Page 2

BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 If a nested query returns a single attribute and a single tuple, the query result will be a single value.
In such cases, = can be used instead of IN for the comparison operator. In general, a nested query
will return a table (relation) which is a set or multiset of tuples.

 SQL allows the use of tuples of values in comparisons by placing them in parentheses. This is
illustrated in the query below.

Query 3:Retrieve the Ssns of all employee who work on the same (project, hours) combination
on some project that employee 'John Smith' whose Ssn is 123456789 works on.
SELECT D I ST IN CT E s sn
FROM WORKS ON
W HE R E ( P n o , H o u r s ) I N ( SE L E C T P n o , H o u r s
FROM WORKS ON
WHERE Ssn = ' 1 2 3 4 5 6 7 8 9 ' ) ;

In this example, the IN operator compares the sub-tuple of values in parentheses (Pno, Hours) for
each tuple in WORKS_ON with the set of union compatible tuples produced by the nested query.

 A number of comparison operators can be used to compare a single value v (typically an

attribute name) to a set or multiset V (typically a nested query). The =ANY (or =SOME) operator
returns TRUE if the value v is equal to some value in the set :V and is hence equivalent to IN The
keywords ANY and SOME have same meaning. Operators that can be combined with ANY
include >, >= <, <— and < >. The keyword ALL can also be combined with each of these
operators. The comparison condition (v >ALL V) returns TRUE if value 'v is greater than all the
values in the set (or multiset) V.

Query 4: Retrieve the names of employees whose salary is greater than the salary of all the
employees in department 5.
SELECT Ln a m e , Fn a m e
FROM EMPLOYEE
WHERE S a l ar y > ALL (SELECT S a la r y

FROM EMPLOYEE

WHERE Dno = 5 ) ;
 If attributes of the same name exist, one in the FROM clause of the nested query and one in the
FROM clause of the outer query, then there arises ambiguity in attribute names. The rule is that the
reference to an unqualified attribute refers to the relation declared in the innermost nested query. It is
generally advisable to create tuple variables (aliases) for all the tables referenced in an SQL
query to avoid errors and ambiguities.

Dept. of ISE, RNSIT Page 3

BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

Query 5: Retrieve the name of each employee who has a dependent with the same first name
and sex as the employee.

SELECT E . Ln a m e, E . Fn a m e
FROM EMPLOYEE AS E
WHERE E . S s n I N ( SELECT E s s n
FROM DEPENDENT
WHERE E. Fna me = De p end ent na me AN D E .S ex= Sex);
3. Correlated Nested Queries:
 Whenever a condition in the WHERE clause of a nested query references some attribute of a
relation declared in the outer query, the two queries are said to be correlated.

 For a correlated nested query, the nested query is evaluated once for each tuple (or
combination of tuples) in the outer query.

Example: In Query 5, for each EMPLOYEE tuple, evaluate the nested query, which retrieves the
Essn values for all DEPENDENT tuples with the same sex and name as that EMPLOYEE tuple; if the
SSN value of the EMPLOYEE tuple is in the result of the nested query, then select that EMPLOYEE
tuple.

In general, a query written with nested select-from-where blocks and using the = or IN comparison
operators can always be expressed as a single block query. The query below is another way of
solving Query 5.

SELECT E . Fn a m e, E . Ln a m e
FROM EMPLOYEE AS E, DEPENDENT AS D
WHERE E . Ssn = D. E ssn AND E . Sex= D. Sex
AN D E . F n a m e = D . D e p e n d e n t n a m e ;

4. The EXISTS and UNIQUE Functions in SQL:

 EXISTS and UNIQUE are Boolean functions that return TRUE or FALSE.
 They can be used in WHERE clause condition.
 The EXISTS function in SQL is used to check whether the result of a correlated
nested query is empty (contains no tuples) or not.
 The result of EXISTS is a Boolean value TRUE if the nested query result contains atleast one
tuple or FALSE if the nested query result contains no tuples.
 EXISTS and NOT EXISTS are typically used in conjunction with a correlated nested query.

 EXISTS (Q) returns TRUE if there is atleast one tuple in the result of the nested query
Q and returns FALSE otherwise.

 NOT EXISTS ( Q) returns TRUE if there are no tuples in the result of the nested query
Q and returns FALSE otherwise.

Dept. of ISE, RNSIT

Page 4
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

Query 5 can be written in an alternative form that uses EXISTS. The nested query
references the Ssn, Fname, and Sex attributes of the EMPLOYEE relation from the
outer query. For each employee tuple, evaluate the nested query which retrieves all
DEPENDENT tuples with the same Essn, Sex and Dependent_name as the employee
tuple; if atleast 1 tuple EXISTS in the result of the nested query, then select that
employee tuple.
SE L E C T E . F n a m e , E . L n a m e FROM EMPLOYEE AS E
WHERE EXISTS ( SELECT * FROM DEPENDENT AS D
WHE R E E . S s n = D . E s s n AND E . S e x = D . S e x
AND
E. Fna me= D .D ependentname);

Query 6: Retrieve the names of employees who have no dependents.

SELECT FNAME, LNAME FROM EMPLOYEE
WHERE N OT EX I ST S ( SELE CT * FROM DEPENDENT
WHERE SSN=ESSN);
In this query, the correlated nested query retrieves all DEPENDENT tuples related to an
EMPLOYEE tuple. If none exist, the EMPLOYEE tuple is selected because the WHERE clause
condition will evaluate to TRUE in this case. For each employee tuple, the correlated nested
query selects all DEPENDENT tuples whose Essn value matches the EMPLOYEE Ssn; if the
result is empty, no dependents are related to the employee and so we select that employee tuple.

Query 7: List the names of managers who have atleast one dependent.
SELECT FNAME, LNAME
FROM EMPLOYEE
WHEREEXISTS ( SELECT * FROM DEPENDENT
WHERE SSN=ESSN)
AND EXISTS (SELECT FROM DEPARTMENT
WHERE S s n = M g r s s n ) ;

Query 8: Retrieve the name of each employee who works on all the projects
controlled by department number 5.

SELECT Fna me, Lna me

FROM EMPLOYEE
WHEREN OT E X I ST S ( ( S E L E C T P n u m b e r F R OM P R O J E C T WHERE
D num= S)
EXCEPT (SELECT Pno FROM WORKS ON WHERE Ssn=Essn)) ;
The first subquery (which is not correlated with the outer query) selects all projects controlled
bydepartment 5 and the second subquery (which is correlated with the outer query) selects all projects
that the particular employee being considered works on. If the set difference of the first subquery result
MINUS EXCEPT) the second subquery result is empty, it means that the employee works on all the projects
and is therefore selected.

Dept. of ISE, RNSIT

Page 5
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 The function UNIQUE (Q) returns TRUE if there are no duplicate tuples in the result of query Q;
otherwise it returns FALSE.

 The UNIQUE function can be used to test whether the result of a nested query is a set — no
duplicates or a multiset — duplicates exist.

5. Explicit sets and Renaming of Attributes in SQL:

 An explicit set of values can be used in the where clause rather than a nested query. Such a set is
enclosed in parentheses in SQL.

Query 8 : Retrieve the Essn of all employees who work on

project numbers 1, 2 or 3.

SELECT DISTINCT Essn FROM WORKS ON

WHERE Pno IN (1,2,3);

 In SQL, it is possible to rename any attribute that appears in the result of a query by adding the
AS qualifier followed by the desired new name.

 AS construct can be used to alias both attribute and relation names in general and it can be used in
appropriate parts of a query.
SELECT E.Lname AS Employee name, S.Lname AS
Supervisor name FROM EMPLOYEE AS E, EMPLOYEE AS
S
WHERE E.Superssn=S.Ssn;

6. Joined Tables in SQL:

 The joined table (or joined relation) permits users to specify a table resulting from a join
operation in the FROM clause of a query. This construct avoids mixing together all the select
and join conditions in the WHERE clause.

Example: Consider query which retrieves the name and address of every employee who
works for the 'Research' department. First specify the join of the EMPLOYEE and DEPARTMENT
relations and then select the desired tuples and attributes. The FROM clause contains a single
joined table.

SELECT F n a m e , L n a m e , A d d r e s s FROM (EMPLOYEE JOIN

DEPARTMENT ON Dno=Dnumber) WHERE D n a m e = ' R e s e a r c h ' ;

The attributes of such a table are all the attributes of the first table EMPLOYEE
followed by all attributes of the second table DEPARTMENT.

 In a NATURAL JOIN on two relations R and S, no join condition is specified; an implicit

EQUIJOIN condition for each pair of attributes with the same name from R and S is created.
Each such pair of attributes is included only once in the resulting relation.

Dept. of ISE, RNSIT

Page 6
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 If the names of join attributes are not the same in base relations, rename the attributes so
that they match and then apply the NATURAL JOIN. The AS construct can be used to
rename a relation and all its attributes in the FROM clause.

Example: Here the DEPARTMENT relation is renamed as DEPT and its attributes are
renamed as Dname , Dno, Mssn and Msdate. The implied join condition for this natural join is
EMPLOYEE. Dno = DEPT. Dno because it is the only pair of attributes with the same name.

SELECT Fname, Lname, Address

FROM (EMPLOYEE NATURAL JOIN DEPARTMENT AS DEPT(Dname, Dno,
Mssn, Msdate) WHERE DNAME='Research';

 The default type of join in a joined table is an INNER JOIN where a tuple is included in the
result only if a matching tuple exists in the other relation. If every tuple should be included in
the result, OUTER JOIN must be explicitly specified.

Query 9: Retrieve the names of employees along with their

supervisor name and even if employee has no supervisor include
his/her name too.
SELECT E . Ln a m e A S E m p l oye e n a m e , S. Ln a m e A S Supervisor
name FROM (EMPLOYEE AS E LEFT OUTER JOIN EMPLOYEE AS S ON
E.Superssn=S.Ssn);

 The options available for specifying joined tables in SQL include —

INNER JOIN only pairs of tuples that match the join condition are retrieved, same as
—

JOIN.

LEFT OUTER JOIN — every tuple in the left table must appear in the result. If it does
not have a matching tuple, it is padded with NULL values for the attributes of the right
table.

RIGHT OUTER JOIN every tuple in the right table must appear in the result. If it does
-

not have a matching tuple, it is padded with NULL values for the attributes of the left table.
F U L L OUTER JOIN. The keyword OUTER may be omitted in LEFT OUTER JOIN or

RIGHT OUTER JOIN or FULL OUTER JOIN.

 : • If the join attributes have the same name, we can specify the natural join variation of outer
joins by using the keyword NATURAL before the operation. Eg: NATURAL LEFT OUTER
JOIN.

 : * The keyword CROSS JO IN is used to specify CARTESIAN PRODUCT operation.

Dept. of ISE, RNSIT

Page 7
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 Join specifications can be nested where one of the tables in a join may itself be a joined table.
This allows the specification of the join of three or more tables as a single joined table which is
called a multiway join.

Example:
SELECT PNUMBER, DNUM, LNAME, BDATE, ADDRESS
FROM((PROJECT JOIN DEPARTMENT ON DNUM=DNUMBER) JOIN
EMPLOYEE ON MGRSSN=SSN)
WHERE PLOCATION='Stafford';

 Some SQL implementations have a different syntax to specify outer joins by using the comparison
operators += for left outer join, =+ for right outer join and +=+ for full outer join when specifying
the join condition.(Eg: Oracle uses this syntax)

Example:
SELECT E .Lname, S.Lname FROM
EMPLOYEE E, EMPLOYEE S W H E R E
E.Super ssn += S.Ssn;

7. Aggregate Functions in SQL:

 Aggregate functions are used to summarize information from multiple tuples into a single-tuple
summary.

 Grouping is used to create subgroups of tuples before summarization.

 SQL has built-in aggregate functions - COUNT, SUM, MAX, MIN and AVG.
 The COUNT function returns the number of tuples or values as specified in a query.
 The functions SUM, MAX, MIN and AVG are applied to a set or multiset of numeric values and
return the sum, the maximum value, the minimum value and the average of those values
respectively.

 These functions can be used in the SELECT clause or in a HAVING clause.

 The functions MAX and MIN can also be used with attributes that have nonnumeric
domains if the domain values have a total ordering among one another.

 NULL values are discarded when aggregate functions are applied to a particular
column (attribute). COUNT (*) counts tuples not values hence NULL values do not
affect it.

 When an aggregate function is applied to a collection of values, NULLs are removed from the
collection before the calculation. If the collection becomes empty because all values are NULL,

Dept. of ISE, RNSIT

Page 8
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

the aggregate function will return NULL except COUNT which returns a 0 for an empty
collection of values.

 Aggregate functions can also be used in selection conditions involving nested queries. A
correlated nested query with an aggregate function can be specified and then used in the
WHERE clause of an outer query.

 SQL also has aggregate functions SOME and ALL that can be applied to a collection of Boolean
values. SOME returns TRUE if atleast one element in the collection is TRUE whereas ALL returns
TRUE if all elements in the collection are TRUE.

Query 10: Find the sum of salaries, maximum salary, the

minimum salary, and the average salary among all employees.
SELECT SUM(SALARY), MAX(SALARY), MIN(SALARY), AVG(SALARY)
FROM EMPLOYEE;
 This query returns a single-row summary of all the rows in the EMPLOYEE table. We can
use the keyword AS to rename the column names in the resulting single-row table.

SELECT SUM(SALARY) AS Total_salary, MAX(SALARY) AS

Highest _salary, MIN(SALARY) AS Lowest salary,
AVG(SALARY)AS Average salary FROM EMPLOYEE;

Query11: Find the sum of the salaries, maximum salary, the

minimum salary, and the average salary among employees who work
for the 'Research' department.
SELECT SUM (SALARY) , MAX(SALARY), MIN( SALARY), AVG ( SALARY)
FROM EMPLOYEE, DEPARTMENT

WHERE DNO=DNUMBER AND DNAME='Research';

Query12: Retrieve the total number of employees in the company.

SE L E C T C OU N T (* ) FROM EMPLOYEE;

Query13: Retrieve the total number of employees in the 'Research'

department.
SELECT COUNT (*) FROM EMPLOYEE, DEPARTMENT
WHEREDNO=DNUMBER AND DNAME='Research';

Here the asterisk (*) refers to the rows (ttiples), so COUNT (*) returns the number of rows in
the result of the query. The COUNT function can also be used to count values in a column rather
than tuples.

Dept. of ISE, RNSIT

Page 9
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

Query14 : Count the number of distinct salary values in the database.

SELECT CO UNT ( DISTINCT S a l a r y) FROM EMPLOYEE;
COUNT (Salary) will not eliminate duplicate values of Salary. Any tuples with NULL for Salary will not
be counted.

Query 15: Retrieve the names of all employees who have two or more
dependents.
SELE CT L n a m e , F n a m e FROM EMPLOYEE
WHERE ( SELECT COUNT (*) FROM DE PE NDE NT
WH ERE S s n = E s s n ) > = 2 ;
The correlated nested query counts the number of dependents that each employee has. If the count is
greater than or equal to two, the employee tuple is selected.

8. Grouping: The GROUP BY and HAVING Clauses:

 The aggregate functions can be applied to subgroups of tuples in a relation where the subgroups
are based on some attribute values.
For e.g., to find the average salary of employees in each department, we need to partition
the relation into non-overlapping subsets (or groups) of tuples.

 Each group (or partition) will consist of tuples that have the same value of some attribute(s)
called the grouping attribute(s).The function is then applied to each subgroup
independently to produce summary information about each group.

 SQL has a GROUP BY-clause for specifying the grouping attributes. These attributes must also
appear in the SELECT- clause so that the value resulting from applying each aggregate function
to a group of tuples appears along with the value of the grouping attribute(s).

 If NULLs exist in the grouping attribute, then a separate group is created for all tuples with a
NULL value in the grouping attribute. Eg: If the EMPLOYEE tuple had NULL for the grouping
attribute Dno, there would be a separate group for those tuples in the result of Query 16.

 A join condition can be used in conjunction with grouping.

 To retrieve the values of aggregate functions for only those groups that satis.b, certain conditions,
SQL provides a HAVING clause which can appear in conjunction with a GROUP BY clause. The
HAVING clause is used for specifying a selection condition on groups (rather than on individual
tuples) of tuples associated with each value of the grouping attributes. HAVING provides a
condition on the summary information regarding the group of tuples associated with each value of
the grouping attributes. Only the groups that satisfy the condition are retrieved in the result of the
query.

Dept. of ISE, RNSIT

Page 10
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 • The selection conditions in the WHERE clause limit the tuples to which functions are applied
but the HAVING clause serves to choose whole groups.

Query 16: For each department, retrieve the department number, the
number of employees in the department, and their average salary.
SELECT D n o , C O U N T ( * ) , A V G ( S a l a r y )
FROM EMPLOYEE GROUP B Y D n o ;
The EMPLOYEE tuples are divided into groups - each group having the same value for the
grouping attribute Dno. The COUNT and AVG functions are applied to each such group of
tuples separately. The SELECT clause includes only the grouping attribute and the functions
to be applied on each group of tuples.

Query 17: For each project, retrieve the project number, project name,
and the number of employees who work on that project.
SELECT P n um be r , Pn a m e, COUNT (*FROM PROJECT, WORKS ON

WHERE PNUMBER=PNO GROUP BY P n u m b e r , P n a m e ;

In this case, the grouping and functions are applied after the joining of the two relations.

Query 18 : For each project on which more than two employees work,
retrieve the project number, project name, and the number of employees
who work on that project.
SELECT P n u m b e r , P n a m e , C OU N T (* )
FROM PROJECT, WORKS ON WHERE Pn u m ber = Pn o
GR OU P BY P n u m b e r , P n a m e
HAVING C OU N T (*) > 2 ;

Query 19: For each project, retrieve the project number, the project
name and the number of employees from department 5 who work on the
project.

SELECT P n u m b e r , P n a m e , C OU N T (* )
FROM PROJECT, WORKS ON, EMPLOYEE
WHERE P n um be r = Pn o A N D S sn = E s sn A N D Dn o= 5
GROUP BY P n u m b e r , P n a m e ;

Query 20: For each department that has more than 5 employees,
retrieve the department number and the number of employees who are
making a salary more than $40,000.
SELECT Dno, COUNT(*) FROM EMPLOYEE

Dept. of ISE, RNSIT

Page 11
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

WHERE S a l a r y > 4 0 0 0 0 A N D D n o IN(SELECT D n o

FROM EMPLOYEE GROUP BY Dno HAVING COUNT(*)>5)
GROUP BY Dno;

9. SQL Constructs: WITH and CASE

 The WITH clause allows a user to define a table that will only be used in a particular query. This
table will be dropped after its use in that query.
 Queries using WITH can generally be written using other SQL constructs.

Example:
WITH LARGE_DEPTS (Dno) AS (SELECT Dno FROM EMPLOYEE
GROUP BY Dno HAVING COUNT(*) > 5)
SELECT Dno, COUNT(*)
FROM EMPLOYEE
WHERE S a l a r y> 4 00 0 0 AND D no IN LARGE DEPTS
GROUP BY D n o ;

Here a temporary table LARGE_DEPTS is defined using the WITH clause whose result holds the
Dnos of departments with more than 5 employees. This table is then used in the subsequent query.
Once this query is executed the temporary table LARGE_DEPTS is discarded.

 The SQL CASE construct can be used when a value can be different based on certain
conditions.

 It can be used in any part of an SQL query where a value is expected, including when
querying, inserting or updating tuples.

Example: Suppose we want to give employees different raise amounts depending on which department
they work for. Employees in department 5 get a $2000 raise, those in department 4 get $1500
and those in department 1 get $3000. We can write the update operation as:
UPDATE EMPLOYEE
SET Salar y = CASE WHEN D n o = 5 THEN S a l a r y + 2 0 0 0
WHEN D no = 4 THEN S a l a r y + 1500 WHEN D no = 1 THEN S a l a r y
+ 3 0 0 0 ELSE S a l a r y+ 0 ;
Here the salary raise value is determined through the CASE construct based on the
department number for which each employee works.

 The CASE construct can also be used when inserting tuples that can have different attributes
being NULL depending on the type of record being inserted into a table, as when a
specialization is mapped into a single table or when a union type is mapped into a relation.

10. Recursive Queries in SQL

Dept. of ISE, RNSIT

Page 12
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 A recursive query can be written in SQL using WITH RECURSIVE construct. It allows users the
capability to specify a recursive query in a declarative manner.

 A recursive relationship between tuples of the same type is the recursive relationship between an
employee and supervisor. This relationship is described by the foreign key S up r_s sn of the
EMPLOYEE relation.

An example of a recursive operation is to retrieve all supervisees of a supervisor employee

e at all levels — all employees e' directly supervised by e, all employees e' directly supervised by
each employee e' , all employees e" ' directly supervised by each employee e' and so on.

WITH RECURSIVE SUP_EMP ( S u p s sn , E m p ssn ) AS

( SELECT S u p e r s n , S s n FROM EMPLOYEE

UNION S E L E C T E . S s n , S . S u p s s n

FROM E MPL OYE E AS E , S UP E M P AS S

WHEREE . S u p e r s s n = S . E m p s s n ) SELECT *
FROM SUP_EMP;

Here the view SUP_EMP will hold the result of the recursive query. The view is initially empty. It
is first loaded with the first level (Supervisor, supervisee) Ssn combinations through the first
part (SELECT Super ssn, Ssn FROM EMPLOYEE) which is called the base query. This
will be combined via UNION with each successive level of supervisees through the second part,
where the view contents are joined again with the base values to get the second level combinations
which are UNIONed with the first level. This is repeated with successive levels until a fixed pint is
reached where no more tuples are added to the view. At this point the result of the recursive
query is in the view SUP EMP.
Select SQL Statement:
A query in SQL can consist of up to six clauses, but only the first two SELECT and FROM, are
mandatory. The clauses are specified in the following order:

SELECT<attribute list>
FROM<table list>
[WHERE <condition>]
[GROUP BY <grouping attribute(s)>]
[HAVING <group condition>]

[ORDER BY <attribute list>] ;

+ The clauses between square brackets are optional.

Dept. of ISE, RNSIT

Page 13
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 The select clause lists the attributes or functions to be retrieved.

 The FROM clause specifies all the relations or tables needed in the query including joined
relations
but not those in nested queries.
 The WHERE clause specifies the conditions for selection of tuples from these relations including join
conditions if needed.

 GROUP BY specifies grouping attributes whereas HAVING specifies a condition on the groups being
selected rather than on the individual tuples.

 The built in aggregate functions COUNT, SUM, AVG, MIN and MAX are used in conjunction with
grouping but they can also be applied to all the selected tuples in a query without the group by clause.

 :* ORDER BY specifies an order for displaying the result of a query. It is applied at the end to sort

the query result.

 A query is evaluated conceptually by first applying the FROM clause followed by the WHERE
clause and then by the GROUP BY and HAVING.

3.2 SPECIFYING CONSTRAINTS AS ASSERTIONS AND ACTIONS AS TRIGGERS

The CREATE ASSERTION can be used to specify additional types of constraints that are outside the
scope of the built-in relational model constraints (primary and unique keys, entity integrity and referential
integrity). These built-in constraints can be specified in CREATE TABLE statement of SQL. The
CREATE TRIGGER can be used to specify automatic actions that the database systems will perform
when certain events and conditions occur. This type of functionality is referred to as active databases.

1. Specifying General Constraints as Assertions in SQL:

 In SQL, users can specify general constraints via declarative assertions, using the CREATE
ASSERTION statement of the DDL.

 Each assertion is given a constraint name and is specified via a condition similar to the
WHERE clause of an SQL query.

For example, to specify the constraint that "the salary of an employee must not be greater
than the salary of the manager of the department that the employee works for" in SQL, we can
write the following assertion:

CREATE ASSERTION SALARY CONSTRAINT

CHECK (NOT EXISTS(SELECT *
FROM EMPLOYEE E, EMPLOYEE M,
DEPARTMENT D WHERE E.SALARY > M.SALARY AND
E.DNO = D.DNUMBER AND D.MGRSSN = M.SSN));

Dept. of ISE, RNSIT

Page 14
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

The constraint name SALARY_CONSTRAINT is followed by the keyword CHECK which is followed by
a
condition in parentheses that must hold true on every database state for the assertion to be satisfied.
 The constraint name can be used later to refer to the constraint or modify or drop it.

 The DBMS is responsible for ensuring that the condition is not violated.

 Any WHERE clause condition can be used but many constraints can be specified using the
EXISTS and NOT EXISTS style of SQL conditions.

 Whenever some tuples in the database cause the condition in the ASSERTION to evaluate to
FALSE, the constraint is violated. The constraint is satisfied by a database state if no
combination of tuples in that database state violates the constraint.

 To write an assertion, specify a query that selects any tuples that violate the desired condition.
By including this query inside a NOT EXISTS clause, the assertion will specify that the result of
this query must be empty so that the condition will always be TRUE. Thus the assertion is
violated if the result of the query isn't empty.

 The CHECK clauses on attributes, domains and tuples are, checked in SQL only when tuples are
inserted or updated in a specific table. Hence constraint checking can be implemented more
efficiently by DBMS in these cases. The schema designer should use CHECK on attributes,
domains and tuples only when sure that the constraint can only be violated by insertion or updating of
tuples and use CREATE ASSERTION only in cases where it is not possible to use CHECK on
attributes, domains or tuples so that checks are implemented efficiently by DBMS.

2. Trigger in SQL:
 The CREATE TRIGGER statement is used to specify the type of action to be taken
when certain events occur and when certain conditions are satisfied. For e.g., it may be useful to
specify a condition that, if violated, causes some user to be informed of the violation. A manager
may want to be informed if an employee's travel expenses exceed a certain limit by receiving a
message whenever this occurs. The action that the DBMS must take in this case is to send an
appropriate message to that user. The condition is thus used to monitor the database. Other
actions may be specified, such as executing a specific stored procedure or triggering other
updates.
Example: Suppose we want to check whenever an employee's salary is greater than the
salary of his or her direct supervisor in the COMPANY database. Several events can trigger this
rule: inserting a new employee record, changing an employee's salary, or changing an employee's
supervisor. Suppose that the action to take would be to call an external stored procedure
SALARYLVIOLAT ION, which will notify the supervisor. The trigger could then be written as
below.

Dept. of ISE, RNSIT

Page 15
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

CREATE TRIGGER SALARYLVIOLATION

BEFORE INSERT OR UPDATE OF SALARY, SUPERVISOR SSN ON
EMPLOYEE FOR EACH ROW
WHEN (NEW. SALARY > (SELECT SALARY FROM EMPLOYEE
WHERE SSN = NEW.SUPERVISOR SSN))
INFORM SUPERVISOR(NEW.Supervisor ssn, NEW.Ssn );

The trigger is given the name SALARY VIOLATION, which can be used to remove or deactivate
the trigger later.

 A typical trigger which is regarded as an ECA (Event, Condition, Action) rule has three
components:
 The event(s): These are usually database update operations that are explicitly applied to the
database. The person who writes the trigger must make sure that all possible events are accounted
for. In some cases, it may be necessary to write more than> one trigger to cover all possible cases.
These events are specified after the keyword BEFORE, which means that the trigger should be
executed before the triggering operation is executed. An alternative is to use the keyword
AFTER, which specifies that the trigger should be executed after the operation specified in the
event is completed.

1. The condition that determines whether the rule action should be executed: Once the
triggering event has occurred, an optional condition may be evaluated. If no condition is
specified, the action will be executed once the event occurs. If a condition is specified, it is
first evaluated, and only if it evaluates to true will the rule action be executed. The condition is
specified in the WHEN clause of the trigger.

. The action to be taken: The action is usually a sequence of SQL statements, but it could also
be a database transaction or an external program that will be automatically executed. In this
example, the action is to execute the stored procedure INFORM SUPERVISOR.
 Triggers can be used in various applications, such as maintaining database consistency, monitoring
database updates, and updating derived data automatically.
 A trigger specifies an event, a condition and an action. The action is to be executed automatically if
the condition is satisfied when the event occurs.
CREATE TRIGGER <trigger name>
(AFTER/ BEFORE ) <triggering events> ON table
name [FOR EACH ROW ]
[WHEN <condition>]
<trigger actions>
3.3 VIEWS (VIRTUAL TABLES) IN SQL
1. Concept of a View in SQL:

Dept. of ISE, RNSIT

Page 16
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 A view in SQL is a single table that is derived from other tables which could be base tables or
previously defined views.
 • A view does not necessarily exist in physical form; it is considered a virtual table, in contrast to
base tables, whose tuples are always physically stored in the database. This limits the possible
update operations that can be applied to views, but it does not provide any limitations on querying
a view.

 A view is a way of specifying a table that we need to reference frequently, even though it may not
exist physically.
 Queries can be specified on a view which is specified as single table retrievals.

2. Specification of Views in SQL:

 A view is specified by the SQL command CREATE VIEW.
 The view is given a (virtual) table name (or view name), a list of attribute names, and a query
to specify the contents of the view.

 If none of the view attributes results from applying functions or arithmetic operations, attribute
names for the view need not be specified, since they would be the same as the names of the
attributes of the defining tables in the default case.

 The view WORKS ON VIEW does not have new attribute names as it inherits the names of the
view attributes from the defining tables EMPLOYEE, PROJECT and WORKS ON.
CREATE VIEW WORKS ON VIEW
AS SELECT FNAME, LNAME, PNAME, HOURS
FROMEMPLOYEE, PROJECT, WORKS ON
WHERESSN=ESSN AND PNO=PNUMBER;

 The view DEPT INFO explicitly specifies new attribute names using a one to one
correspondence between the attributes specified in the CREATE VIEW clause and those
specified in the SELECT clause of the query that defines the view.

CREATE VIEW DEPT INFO(DEPT NAME, NO OF EMP, TOTAL SAL)

A S SE L E C T DNAME, COUNT(*), SUM(SALARY)
FROM DEPARTMENT, EMPLOYEE
WHERE
DNUMBER=DNO
GROUP BY
DNAME;

 Queries can be specified on views just as specifying queries involving base tables.

Dept. of ISE, RNSIT

Page 17
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

Example: To retrieve the last name and first name of all employees who work on `ProductX'
project.
QV: SELECT Fname, Lname
FROM WORKS ONI
WHERE Pname=' ProductX' ;

 Advantages of view: It simplifies the specification of certain queries. It is also used as a security and
authorization mechanism.

 A view should always be up to date i.e., if we modify the tuples in the base tables on which the
-

view is defined, the view must automatically reflect these changes. Hence a view is not realized at
the time of view definition but when we specify a query on the view.
+ It is the responsibility of the DBMS to ensure that a view is up-to-date and not of the
user to ensure that the view is up-to-date.
 If a view is not needed, it can be removed by DROP VIEW command.
Eg: DROP VIEW WORKS ON VIEW;

3. View Implementation and View Update:

 Two main approaches have been suggested to know how efficiently DBMS implements a view
for efficient querying.
 The strategy of query modification involves modifying or transforming the view query into a
query on the underlying base tables.
Example: The query QV would automatically be modified to the following query by the DBMS.
SELECT FNAME, LNAME
FROM EMPLOUEE, PROJECT, WORKS ON
WHERE SSN=ESSN AND PNO=PNUMBER AND PNAME='ProjectX';

 The disadvantage of this approach is that it is inefficient for views defined via complex queries that
are time consuming to execute, especially if multiple queries are applied to the view within a short
time.

 The other strategy, view materialization involves physically creating a temporary view table when
the view is first queried and keeping that table on the assumption that other queries on the view
will follow. Here, an efficient strategy to automatically update the view when the base tables are
updated must be developed to keep the view up- to- date. Incremental update has been developed to
determine what new tuples must be inserted, deleted or modified in a materialized view table when a
change is applied to one of the defining base tables. The view is generally kept as a materialized
(physically stored) table as long as it is being queried. If the view is not queried for a certain period
of time, the system may then automatically remove the physical table and recomputed from scratch
when future queries reference the view.

Dept. of ISE, RNSIT

Page 18
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

 Different strategies as to when a materialized view is updated are possible.

 immediate update strategy updates a view as soon as the base tables are changed.
 lazy update strategy updates the view when needed by a view query.
 periodic update strategy updates the view periodically (in the latter strategy, a view
query may get a result that is not up-to-date).

+ A retrieval query against any view can always be issued. But issuing an INSERT,
DELETE, or UPDATE command on a view table is in many cases not possible.

 In general, an update on a view defined on a single table without any aggregate functions can be
mapped to an update on the underlying base table under certain conditions.

 For a view involving joins, an update operation may be mapped to update operations on the
underlying base relations in multiple ways. Hence, it is not possible for the DBMS to determine
which of the updates is intended.

 Example: Suppose that we issue the command to update the Pname attribute of 'John Smith'
from ProductX' to 'Productr in the view WORKS_ONVIEW. This view update is shown in
UV1: UV': UPDATE WORKS ON1
SET P n a m e = ' Pr od u c t Y '
WHERE L n a m e = ' S m i t h ' AND F n a m e = ' J o h n ' A N D P n a m e = ' P r o d u c t X ' ;

This query can be mapped into several updates on the base relations to give the desired update effect
on the view. Some of these updates will create additional side effects that affect the result of other
queries. Two possible updates, (a) and (b), on the base relations corresponding to UVI are shown.
Update (a) relates 'John Smith' to the 'ProductY' PROJECT tuple in place of the ' ProductX'
PROJECT tuple and is the most likely desired update.

Dept. of ISE, RNSIT

Page 19
BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

(a) UPDATE WORKS ON

S E T P n o = ( SE L E C T P n u m b e r
FROM PROJECT WHERE P n a m e = ' P r o d u c t Y ' )
WHE R E E s s n I N ( SE L E C T S s n FROM EMPLOYEE
WHE RE L n a m e = ’ S m i t h ' AN D F n a m e = ' J o h n ' )
AND P n o = ( SE L E CT P n u m b e r FROM PROJECT
WH E R E P n a m e = ' P r o d u c t X ' ) ;

(b) UPDATE PRO JECT

SE T P n a m e = ' P r o d u c t Y '
WHER E P n a m e = ' P r o d u c t X ' ;

Update (b) would also give the desired update effect on the view, but it accomplishes this by changing
the name of the ' ProductX' tuple in the PROJECT relation to ' Product Y'. It is quite unlikely that
the user who specified the view update UVI wants the update to be interpreted as in (b), since it also
has the side effect of changing all the view tuples with Pname ' ProductX'.

 Some view updates may not make much sense. For example, modifying the Total_Sal attribute of
the DEPT_INFO view does not make sense because Total Sal is defined to be the sum of the
individual employee salaries. This request is shown as UV2:
UV2: UPDATE DEPT_INFO
SET T o t a l S a l = 1 0 0 0 0 0
WHERE Dn a m e= ' Re s ea r ch ;

 A view update is feasible when only one possible update on the base relations can accomplish the
desired update effect on the view.

 Whenever an update on the view can be mapped to more than one update on the underlying base
relations, it is usually not permitted.

 A view with a single defining table is updatable if the view attributes contain the primary key of the
base relation, as well as all attributes with the NOT NULL constraint that do not have default values
specified.

 Views defined on multiple tables using joins are generally not updatable.
 Views defined using grouping and aggregate functions are not updatable.
 In SQL, the clause WITH CHECK OPTION should be added at the end of the view definition if a
view is to be updated by INSERT, DELETE, or UPDATE statements. This allows the system to reject
operations that violate the SQL rules for view updates.
 It is also possible to define a view table in the FROM clause of an SQL query. This is known as an in-
line view.

Dept. of ISE, RNSIT Page 20

BCS403- SQL: Advanced Queries, Introduction to Transaction Processing Concepts and Theory

4. Views as Authorization Mechanisms:

 Views can be used to hide certain attributes or tuples from unauthorized users.
 Suppose a certain user is only allowed to see employee information for employees who work for
department 5; then we can create the following view DEPTEMP and grant the user the privilege to
query the view but not the base table EMPLOYEE itself. This user will only be able to retrieve
employee information for employee tuples whose Dno = 5, and will not be able to see other employee
tuples when the view is queried.

CREATE VIEW DEPTEMP AS SELECT * FROM EMPLOYEE

WHERE Dn o = 5 ;

A view can restrict a user to only see certain columns; for example, only the first name, last name,
and address of an employee may be visible as follows:

CREATE VIEW BASIC _EMP DATA AS SELECT F n a m e , L n a m e , A d d r e s s FROM

EMPLOYEE;

 By creating an appropriate view and granting certain users access to the view and not the base tables,
they would be restricted to retrieving only the data specified in the view.

Dept. of ISE, RNSIT Page 21