Chapter 2: Relational Model

Example of a Relation
 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
● Note: multivalued attribute values are not atomic
● Note: 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
 Relation Schema
● A1, A2, …, An are attributes

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

Example:
Customer_schema = (customer_name, customer_street, customer_city)

● r(R) is a relation on the relation schema R

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

● Example: 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
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
The customer Relation
The depositor Relation
 Keys
● 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} and {customer_name, customer_city} and
{customer_name, customer_street, customer_city}
are four super keys 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.
● Primary Key {customer_name}
 Query Languages
● Language in which user requests information from the database.
● Categories of languages
● Procedural (Ex., C, COBOL, Pascal, Basic)
● Non-procedural, or declarative (Ex., SQL)
● “Pure” languages:
● Relational algebra
● Tuple relational calculus
● Domain relational calculus
● Pure languages form underlying basis of query languages that people use.
 Relational Algebra
● Procedural language
● Six basic operators
● select: σ
● project: ∏
● union: ∪
● set difference: –
● Cartesian product: x
● rename: ρ
● The operators take one or two relations as inputs and produce a new relation as a result.
 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
● Relation r: A B C

α 10 1
α 20 1
β 30 1
β 40 2

∏A,C (r) A C A C

α 1 α 1
α 1 = β 1
β 1 β 2
β 2
 Project Operation
● Notation:
…

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
● Example: 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

A B

● r ∪ s: α 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 (arity means number of attributes)
2. The attribute domains must be compatible (example: 2nd column of r deals with the same
type of values as does the 2nd column of s)
● Example: 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)
● rxs
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
● σA=C(r x s)

A B C D E

α 1 α 10 a
β 2 β 10 a
β 2 β 20 b
 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: Symbol name is rho

ρ x (E)

returns the expression E under the name X

● If a relational-algebra expression E has arity n, then

returns the result of expression E under the name X, and with the
attributes renamed to A1 , A2 , …., An .
 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)

 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”
(σ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)
 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))
 Example Queries
➔ Find the largest account balance
◆ Strategy:
● Find those balances that are not the largest
○ Rename account relation as d so that we can compare each account balance with all
others
● Use set difference to find those account balances that were not found in the earlier step.
◆ The query is:

∏balance(account) - ∏account.balance
(σaccount.balance < d.balance (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
● 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

● Relation r, s:
A B A B
α 1 α 2
α 2 β 3
β 1

r s
● r∩s

A B

α 2
 Natural-Join Operation
● Notation: r s
➔ 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 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))
 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 δ
 Assignment Operation
➔ 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:

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.
 Bank Example Queries
● Find the names of all customers who have a loan and an account at bank.

∏customer_name (borrower) ∩ ∏customer_name (depositor)

● Find the name of all customers who have a loan at the bank and the loan amount
 Extended Relational-Algebra-Operations

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

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

… …

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

● g sum(c) (r) sum(c )

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 sum(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 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.
● We shall 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
 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
 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 (as in SQL)
● For duplicate elimination and grouping, null is treated like any other value, and two nulls are
assumed to be the same (as in 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, (true and false)=false (true and true)=true
(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, loan_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

● Each Fi is either
● the I th attribute of r, if the I th 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 ← ∏ account_number, branch_name, balance * 1.05 (account)

● Pay all accounts with balances over $10,000 6 percent interest

and pay all others 5 percent

account ← ∏ account_number, branch_name, balance * 1.06 (σ BAL > 10000 (account ))

∪ ∏ account_number, branch_name, balance * 1.05 (σBAL ≤ 10000 (account))
End of Chapter 2