Chapter 3: Relational Model

 Structure of Relational Databases

 Relational Algebra
 Tuple Relational Calculus
 Domain Relational Calculus
 Extended Relational-Algebra-Operations
 Modification of the Database
 Views

Database System Concepts 3.1 ©Silberschatz, Korth and Sudarshan

 Basic Structure
3.1.1

 Formally, given sets D1, D2, …. Dn a relation r is a subset of

D1 x D2 x … x Dn
Thus a relation is a set of n-tuples (a1, a2, …, an) where
ai  D i
 Example: if

customer-name = {Jones, Smith, Curry, Lindsay}

customer-street = {Main, North, Park}
customer-city = {Harrison, Rye, Pittsfield}
Then r = { (Jones, Main, Harrison),
(Smith, North, Rye),
(Curry, North, Rye),
(Lindsay, Park, Pittsfield)}
is a relation over customer-name x customer-street x customer-city

Database System Concepts 3.2 ©Silberschatz, Korth and Sudarshan

 Attribute Types
3.1.1

 Each attribute of a relation has a name

 The set of allowed values for each attribute is called the domain
of the attribute
 Attribute values are (normally) required to be atomic, that is,
indivisible
 E.g. multivalued attribute values are not atomic
 E.g. composite attribute values are not atomic
 The special value null is a member of every domain
 The null value causes complications in the definition of many
operations
 we shall ignore the effect of null values in our main presentation
and consider their effect later

Database System Concepts 3.3 ©Silberschatz, Korth and Sudarshan

 Relation Schema
3.1.2

 A1, A2, …, An are attributes

 R = (A1, A2, …, An ) is a relation schema

E.g. Customer-schema =
(customer-name, customer-street, customer-city)
 r(R) is a relation on the relation schema R

E.g. customer (Customer-schema)

Database System Concepts 3.4 ©Silberschatz, Korth and Sudarshan

 Relation Instance
 The current values (relation instance) of a relation are
3.1.2

specified by a table
 An element t of r is a tuple, represented by a row in a table
attributes

customer-name customer-street customer-city

Jones Main Harrison

Smith North Rye tuples
Curry North Rye
Lindsay Park Pittsfield

customer

Relations are Unordered

 Order of tuples is irrelevant (tuples may be stored in an arbitrary order)
 E.g. account relation with unordered tuples

Database System Concepts 3.5 ©Silberschatz, Korth and Sudarshan

 Database
 A database consists of multiple relations
3.1.2

 Information about an enterprise is broken up into parts, with

each relation storing one part of the information

E.g.: account : stores information about accounts

depositor : stores information about which customer
owns which account
customer : stores information about customers
 Storing all information as a single relation such as
bank(account-number, balance, customer-name, ..)
results in
 repetition of information (e.g. two customers own an account)
 the need for null values (e.g. represent a customer without an
account)
 Normalization theory (Chapter 7) deals with how to design
relational schemas

Database System Concepts 3.6 ©Silberschatz, Korth and Sudarshan

 E-R Diagram for the Banking Enterprise
3.1.2

Database System Concepts 3.7 ©Silberschatz, Korth and Sudarshan

 Schema Diagram for the Banking Enterprise
3.1.4

Database System Concepts 3.8 ©Silberschatz, Korth and Sudarshan

 Instance of the banking schema
Account
3.1.2

Customer

Depositor

Database System Concepts 3.9 ©Silberschatz, Korth and Sudarshan

 Instance of the banking schema
Loan
3.1.2

Branch

Borrower

Database System Concepts 3.10 ©Silberschatz, Korth and Sudarshan

 Keys
3.1.3

 Let K  R
 K is a superkey of R if values for K are sufficient to identify a
unique tuple of each possible relation r(R) by “possible r” we
mean a relation r that could exist in the enterprise we are
modeling.
Example: {customer-name, customer-street} and
{customer-name}
are both superkeys of Customer, if no two customers can
possibly have the same name.
 K is a candidate key if K is minimal
Example: {customer-name} is a candidate key for Customer,
since it is a superkey {assuming no two customers can possibly
have the same name), and no subset of it is a superkey.

Database System Concepts 3.11 ©Silberschatz, Korth and Sudarshan

 Determining Keys from E-R Sets
3.1.3

 Strong entity set. The primary key of the entity set becomes
the primary key of the relation.
 Weak entity set. The primary key of the relation consists of the
union of the primary key of the strong entity set and the
discriminator of the weak entity set.
 Relationship set. The union of the primary keys of the related
entity sets becomes a super key of the relation.
 For binary many-to-one relationship sets, the primary key of the
“many” entity set becomes the relation’s primary key.
 For one-to-one relationship sets, the relation’s primary key can be
that of either entity set.
 For many-to-many relationship sets, the union of the primary keys
