Relational Model Notes

Relational Model

Module 3 focuses on the relational model, covering its structure, algebra, calculus, extended operations, modifications, and views.

Topics Covered

• 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

Illustrative table with attributes account-number, branch-name, and balance.

Why Relations?

• Simple model.

• Good match for how we think about data.

• Abstract model underlying SQL, the most important language in DBMS.

  • SQL uses "bags" while the abstract relational model is set-oriented.

Relational Design

Simplest approach: convert each Entity Set (E.S.) to a relation and each relationship to a relation.

• Entity Set → Relation

• E.S. attributes become relational attributes.

Beers(name, manf)

Relational Model

• Table = relation.

• Column headers = attributes.

• Row = tuple (Beers).

• Relation schema = name(attributes) + other structure info., e.g., keys, other constraints.

  • Example: Beers(name, manf)

  • Order of attributes is arbitrary, but in practice, we need to assume the order given in the relation schema.

• Relation instance: current set of rows for a relation schema.

• Database schema = collection of relation schemas.

Constraints

• Primary Key Constraint (P.Key Constraint)

• Referential Integrity Constraint (Ref integ Cons)

• Unique Constraint (Uniq Cons)

• Null Constraint (Null Cons)

• Domain Constraint (Domain Cons)

• Check Constraint (Check Cons)

• Default Constraint (DefaultCons)

Basic Structure

• Formally, given sets $D<em>1, D</em>2, …, D<em>n$, a relation $r$ is a subset of $D</em>1 \,x\, D<em>2 \,x\, … \,x\, D</em>n$. Thus a relation is a set of n-tuples $(a<em>1, a</em>2, …, a<em>n)$ where each $a</em>i \in D_i$.

• Example:

  • 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.

Relational Data Model

Set theoretic.

• Domain: set of values

• Cartesian product (or product) $D<em>1 \,x\, D</em>2 \,x\, … \,x\, D_n$

  • n-tuples $(V<em>1,V</em>2,…,V<em>n)$ s.t., $V</em>1 \in D<em>1, V</em>2 \in D<em>2,…,V</em>n \in D_n$

• Relation = subset of Cartesian product of one or more domains

  • FINITE only; empty set allowed

• Tuples = members of a relation inst.

• Arity = dimension of domains

• Components = values in a tuple

• Domains correspond to values in attributes

• Cardinality = number of tuples

• Relation as table

  • Rows = tuples

  • Columns = components

  • Names of columns = attributes

  • Set of attribute names = schema REL($A<em>1,A</em>2,…,A_n$)

• Arity, Cardinality, Attributes, Component, Tuple

Relation: Example

Domain of Relation: N (Name), A (Address), T (Telephone)

Cardinality of domain: 5 (Names) x 3 (Address) x 7 (Telephone) = 105

Relation:

Arity = 3

Cardinality <= 5 x 3 x 7 of relation

Tuple, Domain, Component, Attribute.

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 for now and consider their effect later.

Relation Schema

• $A<em>1, A</em>2, …, A_n$ are attributes

• R = ($A<em>1, A</em>2, …, A_n$ ) 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 specified by a table.

• An element t of r is a tuple, represented by a row in a table.

Relation Instance Example

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 (Chapter) deals with how to design relational schemas.

E-R Diagram for the Banking Enterprise

Diagram illustrating relationships between entities such as customer, account, branch, loan, and depositor.

The Customer Relation

Table showing customer data with attributes:

• customer-name

• customer-street

• customer-city

The Depositor Relation

Table associating customers with accounts, containing:

• customer-name

• account-number

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

• 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

Diagram visually representing the database schema including relations for branch, account, depositor, loan, customer, and borrower, along with their respective attributes.

Query Languages

• 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.

Relational Algebra

• Procedural language

• 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.

Select Operation – Example

Relation r:

$\sigma_{A=B \land D > 5}(r)$

Select Operation

• Notation: $\sigma_p(r)$

• p is called the selection predicate

• Defined as: $\sigma_p(r) = {t \mid t \in r \land p(t)}$ Where p is a formula in propositional calculus consisting of terms connected by: ∧ (and), ∨ (or), ¬ (not) Each term is one of: op or where op is one of: =, ≠, >, ≥, <, ≤

• Example of selection:
  $\sigma_{branch-name=“Perryridge”}(account)$

Project Operation - Example

Relation r:

$\Pi_{A,C}(r)$

Project Operation

• Notation: $\Pi<em>{A1, A2, …, Ak}(r)$ where $A</em>1, A_2$ 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 $\Pi_{account-number, balance}(account)$

Banking Example

Relations:

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

Tables for Banking Example

Snapshot of tables customer, account, and depositor with sample data.

Example Queries

Write the Relational Algebraic expression for the given queries:

• Find all loans of over $1200.

• Find the loan number for each loan of an amount greater than $1200.

• Find the names of all customers who have a loan at the Perryridge branch.

Solution Queries

• Find all loans of over $1200.

$\sigma_{amount > 1200}(loan)$

• Find the loan number for each loan of an amount greater than $1200.

$\Pi<em>{loan-number}(\sigma</em>{amount > 1200}(loan))$

SQL equivalent: Select Loan_number From Loan Where amount>1200

Solution Queries

