Chapter 6

Query Languages
 The Relational Algebra and Relational Calculus

Relational algebra
Basic set of operations for the relational model
Relational algebra expression
Sequence of relational algebra operations
Relational calculus
Higher-level declarative language for specifying relational queries
 Unary Relational Operations: SELECT and PROJECT

The SELECT Operation

 Subset of the tuples from a relation that satisfies a selection
condition:

• Boolean expression contains clauses of the form <attribute name>

<comparison op> <constant value>
or
• <attribute name> <comparison op> <attribute name>
 Cont’d

Example:

<selection condition> applied independently to each individual

tuple t in R
If condition evaluates to TRUE, tuple selected
Boolean conditions AND, OR, and NOT
Unary
Applied to a single relation
 The PROJECT Operation

 Selects columns from table and discards the other columns:

 Degree
 Number of attributes in <attribute list>
 Duplicate elimination
 Result of PROJECT operation is a set of distinct tuples
 Relational Algebra Operations from Set Theory

 UNION, INTERSECTION, and MINUS

 Merge the elements of two sets in various ways
 Binary operations
 Relations must have the same type of tuples
 UNION
 R∪S
 Includes all tuples that are either in R or in S or in both R and S
 Duplicate tuples eliminated
 Relational Algebra Operationsfrom Set Theory (cont’d.)

 INTERSECTION
 R∩S
 Includes all tuples that are in both R and S
 SET DIFFERENCE (or MINUS)
 R–S
 Includes all tuples that are in R but not in S
 The Cartesian Product (Cross Product) Operation

 CARTESIAN PRODUCT
o CROSS PRODUCT or CROSS JOIN
o Denoted by ×
o Binary set operation
o Relations do not have to be union compatible
o Useful when followed by a selection that matches values of attributes
 Reading Assignment
Binary Relational Operations: JOIN and DIVISION
Tuple Relational Calculus
 SQL
(Structured Query Language)
 Create Table Construct
 An SQL relation is defined using the create table command:
create table r (A1 D1, A2 D2, ..., An Dn,
(integrity-constraint1),
...,
(integrity-constraintk))
 r is the name of the relation
 each Ai is an attribute name in the schema of relation r
 Di is the data type of values in the domain of attribute Ai

 Example:
create table branch ( branch_name char(15) not null,
branch_city char(30),
assets integer )
 Integrity Constraints in Create Table
 not null
 primary key (A1, ..., An )

Example: Declare branch_name as the primary key for branch

.
create table branch
(branch_name char(15),
branch_city char(30),
assets integer,
primary key (branch_name))

primary key declaration on an attribute automatically ensures not null in SQL-92 onwards, needs to be explicitly
stated in SQL-89
 Basic Query Structure
 SQL is based on set and relational operations with certain modifications and enhancements
 A typical SQL query has the form:

select A1, A2, ..., An

from r1, r2, ..., rm
where P

 A represents an attribute
i

 R represents a relation
i
 P is a predicate.
 This query is equivalent to the relational algebra expression.

A1,A2 ,,An ( P (r1 r2  rm ))

 The result of an SQL query is a relation.
 The select Clause
 The select clause list the attributes desired in the result of a query
 corresponds to the projection operation of the relational algebra

 Example: find the names of all branches in the loan relation:

select branch_name from loan

 In the relational algebra, the query would be:

branch_name (loan)
 NOTE: SQL names are case insensitive (i.e., you may use upper- or lower-
case letters.)
 E.g. Branch_Name ≡ BRANCH_NAME ≡ branch_name
 The select Clause (Cont.)
 SQL allows duplicates in relations as well as in query results.
 To force the elimination of duplicates, insert the keyword distinct after
select.
 Find the names of all branches in the loan relations, and remove duplicates

select distinct branch_name from loan

 The keyword all specifies that duplicates not be removed.

select all branch_name from loan

 The select Clause (Cont.)

 An asterisk in the select clause denotes “all attributes”

select * from loan

 The select clause can contain arithmetic expressions involving the operation,
+, –, , and /, and operating on constants or attributes of tuples.
 The query:

select loan_number, branch_name, amount  100 from loan

would return a relation that is the same as the loan relation, except that the
value of the attribute amount is multiplied by 100.
 The where Clause
 The where clause specifies conditions that the result must satisfy
 Corresponds to the selection predicate of the relational algebra.
 To find all loan number for loans made at the XXX branch with loan amounts greater
than $1200.
select loan_number
from loan
where branch_name = ‘XXX' and amount > 1200
 Comparison results can be combined using the logical connectives and, or, and not.
 Comparisons can be applied to results of arithmetic expressions.
 The where Clause (Cont.)

 SQL includes a between comparison operator

 Example: Find the loan number of those loans with loan amounts
between $90,000 and $100,000 (that is, $90,000 and
$100,000)

select loan_number
from loan
where amount between 90000 and 100000
 The from Clause
 The from clause lists the relations involved in the query
 Corresponds to the Cartesian product operation of the relational
algebra.
 Find the Cartesian product borrower X loan

select 
from borrower, loan

 Find the name, loan number and loan amount of all customers
having a loan at the Perryridge branch.
select customer_name, borrower.loan_number, amount
from borrower, loan
where borrower.loan_number = loan.loan_number and
branch_name = 'Perryridge'
 The Rename Operation

 The SQL allows renaming relations and attributes using the as clause:

old-name as new-name
 Find the name, loan number and loan amount of all customers; rename the
column name loan_number as loan_id.

select customer_name, borrower.loan_number as loan_id, amount

from borrower, loan
where borrower.loan_number = loan.loan_number
 Tuple Variables
 Tuple variables are defined in the from clause via the use of the as