becomes the relation’s primary key
 Multivalued Attributes: The primary key of the entity or relationship set
together with the multivalued attribute column becomes the primary key.

Database System Concepts 3.12 ©Silberschatz, Korth and Sudarshan

 Query Languages
3.1.5

 Language in which user requests information from the database.

 Categories of languages
 procedural
 non-procedural
 “Pure” languages:
 Relational Algebra
 Tuple Relational Calculus
 Domain Relational Calculus
 Pure languages form underlying basis of query languages that
people use.

Database System Concepts 3.13 ©Silberschatz, Korth and Sudarshan

 Relational Algebra
 Procedural language
3.2

 Six basic operators

 select
 project
 union
 set difference
 Cartesian product
 rename
 The operators take two or more relations as inputs and give a
new relation as a result.

Database System Concepts 3.14 ©Silberschatz, Korth and Sudarshan

 Select Operation – Example
3.2.1

• Relation r A B C D A=B ^ D > 5 (r)

A B C D
  1 7
  5 7   1 7
  12 3   23 10
  23 10

Loan
 branch-name = “Perryridge” (loan)

Database System Concepts 3.15 ©Silberschatz, Korth and Sudarshan

 Select Operation
3.2.1.1

 Notation:  p(r)
 p is called the selection predicate
 Defined as:

p(r) = {t | t  r and p(t)}

Where p is a formula in propositional calculus consisting
of terms connected by :  (and),  (or),  (not)
Each term is one of:
<attribute> op <attribute> or <constant>
where op is one of: =, , >, . <. 
 Example of selection:
 branch-name=“Perryridge”(account)

Database System Concepts 3.16 ©Silberschatz, Korth and Sudarshan

 Project Operation – Example
 Relation r:
3.2.1.2

A B C  A,C (r) A C A C

 10 1  1  1
 20 1  1 =  1
 30 1  1  2
 40 2  2

Loan loan-number, amount (loan)

Database System Concepts 3.17 ©Silberschatz, Korth and Sudarshan

 Project Operation
3.2.1.2

 Notation:

A1, A2, …, Ak (r)

where A1, A2 are attribute names and r is a relation name.
 The result is defined as the relation of k columns obtained by
erasing the columns that are not listed
 Duplicate rows removed from result, since relations are sets
 E.g. To eliminate the branch-name attribute of account
account-number, balance (account)

Database System Concepts 3.18 ©Silberschatz, Korth and Sudarshan

 Union Operation – Example
3.2.1.4

 Relations r, s:
A B A B

 1  2
 2  3
 1 s
r

r  s: A B

 1
 2
 1
 3

Database System Concepts 3.19 ©Silberschatz, Korth and Sudarshan

 Union Operation
3.2.1.4

 Notation: r  s
 Defined as:

r  s = {t | t  r or t  s}

 For r  s to be valid.

1. r, s must have the same arity (same number of attributes)

2. The attribute domains must be compatible (e.g., 2nd column
of r deals with the same type of values as does the 2nd
column of s)
 E.g. to find all customers with either an account or a loan
customer-name (depositor)  customer-name (borrower)

Database System Concepts 3.20 ©Silberschatz, Korth and Sudarshan

 Set Difference Operation – Example
3.2.1.5

 Relations r, s:
A B A B

 1  2
 2  3
 1 s
r

r – s: A B

 1
 1

Database System Concepts 3.21 ©Silberschatz, Korth and Sudarshan

 Set Difference Operation
3.2.1.5

 Notation r – s
 Defined as:

r – s = {t | t  r and t  s}
 Set differences must be taken between compatible relations.
 r and s must have the same arity
 attribute domains of r and s must be compatible

Database System Concepts 3.22 ©Silberschatz, Korth and Sudarshan

 Cartesian-Product Operation-Example
3.2.1.6

Relations r, s: A B C D E

 1  10 a
 10 a
 2  20 b
r  10 b
s
r x s:
A B C D E
 1  10 a
 1  19 a
 1  20 b
 1  10 b
 2  10 a
 2  10 a
 2  20 b
 2  10 b

Database System Concepts 3.23 ©Silberschatz, Korth and Sudarshan

 Cartesian-Product Operation
3.2.1.6

 Notation r x s
 Defined as:

r x s = {t q | t  r and q  s}
 Assume that attributes of r(R) and s(S) are disjoint. (That is,
R  S = ).
 If attributes of r(R) and s(S) are not disjoint, then renaming must
be used.

Database System Concepts 3.24 ©Silberschatz, Korth and Sudarshan

 Result of borrower  loan
3.2.1.6

Database System Concepts 3.25 ©Silberschatz, Korth and Sudarshan

 Result of  branch-name = “Perryridge” (borrower  loan)
3.2.1.6

Database System Concepts 3.26 ©Silberschatz, Korth and Sudarshan

 Composition of Operations