• Find the names of all customers who have a loan at the Perryridge branch.

  • Query 1:

$\Pi<em>{customer-name}(\sigma</em>{branch-name = “Perryridge”}(\sigma_{borrower.loan-number = loan.loan-number}(borrower \,x\, loan)))$

*   Query 2:

$\Pi<em>{customer-name}(\sigma</em>{loan.loan-number = borrower.loan-number}((\sigma_{branch-name = “Perryridge”}(loan)) \,x\, borrower))$

Union Operation – Example

Relations r, s:

r

s

r ∪ s:

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
  $\Pi<em>{customer-name}(depositor) ∪ \Pi</em>{customer-name}(borrower)$

Union Operation

• SQL example:
  select CID from depositor union select CID from borrower

• Will Union and Union all give the same result?

Set Difference Operation - Example

Relations r, s:

r

s

r - s:

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

Difference

• SQL Example

  • Except operation

select distinct CID from depositor except select CID from borrower

*   Except all operation

select CID from depositor except all select CID from borrower

Cartesian-Product Operation-Example

Relations r, s:

r

s

r x s:

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.

• If attributes of r(R) and s(S) are not disjoint, then renaming must be used.

Rename Operation

• This is used to rename both relations and attributes.

• In relational algebra it is denoted by ρ

• Relational Algebra expression

  • Renaming attributes : $\rho_{a/b}(R)$

  • Renaming Relation : $\rho_x(R)$

Example Tables

Snapshot of tables customer, depositor, and account with sample data.

Example Queries

• Find the names of all customers who have a loan or an account, or both, from the bank.

• Find the names of all customers who have a loan and an account at bank.

• 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.

Example Queries

Find the names of all customers who have a loan, an account, or both, from the bank

$\Pi<em>{customer-name}(borrower) ∪ \Pi</em>{customer-name}(depositor)$

Find the names of all customers who have a loan and an account at bank.

$\Pi<em>{customer-name}(borrower) ∩ \Pi</em>{customer-name}(depositor)$

Example Queries

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.

$\Pi<em>{customer-name}(\sigma</em>{branch-name = “Perryridge”}(\sigma<em>{borrower.loan-number = loan.loan-number}(borrower \,x\, loan))) – \Pi</em>{customer-name}(depositor)$

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

• $\sigma_p(E1)$, P is a predicate on attributes in E1

• $\Pi_s(E1)$, S is a list consisting of some of the attributes in E1

• $\rho_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

Relation r, s:

s

r ∩ s:

Intersection

Includes all tuples that are both in R and S.

Denoted as R ∩ S

Intersection

SQL:

• intersect

select distinct CID from depositor intersect select CID from borrower

• intersect all

select distinct CID from depositor intersect all select CID from borrower

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

Natural Join Operation – Example

Relations r, s:

r ⋈ s

Division Operation

• Suited to queries that include the phrase “for all”.

• Let r and s be relations on schemas R and S respectively where
  * R = ($A<em>1$, …, $A</em>m$, $B<em>1$, …, $B</em>n$)
  * S = ($B<em>1$, …, $B</em>n$)

The result of r ÷ s is a relation on schema R – S = ($A<em>1$, …, $A</em>m$)

r ÷ s = { t | t ∈ $\Pi_{R-S}(r)$ ∧ ∀ u ∈ s ( tu ∈ r ) }

r ÷ s

Division Operation – Example

Relations r, s:

r

| B |
|---|---|
| 1 |
| 2 |
s

r ÷ s:

| A |
|---|---|
| α |

Another Division Example

Relations r, s:

r

s

r ÷ s:

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: 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.

Relational Algebra Defined: Where is it in DBMS?

Diagram illustrating the flow from SQL query to executable code through parsing, optimization, and code generation within a DBMS.

Putting it altogether

Overall summary on Relational Algebra

Operations (Unary): Selection, Projection

• Selection: $\sigma_{}()$

  • Picks tuples from the relation

• Projection: $\Pi_{}()$

  • Picks columns from the relation

Operations (Set): Union, Set Difference

• Union: () U ()

  • New relation contains all tuples from both relations, duplicate tuples eliminated.

• Set Difference: R – S

  • Produces a relation with tuples that are in R but NOT in S.

Operations (Set): Cartesian Product, Intersect

• Cartesian Product: R x S

  • Produces a relation that is concatenation of every tuple of R with every tuple of S

• The Above operations are the 5 fundamental operations of relational algebra.

• Intersection: R ∩ S

  • All tuples that are in both R and S

Operations (Join): Theta Join, Natural Join

• Theta Join: $\R Join<em>{F} S = \sigma</em>{F}(R \,x\, S)$

  • Select all tuples from the Cartesian product of the two relations, matching condition F

  • When F contains only equality “=“, it is called Equijoin

• Natural Join: R ⋈ S

  • Equijoin with common attributes eliminated

Operations: Division

• Division: R ÷ S

• Produce a relation consist of the set of tuples from R that matches the combination of every tuple in S

Translation to SQL

• FROM clause produces Cartesian product (x) of listed tables

• WHERE clause assigns rows to C in sequence and produces table containing only rows satisfying condition ( sort of like $\sigma$ )

• SELECT clause retains listed columns ($\Pi$ )