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
 Example of a Relation

Mathematicians define a
relation to be a subset of
cartesian product of a list
of domains.
This definition corresponds
with our definition of table.
Every tuble is define a
row in our table.
Tubles can place to table
as sorted or unsorted.
 Basic Structure
• 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
each ai  Di
• 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
 Attribute Types
• 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
 Relation Schema
• Database Schema; is the logical design of the database.
• Database Instance; is a snapshot of the data in the database at a given
instant time.
In Programming Language Symbolized
Relation Variable lower case names
Relation Schema Type of variable Beginning upper case
then lower case
Relation Instance Value of a variable

• 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)
 Relation Instance
• The current values (relation instance) of a relation
are specified by a table
• An element t of r is a tuple, represented by a row
in a table
attributes
(or columns)
customer-name customer-street customer-city

Jones Main Harrison

Smith North Rye tuples
Curry North Rye (or rows)
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
• A database consists of multiple relations
• 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 (we will study) deals with how to design
relational schemas
The customer Relation
The depositor Relation
E-R Diagram for the Banking Enterprise
 Keys
• A super key of an entity set is a set of one or more
attributes whose values uniquely determine each entity.
• A candidate key of an entity set is a minimal super key
– Customer-id is candidate key of customer
– account-number is candidate key of account
• Although several candidate keys may exist, one of the
candidate keys is selected to be the primary key.
Example: In Branch-schema, {branch-name} and {branch-
name, branch-city} are both super keys. But {branch-name,
branch-city} is not a candidate key. Because; {branch-name}
is its subset and for our purpose will serve as a primary key
 Keys
• R is a relation schema and subset K of R is a superkey
for R. 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.
 Determining Keys from E-R Sets
• Relational database schema is based on tables derived from an E-
R schema.
• 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
Schema Diagram for the Banking Enterprise

Foreign Key ;
branch-name

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
 Query Languages
• Language in which user requests information from the database.
• Categories of languages
– Procedural; the user instructs the system to perform a sequence of
operations on the DB to compute desired result.
– Non-procedural; the user describes the desired information without
giving a specific procedure for obtaining that information.
(Most Relational DB systems offer a query language that includes of both; procedural and
non-procedural).
• “Pure” languages:
– Relational Algebra
– Tuple Relational Calculus
– Domain Relational Calculus
• Pure languages form underlying basis of query languages that
people use.
 Relational Algebra
• Which is a procedural query language. It consists of a
set of operations that take one or two relations as
input and produce a new relation as their result.
• The fundamental operations as done by six basic
operators;
– select
– project
– union
– set difference
– Cartesian product
– rename
 Select Operation – Example
• Relation r A B C D

  1 7
  5 7
  12 3
  23 10

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

A B C D

  1 7
  23 10
 Select Operation
• 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)
 Project Operation – Example
The project operation allows us to produce
• Relation r: A B C
relation. This is a unary operation that returns
its argument relation, with certain attributes
 10 1
left out.
 20 1 Since a relation is a set, any dublicate rows
 30 1 are eliminated.

 40 2

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

 1  1
 1 =  1
The argument
Attributes; will  1  2 relation
be in the
results  2
 Project Operation
• 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)
 Union Operation – Example
• Relations r, s:

A B A B

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

r  s:

A B

 1
 2
 1
 3
 Union Operation
• 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)
Set Difference Operation – Example
• Relations r, s:

A B A B

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

r – s:
A B

 1
 1
 Set Difference Operation
• 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
 Cartesian-Product Operation-Example

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  10 a
 1  20 b
 1  10 b
 2  10 a
 2  10 a
 2  20 b
 2  10 b
 Cartesian-Product Operation
• 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.
 Composition of Operations
• Can build expressions using multiple operations
• Example: A=C(r x s) A B C D E A B C D E
• rxs  1  10 a  1  10 a
 1  10 a  10 a
   2 A
1 20 b  20 b
 1  10 b r  10 b
 2  10 a
s
 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
Example
 Rename Operation
• 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.
Example
 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)

 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))

 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)

 Example Queries