clause.
 Find the customer names and their loan numbers for all customers
having a loan at some branch.

select customer_name, T.loan_number, S.amount

from borrower as T, loan as S
where T.loan_number = S.loan_number
 String Operations
 SQL includes a string-matching operator for comparisons on character strings.
The operator “like” uses patterns that are described using two special
characters:
 percent (%). The % character matches any substring.
 underscore (_). The _ character matches any character.
 Find the names of all customers whose street includes the substring “Main”.
select customer_name
from customer
where customer_street like '% Main%'
 SQL supports a variety of string operations such as
 concatenation (using “||”)
 converting from upper to lower case (and vice versa)
 finding string length, extracting substrings, etc.
 Ordering the Display of Tuples

 List in alphabetic order the names of all customers having a loan in Perryridge
branch
select distinct customer_name
from borrower, loan
where borrower.loan_number = loan.loan_number and
branch_name = 'Perryridge'
order by customer_name
 We may specify desc for descending order or asc for ascending order, for each
attribute; ascending order is the default.
 Example: order by customer_name desc
 Set Operations
 Find all customers who have a loan, an account, or both:

(select customer_name from depositor)

union
(select customer_name from borrower)
 Find all customers who have both a loan and an account.
(select customer_name from depositor)
intersect
(select customer_name from borrower)

 Find all customers who have an account but no loan.

(select customer_name from depositor)
except
(select customer_name from borrower)
 Aggregate Functions

 These functions operate on the multiset of values of a column of a

relation, and return a value

avg: average value

min: minimum value
max: maximum value
sum: sum of values
count: number of values
 Aggregate Functions (Cont.)

 Find the average account balance at the Perryridge branch.

select avg (balance)

from account
where branch_name = 'Perryridge'

 Find the number of tuples in the customer relation.

select count (*) from customer

 Find the number of depositors in the bank.

select count (distinct customer_name) from depositor
 Aggregate Functions – Group By

 Find the number of depositors for each branch.

select branch_name, count (distinct customer_name)

from depositor, account
where depositor.account_number = account.account_number
group by branch_name
 Aggregate Functions – Having Clause

 Find the names of all branches where the average account balance is more than
$1,200.

select branch_name, avg (balance)

from account
group by branch_name
having avg (balance) > 1200

Note: predicates in the having clause are applied after the formation of groups
whereas predicates in the where clause are applied before forming groups
 Null Values
 It is possible for tuples to have a null value, denoted by null, for some of their
attributes
 null signifies an unknown value or that a value does not exist.
 The predicate is null can be used to check for null values.
 Example: Find all loan number which appear in the loan relation with null values
for amount.
select loan_number
from loan
where amount is null
 The result of any arithmetic expression involving null is null
 Example: 5 + null returns null
 However, aggregate functions simply ignore nulls
 Null Values and Aggregates

 Total all loan amounts

select sum (amount )

from loan
 Above statement ignores null amounts

 All aggregate operations except count(*) ignore tuples with null values on the
aggregated attributes.
 Nested Subqueries

 SQL provides a mechanism for the nesting of subqueries.

 A subquery is a select-from-where expression that is nested within another
query.
 A common use of subqueries is to perform tests for
 set membership,
 set comparisons, and
 set cardinality.
 Example Query
 Find all customers who have both an account and a loan at the bank.

select distinct customer_name

from borrower
where customer_name in (select customer_name from depositor )

 Find all customers who have a loan at the bank but do not have an account at the
bank

select distinct customer_name

from borrower
where customer_name not in (select customer_name from depositor )
 Views
 In some cases, it is not desirable for all users to see the entire logical model (that is, all the
actual relations stored in the database.)
 Consider a person who needs to know a customer’s name, loan number and branch name,
but has no need to see the loan amount.
 This person should see a relation described, in SQL, by

(select customer_name, borrower.loan_number, branch_name

from borrower, loan
where borrower.loan_number = loan.loan_number )

 A view provides a mechanism to hide certain data from the view of certain users.
 Any relation that is not of the conceptual model but is made visible to a user as a “ virtual
relation” is called a view.
 View Definition

 A view is defined using the create view statement which has the form

create view v as < query expression >

where <query expression> is any legal SQL expression. The view name is
represented by v.
 Once a view is defined, the view name can be used to refer to the virtual relation
that the view generates.
 When a view is created, the query expression is stored in the database; the
expression is substituted into queries using the view.
 Example Queries
 A view consisting of branches and their customers
create view all_customer as
(select branch_name, customer_name
from depositor, account
where depositor.account_number =
account.account_number )
union
(select branch_name, customer_name
from borrower, loan
where borrower.loan_number = loan.loan_number )

 Find all customers of the Perryridge branch

select customer_name
from all_customer
where branch_name = 'Perryridge'
 Modification of the Database – Deletion

 Delete all account tuples at the Perryridge branch

delete from account

where branch_name = 'Perryridge’

 Delete all accounts at every branch located in the city ‘Needham’.

delete from account
where branch_name in (select branch_name
from branch
where branch_city = 'Needham')
 Modification of the Database – Insertion

 Add a new tuple to account

insert into account

values ('A-9732', 'Perryridge', 1200)

or equivalently

insert into account (branch_name, balance, account_number)

values ('Perryridge', 1200, 'A-9732')

 Add a new tuple to account with balance set to null

insert into account

values ('A-777','Perryridge', null )
 Modification of the Database – Updates

 Increase all accounts with balances over $10,000 by 6%, all other accounts
receive 5%.
 Write two update statements:
update account
set balance = balance  0.6
where balance > 10000

update account
set balance = balance  0.5
where balance  10000
 The order is important