3.2.1.3

 Can build expressions using multiple operations

 Example: A=C(r x s)
 rxs A B C D E
 1  10 a
 1  19 a
 1  20 b
 1  10 b
 2  10 a
 2  10 a
 2  20 b
 2  10 b

 A=C(r x s)
A B C D E

 1  10 a
 2  20 a
 2  20 b
Database System Concepts 3.27 ©Silberschatz, Korth and Sudarshan
 Rename Operation
3.2.1.7

 Allows us to name, and therefore to refer to, the results of

relational-algebra expressions.
 Allows us to refer to a relation by more than one name.

Example:
 x (E)
returns the expression E under the name X
If a relational-algebra expression E has arity n, then
x (A1, A2, …, An) (E)
returns the result of expression E under the name X, and with the
attributes renamed to A1, A2, …., An.

Database System Concepts 3.28 ©Silberschatz, Korth and Sudarshan

 Banking Example

branch (branch-name, branch-city, assets)

customer (customer-name, customer-street, customer-only)

account (account-number, branch-name, balance)

loan (loan-number, branch-name, amount)

depositor (customer-name, account-number)

borrower (customer-name, loan-number)

Database System Concepts 3.29 ©Silberschatz, Korth and Sudarshan

 Example Queries

 Find all loans of over $1200

amount > 1200 (loan)

 Find the loan number for each loan of an amount greater than
$1200
loan-number (amount > 1200 (loan))

Database System Concepts 3.30 ©Silberschatz, Korth and Sudarshan

 Example Queries

 Find the names of all customers who have a loan, an account, or

both, from the bank
customer-name (borrower)  customer-name (depositor)
 Find the names of all customers who have a loan and an
account at bank.
customer-name (borrower)  customer-name (depositor)

Database System Concepts 3.31 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers who have a loan at the Perryridge
branch.

customer-name (branch-name=“Perryridge”
(borrower.loan-number = loan.loan-number(borrower x loan)))
 Find the names of all customers who have a loan at the Perryridge
branch but do not have an account at any branch of the bank.

customer-name (branch-name = “Perryridge”

(borrower.loan-number = loan.loan-number(borrower x loan)))

– customer-name(depositor)

Database System Concepts 3.32 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers who have a loan at the Perryridge
branch.
 Query 1
customer-name(branch-name = “Perryridge”
(borrower.loan-number = loan.loan-number(borrower x loan)))
 Query 2
customer-name(loan.loan-number = borrower.loan-number(
(branch-name = “Perryridge”(loan)) x
borrower)
)

Database System Concepts 3.33 ©Silberschatz, Korth and Sudarshan

 Example Queries
Find the largest account balance
 Rename account relation as d
 The query is:

balance(account) - account.balance
(account.balance < d.balance (account x d (account)))

Database System Concepts 3.34 ©Silberschatz, Korth and Sudarshan

 Formal Definition of Relational Algebra
 A basic expression in the relational algebra consists of either
3.2.2

one of the following:

 A relation in the database
 A constant relation
 Let E and E be relational-algebra expressions; the following are
1 2
all relational-algebra expressions:
 E1  E 2
 E1 - E2
 E1 x E2
 p (E1), P is a predicate on attributes in E1
 s(E1), S is a list consisting of some of the attributes in E1
  x (E1), x is the new name for the result of E1

Database System Concepts 3.35 ©Silberschatz, Korth and Sudarshan

 Additional Operations
3.2.3

We define additional operations that do not add any power to the

relational algebra, but that simplify common queries.

 Set intersection
 Natural join
 Division
 Assignment

Database System Concepts 3.36 ©Silberschatz, Korth and Sudarshan

 Set-Intersection Operation
3.2.3.1

 Notation: r  s
 Defined as:
 r  s ={ t | t  r and t  s }
 Assume:
 r, s have the same arity
 attributes of r and s are compatible
 Note: r  s = r - (r - s)

Database System Concepts 3.37 ©Silberschatz, Korth and Sudarshan

 Set-Intersection Operation - Example
3.2.3.1

 Relation r, s:
A B A B
 1  2
 2  3
 1

r s
 rs
A B

 2

Database System Concepts 3.38 ©Silberschatz, Korth and Sudarshan

 Natural-Join Operation

3.2.3.2

Notation: r s
 Let r and s be relations on schemas R and S respectively.The result is a
relation on schema R  S which is obtained by considering each pair of
tuples tr from r and ts from s.
 If tr and ts have the same value on each of the attributes in R  S, a tuple t
is added to the result, where
 t has the same value as t on r
r
 t has the same value as t on s
s
 Example:
R = (A, B, C, D)
S = (E, B, D)
 Result schema = (A, B, C, D, E)
 r s is defined as:
r.A, r.B, r.C, r.D, s.E (r.B = s.B r.D = s.D (r x s))

Database System Concepts 3.39 ©Silberschatz, Korth and Sudarshan

 Natural Join Operation – Example
3.2.3.2

 Relations r, s:

A B C D B D E

 1  a 1 a 
 2  a 3 a 
 4  b 1 a 
 1  a 2 b 
 2  b 3 b 
r s

r s A B C D E
 1  a 
 1  a 
 1  a 
 1  a 
 2  b 

Database System Concepts 3.40 ©Silberschatz, Korth and Sudarshan

 Division Operation
3.2.3.3

rs
 Suited to queries that include the phrase “for all”.
 Let r and s be relations on schemas R and S respectively
where
 R = (A1, …, Am, B1, …, Bn)
 S = (B1, …, Bn)
The result of r  s is a relation on schema
R – S = (A1, …, Am)

r  s = { t | t   R-S(r)   u  s ( tu  r ) }

Database System Concepts 3.41 ©Silberschatz, Korth and Sudarshan

 Division Operation – Example
3.2.3.3

Relations r, s: A B
B
 1
1
 2
 3 2
 1 s
 1
 1
 3
 4
 6
 1
 2
r  s: A r




Database System Concepts 3.42 ©Silberschatz, Korth and Sudarshan

 Another Division Example
3.2.3.3

Relations r, s:
A B C D E D E

 a  a 1 a 1
 a  a 1 b 1
 a  b 1 s
 a  a 1
 a  b 3
 a  a 1
 a  b 1
 a  b 1
r

r  s: A B C

 a 
 a 

Database System Concepts 3.43 ©Silberschatz, Korth and Sudarshan

 Division Operation (Cont.)
3.2.3.3

 Property
 Let q – r  s
 Then q is the largest relation satisfying q x s  r
 Definition in terms of the basic algebra operation
Let r(R) and s(S) be relations, and let S  R

r  s = R-S (r) –R-S ( (R-S (r) x s) – R-S,S(r))

To see why
 R-S,S(r) simply reorders attributes of r

 R-S(R-S (r) x s) – R-S,S(r)) gives those tuples t in

R-S (r) such that for some tuple u  s, tu  r.

Database System Concepts 3.44 ©Silberschatz, Korth and Sudarshan

 Division Operation – Example
3.2.3.3

A B
A B A B
 2
 1  1  3
 2  2
 3 A (R-S(r) X s) - R-S,S(r)
 1
 1  2
 1 B   1
 1   2 A
 3 1   1
 2   2 
2 
r s R-S(r) R-S(r) X s R-S((R-S(r) X s) - R-S,S(r))

R-S,S(r) A


r  s = R-S (r) –R-S ( (R-S (r) x s) – R-S,S(r))

Database System Concepts 3.45 ©Silberschatz, Korth and Sudarshan
 Assignment Operation

3.2.3.4

The assignment operation () provides a convenient way to

express complex queries, write query as a sequential program
consisting of a series of assignments followed by an expression
whose value is displayed as a result of the query.
 Assignment must always be made to a temporary relation
variable.
 Example: Write r  s as

temp1  R-S (r)

temp2  R-S ((temp1 x s) – R-S,S (r))
result = temp1 – temp2
 The result to the right of the  is assigned to the relation variable on
the left of the .
 May use variable in subsequent expressions.

Database System Concepts 3.46 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find all customers who have an account from at least the
“Downtown” and the “Uptown” branches.
 Query 1

CN(BN=“Downtown”(depositor account)) 

CN(BN=“Uptown”(depositor account))

where CN denotes customer-name and BN denotes

branch-name.
 Query 2
customer-name, branch-name (depositor account)
 temp(branch-name) ({(“Downtown”), (“Uptown”)})

Database System Concepts 3.47 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find all customers who have an account at all branches located
in Brooklyn city.

customer-name, branch-name (depositor account)

 branch-name (branch-city = “Brooklyn” (branch))

Database System Concepts 3.48 ©Silberschatz, Korth and Sudarshan

 Extended Relational-Algebra-Operations
3.3

 Generalized Projection
 Outer Join
 Aggregate Functions

Database System Concepts 3.49 ©Silberschatz, Korth and Sudarshan

 Generalized Projection
 Extends the projection operation by allowing arithmetic functions
3.3.1

to be used in the projection list.

 F1, F2, …, Fn(E)

 E is any relational-algebra expression
 Each of F1, F2, …, Fn are are arithmetic expressions involving
constants and attributes in the schema of E.
 Given relation credit-info(customer-name, limit, credit-balance),
find how much more each person can spend:
customer-name, limit – credit-balance (credit-info)

Database System Concepts 3.50 ©Silberschatz, Korth and Sudarshan

 Aggregate Functions and Operations
 Aggregation function takes a collection of values and returns a