• Find the names of all customers who have a loan at
the Perryridge branch.
customer-name (branch-name=“Perryridge”
([Link]-number = [Link]-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”

([Link]-number = [Link]-number(borrower x loan))) –

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

 Query 2
customer-name([Link]-number = [Link]-number(
(branch-name = “Perryridge”(loan)) x borrower))
 Example Queries
Find the largest account balance
• Rename account relation as d
• The query is:
balance(account) - [Link]
([Link] < [Link] (account x d (account)))
 Formal Definition
• A basic expression in the relational algebra consists of
either one of the following:
– A relation in the database
– A constant relation
• Let E1 and E2 be relational-algebra expressions; the
following are all relational-algebra expressions:
– E1  E2
– 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
 Additional Operations
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
 Set-Intersection Operation
• 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)
 Set-Intersection Operation - Example
A B A B

• Relation r, s: 1
2
 2
 3
 1

r s

A B

 2

• r  s= r - (r - s)

Natural-Join
Notation: r s
Operation
• Let r and s be relations on schemas R and S
respectively.
Then, r s is a relation on schema R  S obtained as
follows:
– Consider 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, add a tuple t to the result, where
• t has the same value as tr on r
• t has the same value as ts on 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))
 Natural Join Operation – Example
• 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 
 Division Operation
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 ) }
 Division Operation – Example
Relations r, s: A B B
 1 1
 2
 3 2
 1 s
 1
 1
 3
 4
 6
 1
 2
r  s: A r


rs={t | t  R-S(r)   u  s ( tu  r ) }
 Another Division Example
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 
 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”)})
 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))
Extended Relational-Algebra-Operations

• Generalized Projection
• Outer Join
• Aggregate Functions
 Generalized Projection
• Extends the projection operation by allowing
arithmetic functions to be used in the projection list.

 F1, F2, …, Fn(E)

• E is any relational-algebra expression
• Each of F1, F2, …, Fn 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)
Arithmetic expression
 Aggregate Functions and Operations
• Aggregation function takes a collection of values and
returns a 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
 Aggregate Operation – Example
• Relation r:
A B C

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

sum-C
g sum(c) (r)
27
Aggregate Operation – Example
• 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
 Aggregate Functions (Cont.)
• Result of aggregation does not have a name
– 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)
 Outer Join
• An extension of the join operation that avoids
loss of information.
• Computes the join and then adds tuples form one
relation that do 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
 Outer Join – Example
• Relation loan
loan-number branch-name amount
L-170 Downtown 3000
L-230 Redwood 4000
L-260 Perryridge 1700

• Relation borrower
customer-name loan-number
Jones L-170
Smith L-230
Hayes L-155
 Outer Join – Example
• Inner Join
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

loan-number branch-name amount customer-name loan-number

L-170 Downtown 3000 Jones L-170
L-230 Redwood 4000 Smith L-230
L-260 Perryridge 1700 Hayes L-155

loan borrower
 Outer Join – Example
• Right Outer Join
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

loan-number branch-name amount customer-name loan-number

L-170 Downtown 3000 Jones L-170
L-230 Redwood 4000 Smith L-230
L-260 Perryridge 1700 Hayes L-155

loan borrower
 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 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
 Null Values
• Comparisons with null values return the special truth
value 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
 Modification of the Database
• The content of the database may be modified
using the following operations:
– Deletion
– Insertion
– Updating
• All these operations are expressed using the
assignment operator.
 Deletion
• A delete request is expressed similarly to a query, except
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.
 Deletion Examples
• 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
 Insertion
• To insert data into a relation, we either:
– 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.
 Insertion Examples
• Insert information in the database specifying that Smith
has $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)
 Updating
• A mechanism to change a value in a tuple without
charging all values in the tuple
• Use the generalized projection operator to do this
task
r   F1, F2, …, FI, (r)
• Each Fi 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
 Update Examples
• Make interest payments by increasing all balances by 5
percent.
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))
 Views
• In some cases, it is not desirable for all users to see
the entire 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.
 View Definition
• A view is defined using the create view statement which has
the form
create view 𝑣 as <query expression>
where <query expression> is any legal relational algebra query
expression. The view name is represented by 𝑣.
• 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; the expression is substituted into queries using
the view.
 View Examples
• Consider the view (named all-customer) consisting
of branches 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:

customer-name
(branch-name = “Perryridge” (all-customer))
 Updates Through View
• Database modifications expressed as views must be translated
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)}

End of Chapter 3