Relational Calculus

There is an alternate way of formulating queries known as Relational Calculus.

Relational calculus is a non-procedural query language. In the non-procedural query
language, the user is concerned with the details of how to obtain the end results. The
relational calculus tells what to do but never explains how to do. Most commercial
relational languages are based on aspects of relational calculus including SQL-QBE
and QUEL.

Why it is called Relational Calculus?

It is based on Predicate calculus, a name derived from branch of symbolic language.
A predicate is a truth-valued function with arguments. On substituting values for the
arguments, the function result in an expression called a proposition. It can be either
true or false. It is a tailored version of a subset of the Predicate Calculus to
communicate with the relational database.
Many of the calculus expressions involves the use of Quantifiers. There are two types of
quantifiers:
● Universal Quantifiers: The universal quantifier denoted by is read as for all
which means that in a given set of tuples exactly all tuples satisfy a given
condition.
● Existential Quantifiers: The existential quantifier denoted by ! is read as for
all which means that in a given set of tuples there is at least one occurrences
whose value satisfy a given condition.
Before using the concept of quantifiers in formulas, we need to know the concept of
Free and Bound Variables.
A tuple variable t is bound if it is quantified which means that if it appears in any
occurrences a variable that is not bound is said to be free.
Free and bound variables may be compared with global and local variable of
programming languages.

Types of Relational calculus:

1. Tuple Relational Calculus (TRC)

It is a non-procedural query language which is based on finding a number of tuple
variables also known as range variable for which predicate holds true. It describes
the desired information without giving a specific procedure for obtaining that
information. The tuple relational calculus is specified to select the tuples in a
relation. In TRC, filtering variable uses the tuples of a relation. The result of the
relation can have one or more tuples.
Notation:
A Query in the tuple relational calculus is expressed as following notation
1. {T | P (T)} or {T | Condition (T)}
Where
T is the resulting tuples
P(T) is the condition used to fetch T.
For example:
{ [Link] | Author(T) AND [Link] = 'database' }
Output: This query selects the tuples from the AUTHOR relation. It returns a tuple with
'name' from Author who has written an article on 'database'.
TRC (tuple relation calculus) can be quantified. In TRC, we can use Existential (! )
and Universal Quantifiers ( ).
For example:
{ R| ! T ∀ Authors([Link]='database' AND [Link]=[Link])}
Output: This query will yield the same result as the previous one.

2. Domain Relational Calculus (DRC)

The second form of relation is known as Domain relational calculus. In domain
relational calculus, filtering variable uses the domain of attributes. Domain relational
calculus uses the same operators as tuple calculus. It uses logical connectives #
(and), ∃ (or) and (not). It uses Existential (! ) and Universal Quantifiers ( ) to bind
the variable. The QBE or Query by example is a query language related to domain
relational calculus.
Notation:
1. { a1, a2, a3, ..., an | P (a1, a2, a3, ... ,an)}
Where
a1, a2 are attributes
P stands for formula built by inner attributes
For example:
1. {< article, page, subject > | ∀ javatpoint # subject = 'database'}
Output: This query will yield the article, page, and subject from the relational
javatpoint, where the subject is a database.

Relational Calculus Use Cases in DBMS

The relational calculus use cases in DBMS are listed below.
● Creating complicated queries with several tables, aggregations, and
conditions is made easier with the aid of relational calculus. It aids users in
getting the needed info out of the database.
● Validating data is another benefit of Relational Calculus. Users can use it to
verify that the data meets the requirements and to find mistakes or
discrepancies.
● A crucial component of database modeling and design is relational calculus.
It aids in the definition of the main and foreign key constraints, integrity
requirements, schema, and other necessities for database architecture.
● Advanced data analysis tasks including sorting, filtering, aggregating, and
grouping may be carried out using it. It facilitates users' extraction of valuable
insights from massive databases.

Restrictions on Relational Calculus in DBMS:

● Compared to other query languages like SQL, it is not that easy to use. It
 does not provide the operations necessary to write complicated queries concisely
and efficiently.
● It is a declarative language that doesn't worry about how to obtain things-
just what to fetch.
● It does not allow recursive queries and does not offer an automated query
optimization method.
● When handling semi-structured or non-relational data, such graph data or
JSON documents, it might not be the best option.

Conclusion
In DBMS, Relational Calculus informs us what we want to get out of the database,
not how to do it.
A declarative language is Relational Calculus.
Tuple variables are used by TRC to verify each Row against the condition of the
predicate expression.
DRC makes advantage of domain variables to return the necessary column or
attribute in accordance with the requirement.
Both TRC and DRC may be written for any demand.
Multiple tuples or attributes can be returned by TRC and DRC queries.

Questions:

1. What distinguishes Domain Relational Calculus from Tuple Relational Calculus?

While domain relational calculus is used to pick individual values from a relation,
tuples (rows) from a relation (table) are selected using tuple relational calculus.
Whereas Domain Relational Calculus employs individual value variables, Tuple
Relational Calculus utilizes tuple variables for representing tuples.
2. Is the query language used in Relational Calculus procedural or non-procedural?
The query language used in Relational Calculus is non-procedural. It outlines the
data that is required, not how to obtain it. The DBMS system is responsible for
carrying out the query's actual execution.
3. What are Relational Calculus's limitations?
Those who are unfamiliar with formal logic may find Relational Calculus more
challenging to comprehend than Relational Algebra. Because the database
management system must convert the calculus expressions into comparable
algebraic expressions before executing them, it may also not be as effective as
relational algebra, particularly for complicated queries.
Tuple Relational Calculus Examples

Table Customer
Customer
name Street City
 Saurabh A7 Patiala

Jalandh
Mehak B6 ar

Ludhian
Sumiti D9 a

Ria A5 Patiala

Table Branch
Branch name Branch City

ABC Patiala

DEF Ludhiana

GHI Jalandhar

Table Account
Account number Branch name Balance

1111 ABC 50000

1112 DEF 10000

1113 GHI 9000

1114 ABC 7000

Table Loan
Loan number Branch name Amount

L33 ABC 10000

L35 DEF 15000

L49 GHI 9000

L98 DEF 65000

Table Borrower
 Customer
name
Saurabh L33

Mehak L49

Ria L98

Table Depositor
Customer
name Account number

Saurabh 1111

Mehak 1113

Suniti 1114

Example 1: Find the loan number, branch, and amount of loans greater than or equal
to 10000 amount.
{t| t ∀ loan # t[amount]>=10000}
Resulting relation:

Loan number Branch name Amount

L33 ABC 10000

L35 DEF 15000

L98 DEF 65000

In the above query, t[amount] is known as a tuple variable.

Example 2: Find the loan number for each loan of an amount greater or equal to
10000.
{t| ! s ∀ loan(t[loan number] = s[loan number]
# s[amount]>=10000)}
Resulting relation:

Loan number

L33
 L35

L98

Example 3: 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])}
Resulting relation:

Customer
name

Saurabh

Mehak

Example 4: Find the names of all customers having a loan at the “ABC” branch.
{t | ! s ∀ borrower(t[customer-name] = s[customer-name]
# ! u ∀ loan(u[branch-name] = “ABC” # u[loan-number] = s[loan-number]))}

===============================================================