3.3.2

single value as a result.

avg: average value
min: minimum value
max: maximum value
sum: sum of values
count: number of values
 Aggregate operation in relational algebra

G1, G2, …, Gn g F1( A1), F2( A2),…, Fn( An) (E)

 E is any relational-algebra expression
 G1, G2 …, Gn is a list of attributes on which to group (can be empty)
 Each Fi is an aggregate function
 Each Ai is an attribute name

Database System Concepts 3.51 ©Silberschatz, Korth and Sudarshan

 Aggregate Operation – Example
 Relation r:
3.3.2

A B C

  7
  7
  3
  10

sum-C
g sum(c) (r)
27

Database System Concepts 3.52 ©Silberschatz, Korth and Sudarshan

 Aggregate Operation – Example
3.3.2

 Relation account grouped by branch-name:

branch-name account-number balance

Perryridge A-102 400
Perryridge A-201 900
Brighton A-217 750
Brighton A-215 750
Redwood A-222 700

branch-name g sum(balance) (account)

branch-name balance
Perryridge 1300
Brighton 1500
Redwood 700

Database System Concepts 3.53 ©Silberschatz, Korth and Sudarshan

 Aggregate Functions (Cont.)
 Result of aggregation does not have a name
3.3.2

 Can use rename operation to give it a name

 For convenience, we permit renaming as part of aggregate
operation

branch-name g sum(balance) as sum-balance (account)

Database System Concepts 3.54 ©Silberschatz, Korth and Sudarshan

 Outer Join
 An extension of the join operation that avoids loss of information.
3.3.3

 Computes the join and then adds tuples form one relation that
does not match tuples in the other relation to the result of the
join.
 Uses null values:
 null signifies that the value is unknown or does not exist
 All comparisons involving null are (roughly speaking) false by
definition.
 Will study precise meaning of comparisons with nulls later

Database System Concepts 3.55 ©Silberschatz, Korth and Sudarshan

 Outer Join – Example
loan-number branch-name amount customer-name loan-number
3.3.3

L-170 Downtown 3000 Jones L-170

L-230 Redwood 4000 Smith L-230
L-260 Perryridge 1700 Hayes L-155
 Inner Join loan Borrower

loan Borrower

loan-number branch-name amount customer-name

L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith

 Left Outer Join

loan borrower
loan-number branch-name amount customer-name
L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-260 Perryridge 1700 null
Database System Concepts 3.56 ©Silberschatz, Korth and Sudarshan
 Outer Join – Example
loan-number branch-name amount customer-name loan-number
3.3.3

L-170 Downtown 3000 Jones L-170

L-230 Redwood 4000 Smith L-230
L-260 Perryridge 1700 Hayes L-155
 Right Outer Join
loan borrower
loan Borrower

loan-number branch-name amount customer-name

L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-155 null null Hayes
 Full Outer Join
loan borrower
loan-number branch-name amount customer-name
L-170 Downtown 3000 Jones
L-230 Redwood 4000 Smith
L-260 Perryridge 1700 null
L-155 null null Hayes
Database System Concepts 3.57 ©Silberschatz, Korth and Sudarshan
 Null Values
 It is possible for tuples to have a null value, denoted by null, for
3.3.4

some of their attributes

 null signifies an unknown value or that a value does not exist.
 The result of any arithmetic expression involving null is null.
 Aggregate functions simply ignore null values
 Is an arbitrary decision. Could have returned null as result instead.
 We follow the semantics of SQL in its handling of null values
 For duplicate elimination and grouping, null is treated like any
other value, and two nulls are assumed to be the same
 Alternative: assume each null is different from each other
 Both are arbitrary decisions, so we simply follow SQL

Database System Concepts 3.58 ©Silberschatz, Korth and Sudarshan

 Null Values
 Comparisons with null values return the special truth value
3.3.4

unknown
 If false was used instead of unknown, then not (A < 5)
would not be equivalent to A >= 5
 Three-valued logic using the truth value unknown:
 OR: (unknown or true) = true,
(unknown or false) = unknown
(unknown or unknown) = unknown
 AND: (true and unknown) = unknown,
(false and unknown) = false,
(unknown and unknown) = unknown
 NOT: (not unknown) = unknown
 In SQL “P is unknown” evaluates to true if predicate P evaluates
to unknown
 Result of select predicate is treated as false if it evaluates to
unknown

Database System Concepts 3.59 ©Silberschatz, Korth and Sudarshan

 Modification of the Database
 The content of the database may be modified using the following
3.4

operations:
 Deletion
 Insertion
 Updating
 All these operations are expressed using the assignment
operator.

Database System Concepts 3.60 ©Silberschatz, Korth and Sudarshan

 Deletion
 A delete request is expressed similarly to a query, except
3.4.1

instead of displaying tuples to the user, the selected tuples are

removed from the database.
 Can delete only whole tuples; cannot delete values on only
particular attributes
 A deletion is expressed in relational algebra by:

rr–E
where r is a relation and E is a relational algebra query.

Database System Concepts 3.61 ©Silberschatz, Korth and Sudarshan

 Deletion Examples
3.4.1

 Delete all account records in the Perryridge branch.

account  account – branch-name = “Perryridge” (account)
 Delete all loan records with amount in the range of 0 to 50
loan  loan – amount 0and amount  50 (loan)
 Delete all accounts at branches located in Needham.
r1  branch-city = “Needham” (account branch)
r2  branch-name, account-number, balance (r1)

r3   customer-name, account-number (r2 depositor)

account  account – r2
depositor  depositor – r3

Database System Concepts 3.62 ©Silberschatz, Korth and Sudarshan

 Insertion
 To insert data into a relation, we either:
3.4.2

 specify a tuple to be inserted

 write a query whose result is a set of tuples to be inserted
 in relational algebra, an insertion is expressed by:

r r  E
where r is a relation and E is a relational algebra expression.
 The insertion of a single tuple is expressed by letting E be a
constant relation containing one tuple.

Database System Concepts 3.63 ©Silberschatz, Korth and Sudarshan

 Insertion Examples
 Insert information in the database specifying that Smith has
3.4.2

$1200 in account A-973 at the Perryridge branch.

account  account  {(“Perryridge”, A-973, 1200)}
depositor  depositor  {(“Smith”, A-973)}

 Provide as a gift for all loan customers in the Perryridge branch,

a $200 savings account. Let the loan number serve as the
account number for the new savings account.
r1  (branch-name = “Perryridge” (borrower loan))
account  account  branch-name, account-number,200 (r1)
depositor  depositor  customer-name, loan-number,(r1)

Database System Concepts 3.64 ©Silberschatz, Korth and Sudarshan

 Updating
 A mechanism to change a value in a tuple without charging all
3.4.3

values in the tuple

 Use the generalized projection operator to do this task

r   F1, F2, …, FI, (r)

 Each F, is either the ith attribute of r, if the ith attribute is not
updated, or, if the attribute is to be updated
 Fi is an expression, involving only constants and the attributes of
r, which gives the new value for the attribute

Database System Concepts 3.65 ©Silberschatz, Korth and Sudarshan

 Update Examples
 Make interest payments by increasing all balances by 5 percent.
3.4.3

account   AN, BN, BAL * 1.05 (account)

where AN, BN and BAL stand for account-number, branch-name
and balance, respectively.
 Pay all accounts with balances over $10,000
6 percent interest and pay all others 5 percent

account   AN, BN, BAL * 1.06 ( BAL  10000 (account))

 AN, BN, BAL * 1.05 (BAL  10000 (account))

Database System Concepts 3.66 ©Silberschatz, Korth and Sudarshan

 Views
 In some cases, it is not desirable for all users to see the entire
3.5

logical model (i.e., all the actual relations stored in the

database.)
 Consider a person who needs to know a customer’s loan
number but has no need to see the loan amount. This person
should see a relation described, in the relational algebra, by
customer-name, loan-number (borrower loan)
 Any relation that is not of the conceptual model but is made
visible to a user as a “virtual relation” is called a view.

Database System Concepts 3.67 ©Silberschatz, Korth and Sudarshan

 View Definition
 A view is defined using the create view statement which has the
3.5.1

form

create view v as <query expression>

where <query expression> is any legal relational algebra query

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.
 View definition is not the same as creating a new relation by
evaluating the query expression Rather, a view definition
causes the saving of an expression to be substituted into queries
using the view.

Database System Concepts 3.68 ©Silberschatz, Korth and Sudarshan

 View Examples
 Consider the view (named all-customer) consisting of branches
3.5.1

and their customers.

create view all-customer as
branch-name, customer-name (depositor account)
 branch-name, customer-name (borrower loan)

 We can find all customers of the Perryridge branch by writing:

branch-name
(branch-name = “Perryridge” (all-customer))

Database System Concepts 3.69 ©Silberschatz, Korth and Sudarshan

 Updates Through View
 Database modifications expressed as views must be translated
3.5.2

to modifications of the actual relations in the database.

 Consider the person who needs to see all loan data in the loan
relation except amount. The view given to the person, branch-
loan, is defined as:
create view branch-loan as
branch-name, loan-number (loan)
 Since we allow a view name to appear wherever a relation name
is allowed, the person may write:

branch-loan  branch-loan  {(“Perryridge”, L-37)}

Database System Concepts 3.70 ©Silberschatz, Korth and Sudarshan

 Updates Through Views (Cont.)
 The previous insertion must be represented by an insertion into
3.5.2

the actual relation loan from which the view branch-loan is

constructed.
 An insertion into loan requires a value for amount. The insertion
can be dealt with by either.
 rejecting the insertion and returning an error message to the user.
 inserting a tuple (“L-37”, “Perryridge”, null) into the loan relation
 Some updates through views are impossible to translate into
database relation updates
 create view v as 
branch-name = “Perryridge” (account))
v  v  (L-99, Downtown, 23)
 Others cannot be translated uniquely
 all-customer  all-customer  (Perryridge, John)
 Have to choose loan or account, and
create a new loan/account number!

Database System Concepts 3.71 ©Silberschatz, Korth and Sudarshan

 Views Defined Using Other Views
 One view may be used in the expression defining another view
3.5.3

 A view relation v1 is said to depend directly on a view relation v2

if v2 is used in the expression defining v1
 A view relation v1 is said to depend on view relation v2 if either v1
depends directly to v2 or there is a path of dependencies from
v1 to v2
 A view relation v is said to be recursive if it depends on itself.

Database System Concepts 3.72 ©Silberschatz, Korth and Sudarshan

 View Expansion
 A way to define the meaning of views defined in terms of other
3.5.3

views.
 Let view v1 be defined by an expression e1 that may itself contain
uses of view relations.
 View expansion of an expression repeats the following
replacement step:
repeat
Find any view relation vi in e1
Replace the view relation vi by the expression defining vi
until no more view relations are present in e1
 As long as the view definitions are not recursive, this loop will
terminate

Database System Concepts 3.73 ©Silberschatz, Korth and Sudarshan

 Tuple Relational Calculus
 A nonprocedural query language, where each query is of the form
3.6

{t | P (t) }
 It is the set of all tuples t such that predicate P is true for t
 t is a tuple variable, t[A] denotes the value of tuple t on attribute A
 t  r denotes that tuple t is in relation r
 P is a formula similar to that of the predicate calculus
 A tuple variable is said to be a free variable unless it is quantified
by a  or .

Database System Concepts 3.74 ©Silberschatz, Korth and Sudarshan

 Predicate Calculus Formula
1. Set of attributes and constants
3.6

2. Set of comparison operators: (e.g., , , , , , )

3. Set of connectives: and (), or (v)‚ not ()
4. Implication (): x  y, if x if true, then y is true
x  y x v y
5. Set of quantifiers:
 t r (Q(t)) ”there exists” a tuple in t in relation r
such that predicate Q(t) is true
 t r (Q(t)) Q is true “for all” tuples t in relation r

Database System Concepts 3.75 ©Silberschatz, Korth and Sudarshan

 Formal Definition
 A tuple-relational-calculus formula is built up out of atom.
3.6.2

 An atom has one or the following form

 s  r, where s is a tuple variable and r is a relation.
 s[x]  u[y], where s and u are tuple variables, x and y are attributes
on which s and u are defined respectively.  is a comparison
operator ( <, , =,  ,  , > )
 s[x]  c, where c is a constant and rest are same as above.
 We build up formulae from atoms by using following rules:
 An atom is a formula
 If P1 is a formula, then so are  P1 and (P1).
 If P1 and P2 are formulae, Then so are P1  P2 , P1  P2 , P1  P2
 If P1(s) is a formula containing a free tuple variable s and r is a
relation, then
 s r (P1(s)) and  s r (P1(s))
are also formulae.

Database System Concepts 3.76 ©Silberschatz, Korth and Sudarshan

 Banking Example
 branch (branch-name, branch-city, assets)
 customer (customer-name, customer-street, customer-city)
 account (account-number, branch-name, balance)
 loan (loan-number, branch-name, amount)
 depositor (customer-name, account-number)
 borrower (customer-name, loan-number)

Database System Concepts 3.77 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the loan-number, branch-name, and amount for loans of
3.6.1

over $1200
{t | t  loan  t [amount]  1200}

 Find the loan number for each loan of an amount greater than
$1200
{t |  s loan (t[loan-number] = s[loan-number]
 s [amount]  1200}

Notice that a relation on schema [customer-name] is implicitly

defined by the query

Database System Concepts 3.78 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers having a loan, an account, or
3.6.1

both at the bank

{t | s  borrower(t[customer-name] = s[customer-name])
 u  depositor(t[customer-name] = u[customer-name])

 Find the names of all customers who have a loan and an

account at the bank

{t | s  borrower(t[customer-name] = s[customer-name])
 u  depositor(t[customer-name] = u[customer-name])

Database System Concepts 3.79 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers having a loan at the Perryridge
3.6.1

branch
{t | s  borrower(t[customer-name] = s[customer-name]
 u  loan(u[branch-name] = “Perryridge”
 u[loan-number] = s[loan-number]))}

 Find the names of all customers who have a loan at the

Perryridge branch, but no account at any branch of the bank
{t | s  borrower(t[customer-name] = s[customer-name]
 u  loan(u[branch-name] = “Perryridge”
 u[loan-number] = s[loan-number]))
 not v  depositor (v[customer-name] =
t[customer-name]) }

Database System Concepts 3.80 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers having a loan from the
3.6.1

Perryridge branch, and the cities they live in

{t | s  loan(s[branch-name] = “Perryridge”
 u  borrower (u[loan-number] = s[loan-number]
 t [customer-name] = u[customer-name])
  v  customer (u[customer-name] = v[customer-name]
 t[customer-city] = v[customer-
city])))}

Database System Concepts 3.81 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers who have an account at all
3.6.1

branches located in Brooklyn:

{t |  c  customer (t[customer.name] = c[customer-name]) 

 s  branch(s[branch-city] = “Brooklyn” 
 u  account ( s[branch-name] = u[branch-name]
  v  depositor ( t[customer-name] = v[customer-name]
 v[account-number] = u[account-number] )) )}

Database System Concepts 3.82 ©Silberschatz, Korth and Sudarshan

 Safety of Expressions
 It is possible to write tuple calculus expressions that generate
3.6.3

infinite relations.
 For example, {t |  t r} results in an infinite relation if the
domain of any attribute of relation r is infinite
 To guard against the problem, we restrict the set of allowable
expressions to safe expressions.
 An expression {t | P(t)} in the tuple relational calculus is safe if
every component of t appears in one of the relations, tuples, or
constants that appear in P

Database System Concepts 3.83 ©Silberschatz, Korth and Sudarshan

 Domain Relational Calculus
 A nonprocedural query language equivalent in power to the tuple
3.7.1

relational calculus
 Each query is an expression of the form:

{  x1, x2, …, xn  | P(x1, x2, …, xn)}

 x1, x2, …, xn represent domain variables

 P represents a formula similar to that of the predicate calculus

Database System Concepts 3.84 ©Silberschatz, Korth and Sudarshan

 Formal Definition
 An atom has one or the following form
3.7.1

 <x1, x2, …, xn>  r, where r is a relation on n attributes and are x1,

x2, …, xn domain variables or domain constants.
 x  y, where x and y are domain variables and  is a comparison
operator ( <, , =,  ,  , > )
 x  c, where c is a constant and rest are same as above.
 We build up formulae from atoms by using following rules:
 An atom is a formula
 If P1 is a formula, then so are  P1 and (P1).
 If P1 and P2 are formulae, Then so are P1  P2 , P1  P2 , P1  P2
 If P1(s) is a formula containing a free tuple variable s and r is a
relation, then
 x (P1(x)) and x (P1(x))
are also formulae.

Database System Concepts 3.85 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the branch-name, loan-number, and amount for loans of over
3.7.2

$1200

{ l, b, a  |  l, b, a   loan  a > 1200}

 Find the names of all customers who have a loan of over $1200

{ c  |  l, b, a ( c, l   borrower   l, b, a   loan  a > 1200)}

 Find the names of all customers who have a loan from the
Perryridge branch and the loan amount:

{ c, a  |  l ( c, l   borrower  b( l, b, a   loan 

b = “Perryridge”))}
or { c, a  |  l ( c, l   borrower   l, “Perryridge”, a   loan)}

Database System Concepts 3.86 ©Silberschatz, Korth and Sudarshan

 Example Queries
 Find the names of all customers having a loan, an account, or
3.7.2

both at the Perryridge branch:

{ c  |  l ({ c, l   borrower
  b,a( l, b, a   loan  b = “Perryridge”))
  a( c, a   depositor
  b,n( a, b, n   account  b = “Perryridge”))}

 Find the names of all customers who have an account at all

branches located in Brooklyn:
{ c  |  n ( c, s, n   customer) 
 x,y,z( x, y, z   branch  y = “Brooklyn”) 
 a,b( a, b, z   account   c,a   depositor)}

Database System Concepts 3.87 ©Silberschatz, Korth and Sudarshan

 Safety of Expressions
{  x1, x2, …, xn  | P(x1, x2, …, xn)}
3.7.3

is safe if all of the following hold:

1. All values that appear in tuples of the expression are values
from dom(P) (that is, the values appear either in P or in a tuple
of a relation mentioned in P).
2. For every “there exists” subformula of the form  x (P1(x)),
the subformula is true if an only if P1(x) is true for all values x
from dom(P1).
3. For every “for all” subformula of the form x (P1 (x)), the
subformula is true if and only if P1(x) is true for all values x
from dom (P1).

Database System Concepts 3.88 ©Silberschatz, Korth and Sudarshan

 E-R Diagram Example

Database System Concepts 3.89 ©Silberschatz, Korth and Sudarshan

End of Chapter 3