What is an ER Model?

An Entity-Relationship Model represents the structure of the database with the help
of a diagram. ER Modelling is a systematic process to design a database as it would
require you to analyze all data requirements before implementing your database.

History of ER models

Peter Chen proposed ER Diagrams in 1971 to create a uniform convention that can
be used as a conceptual modeling tool. Many models were presented and discussed,
but none were suitable. The data structure diagrams offered by Charles Bachman
also inspired his model.

Why Use ER Diagrams in DBMS?

 • ER Diagram helps you conceptualize the database and lets you know which
fields need to be embedded for a particular entity

• ER Diagram gives a better understanding of the information to be stored in

a database

• It reduces complexity and allows database designers to build databases

quickly

• It helps to describe elements using Entity-Relationship models

• It allows users to get a preview of the logical structure of the database

Symbols Used in ER Diagrams

• Rectangles: This Entity Relationship Diagram symbol represents entity

types

• Ellipses: This symbol represents attributes

• Diamonds: This symbol represents relationship types

• Lines: It links attributes to entity types and entity types with other
relationship types

• Primary key: Here, it underlines the attributes

• Double Ellipses: Represents multi-valued attributes

Components of ER Diagram

You base an ER Diagram on three basic concepts:

• Entities

• Weak Entity

• Attributes

• Key Attribute

• Composite Attribute

• Multivalued Attribute

• Derived Attribute

• Relationships

• One-to-One Relationships

• One-to-Many Relationships

• Many-to-One Relationships
 • Many-to-Many Relationships

Entities

An entity can be either a living or non-living component.

It showcases an entity as a rectangle in an ER diagram.

For example, in a student study course, both the student and the course are entities.

Weak Entity

An entity that makes reliance over another entity is called a weak entity

You showcase the weak entity as a double rectangle in ER Diagram.

In the example below, school is a strong entity because it has a primary key attribute
- school number. Unlike school, the classroom is a weak entity because it does not
have any primary key and the room number here acts only as a discriminator.
Attribute

An attribute exhibits the properties of an entity.

You can illustrate an attribute with an oval shape in an ER diagram.

Key Attribute

Key attribute uniquely identifies an entity from an entity set.

It underlines the text of a key attribute.

For example: For a student entity, the roll number can uniquely identify a student
from a set of students.
Composite Attribute

An attribute that is composed of several other attributes is known as a composite

attribute.

An oval showcases the composite attribute, and the composite attribute oval is
further connected with other ovals.

Multivalued Attribute

Some attributes can possess over one value, those attributes are called multivalued
attributes.

The double oval shape is used to represent a multivalued attribute.

Derived Attribute

An attribute that can be derived from other attributes of the entity is known as a
derived attribute.

In the ER diagram, the dashed oval represents the derived attribute.

Relationship

The diamond shape showcases a relationship in the ER diagram.

It depicts the relationship between two entities.

In the example below, both the student and the course are entities, and study is the
relationship between them.

One-to-One Relationship

When a single element of an entity is associated with a single element of another

entity, it is called a one-to-one relationship.

For example, a student has only one identification card and an identification card is
given to one person.

One-to-Many Relationship

When a single element of an entity is associated with more than one element of
another entity, it is called a one-to-many relationship

For example, a customer can place many orders, but an order cannot be placed by
many customers.
Many-to-One Relationship

When more than one element of an entity is related to a single element of another
entity, then it is called a many-to-one relationship.

For example, students have to opt for a single course, but a course can have many
students.

Many-to-Many Relationship

When more than one element of an entity is associated with more than one element
of another entity, this is called a many-to-many relationship.

For example, you can assign an employee to many projects and a project can have
many employees.
How to Draw an ER Diagram?

Below are some important points to draw ER diagram:

• First, identify all the Entities. Embed all the entities in a rectangle and label
them properly.

• Identify relationships between entities and connect them using a diamond

in the middle, illustrating the relationship. Do not connect relationships
with each other.

• Connect attributes for entities and label them properly.

• Eradicate any redundant entities or relationships.

• Make sure your ER Diagram supports all the data provided to design the
database.

• Effectively use colors to highlight key areas in your diagrams.

In a relational database management system (RDBMS), data is organized and stored

in tables, which are related to each other based on common attributes. The structure
of a relational database can be broken down into the following components:
1. Table:
• A table is a collection of related data organized in rows and columns.
• Each table has a unique name.
• Example: Consider a "Students" table with columns like "StudentID,"
"FirstName," "LastName," and "Age."

StudentID FirstName LastName Age

1 X BOSE 20

2 Y GHOSH 22
 StudentID FirstName LastName Age

3 Z MITRA 21

2. Row (Tuple):
• A row represents a single record or data point in a table.
• Each row contains values for each column defined in the table.
• Example: The first row in the "Students" table represents a student with
ID 1, named X BOSE, aged 20.
3. Column (Attribute):
• A column represents a specific attribute or field in a table.
• Each column has a name and a data type.
• Example: In the "Students" table, "StudentID," "FirstName,"
"LastName," and "Age" are columns.
4. Primary Key:
• A primary key is a unique identifier for each record in a table.
• It ensures that each row in the table can be uniquely identified.
• Example: In the "Students" table, the "StudentID" column can be a
primary key.
5. Foreign Key:
• A foreign key is a column or a set of columns in one table that refers to
the primary key of another table.
• It establishes a link between the two tables.
• Example: If there is another table called "Courses" with a "StudentID"
column, it could be a foreign key linking to the "Students" table.
6. Relationships:
• Relationships define how tables are related to each other.
• Common types of relationships include one-to-one, one-to-many, and
many-to-many.
 • Example: In a university database, the "Students" table and the
"Courses" table may have a one-to-many relationship, where one
student can be enrolled in multiple courses.
7. Normalization:
• Normalization is the process of organizing data in a database to reduce
redundancy and dependency.
• It involves breaking down large tables into smaller, related tables.
• Example: If the "Students" table has both "HomeAddress" and
"SchoolAddress," normalization may involve creating a separate
"Addresses" table and linking it with foreign keys.
What is Relational Algebra in DBMS?

Relational algebra is a procedural query language that works on relational model.

The purpose of a query language is to retrieve data from database or perform various
operations such as insert, update, delete on the data. When I say that relational
algebra is a procedural query language, it means that it tells what data to be retrieved
and how to be retrieved.

On the other hand relational calculus is a non-procedural query language, which

means it tells what data to be retrieved but doesn’t tell how to retrieve it. We will
discuss relational calculus in a separate tutorial.

Types of operations in relational algebra

We have divided these operations in two categories:

1. Basic Operations
2. Derived Operations

Basic/Fundamental Operations:

1. Select (σ)
2. Project (∏)
3. Union (∪)
4. Set Difference (-)
5. Cartesian product (X)
6. Rename (ρ)
Derived Operations:

1. Natural Join (⋈)

2. Left, Right, Full outer join (⟕, ⟖, ⟗)
3. Intersection (∩)
4. Division (÷)

Lets discuss these operations one by one with the help of examples.

Select Operator (σ)

Select Operator is denoted by sigma (σ) and it is used to find the tuples (or rows) in
a relation (or table) which satisfy the given condition.

If you understand little bit of SQL then you can think of it as a where clause in
SQL, which is used for the same purpose.

Syntax of Select Operator (σ)

σ Condition/Predicate(Relation/Table name)
Select Operator (σ) Example

Table: CUSTOMER
---------------

Customer_Id Customer_Name Customer_City

----------- ------------- -------------
C10100 Steve Agra
C10111 Raghu Agra
C10115 Chaitanya Noida
C10117 Ajeet Delhi
C10118 Carl Delhi
Query:

σ Customer_City="Agra" (CUSTOMER)
Output:

Customer_Id Customer_Name Customer_City

----------- ------------- -------------
C10100 Steve Agra
C10111 Raghu Agra
Project Operator (∏)

Project operator is denoted by ∏ symbol and it is used to select desired columns (or
attributes) from a table (or relation).

Project operator in relational algebra is similar to the Select statement in SQL.

Syntax of Project Operator (∏)

∏ column_name1, column_name2, ...., column_nameN(table_name)

Project Operator (∏) Example
In this example, we have a table CUSTOMER with three columns, we want to fetch
only two columns of the table, which we can do with the help of Project Operator
∏.

Table: CUSTOMER

Customer_Id Customer_Name Customer_City

----------- ------------- -------------
C10100 Steve Agra
C10111 Raghu Agra
C10115 Chaitanya Noida
C10117 Ajeet Delhi
C10118 Carl Delhi
Query:

∏ Customer_Name, Customer_City (CUSTOMER)

Output:

Customer_Name Customer_City
------------- -------------
Steve Agra
Raghu Agra
Chaitanya Noida
Ajeet Delhi
Carl Delhi
Union Operator (∪)

Union operator is denoted by ∪ symbol and it is used to select all the rows (tuples)
from two tables (relations).

Lets discuss union operator a bit more. Lets say we have two relations R1 and R2
both have same columns and we want to select all the tuples(rows) from these
relations then we can apply the union operator on these relations.

Note: The rows (tuples) that are present in both the tables will only appear once in
the union set. In short you can say that there are no duplicates present after the union
operation.

Syntax of Union Operator (∪)

table_name1 ∪ table_name2
Union Operator (∪) Example

Table 1: COURSE

Course_Id Student_Name Student_Id

--------- ------------ ----------
C101 Aditya S901
C104 Aditya S901
C106 Steve S911
C109 Paul S921
C115 Lucy S931
Table 2: STUDENT

Student_Id Student_Name Student_Age

------------ ---------- -----------
S901 Aditya 19
S911 Steve 18
S921 Paul 19
S931 Lucy 17
S941 Carl 16
S951 Rick 18
Query:

∏ Student_Name (COURSE) ∪ ∏ Student_Name (STUDENT)

Output:

Student_Name
------------
Aditya
Carl
Paul
Lucy
Rick
Steve
Note: As you can see there are no duplicate names present in the output even though
we had few common names in both the tables, also in the COURSE table we had the
duplicate name itself.

Intersection Operator (∩)

Intersection operator is denoted by ∩ symbol and it is used to select common rows

(tuples) from two tables (relations).

Lets say we have two relations R1 and R2 both have same columns and we want to
select all those tuples(rows) that are present in both the relations, then in that case
we can apply intersection operation on these two relations R1 ∩ R2.

Note: Only those rows that are present in both the tables will appear in the result set.

Syntax of Intersection Operator (∩)

table_name1 ∩ table_name2
Intersection Operator (∩) Example

Lets take the same example that we have taken above.

Table 1: COURSE
Course_Id Student_Name Student_Id
--------- ------------ ----------
C101 Aditya S901
C104 Aditya S901
C106 Steve S911
C109 Paul S921
C115 Lucy S931
Table 2: STUDENT

Student_Id Student_Name Student_Age

------------ ---------- -----------
S901 Aditya 19
S911 Steve 18
S921 Paul 19
S931 Lucy 17
S941 Carl 16
S951 Rick 18
Query:

∏ Student_Name (COURSE) ∩ ∏ Student_Name (STUDENT)

Output:

Student_Name
------------
Aditya
Steve
Paul
Lucy
Set Difference (-)

Set Difference is denoted by – symbol. Lets say we have two relations R1 and R2
and we want to select all those tuples(rows) that are present in Relation R1
but not present in Relation R2, this can be done using Set difference R1 – R2.

Syntax of Set Difference (-)

table_name1 - table_name2
Set Difference (-) Example

Lets take the same tables COURSE and STUDENT that we have seen above.

Query:
Lets write a query to select those student names that are present in STUDENT table
but not present in COURSE table.

∏ Student_Name (STUDENT) - ∏ Student_Name (COURSE)

Output:

Student_Name
------------
Carl
Rick
Cartesian product (X)
Cartesian Product is denoted by X symbol. Lets say we have two relations R1 and
R2 then the cartesian product of these two relations (R1 X R2) would combine each
tuple of first relation R1 with the each tuple of second relation R2. I know it sounds
confusing but once we take an example of this, you will be able to understand this.

Syntax of Cartesian product (X)

R1 X R2
Cartesian product (X) Example
Table 1: R

Col_A Col_B
----- ------
AA 100
BB 200
CC 300
Table 2: S

Col_X Col_Y
----- -----
XX 99
YY 11
ZZ 101
Query:
Lets find the cartesian product of table R and S.

RXS
Output:

Col_A Col_B Col_X Col_Y

----- ------ ------ ------
AA 100 XX 99
AA 100 YY 11
AA 100 ZZ 101
BB 200 XX 99
BB 200 YY 11
BB 200 ZZ 101
CC 300 XX 99
CC 300 YY 11
CC 300 ZZ 101
Note: The number of rows in the output will always be the cross product of number
of rows in each table. In our example table 1 has 3 rows and table 2 has 3 rows so
the output has 3×3 = 9 rows.

Rename (ρ)

Rename (ρ) operation can be used to rename a relation or an attribute of a relation.

Rename (ρ) Syntax:
ρ(new_relation_name, old_relation_name)

Rename (ρ) Example

Lets say we have a table customer, we are fetching customer names and we are
renaming the resulted relation to CUST_NAMES.

Table: CUSTOMER
Customer_Id Customer_Name Customer_City
----------- ------------- -------------
C10100 Steve Agra
C10111 Raghu Agra
C10115 Chaitanya Noida
C10117 Ajeet Delhi
C10118 Carl Delhi
Query:

ρ(CUST_NAMES, ∏(Customer_Name)(CUSTOMER))
Output:

CUST_NAMES
----------
Steve
Raghu
Chaitanya
Ajeet
Carl

What are Extended Operators in Relational Algebra?

In Relational Algebra, Extended Operators are those operators that are derived
from the basic operators. We already have discussed Basic Operators in the previous
section. Now let us discuss the Extended Operators and how they are beneficial in
Relational Algebra.

Types of Extended Operators in Relational Algebra

There are mainly three types of extended operators in relational algebra, namely:

1. Intersection
2. Divide
3. Join

1) Intersection

Intersection works on the relation as 'this and that'. In relational algebra, A ∩

B returns a relation instance that contains every tuple that occurs in relation to
instance A and relation instance B (both together). Here, A and B need to be union-
compatible, and the schema of both result and A must be identical.

Example

Let us consider two tables named as A and B.

A–

RollNo Name Marks

1 Aashi 98

3 Anjali 79

4 Brijesh 88

B–

RollNo Name Marks

1 Aashi 98

2 Abhishek 87

3 Anjali 79

4 Brijesh 88

Query -

SELECT * FROM A INTERSECT SELECT * FROM B;

RollNo Name Marks

1 Aashi 98
 3 Anjali 79

4 Brijesh 88

2) Divide

Divide operator is used for the queries that contain the keyword ALL.

Example

Find all the students who has chosen additional subjects Machine Learning and Data
Mining.

Student –

Student Name Subject

Ashish Machine Learning

Ashish Data Mining

Shivam Network Security

Shivam Data Mining

Tarun Network Security

Tarun Machine Learning

Yash Machine Learning

Yash Data Mining

Subject –

Student Name
 Machine Learning

Data Mining

Output: Student ÷ Subject

Student

Ashish

Yash

3) Join

Join operation is as its name suggest, to join or combine two or more relations'
information. Join can also be defined as a cross-product followed by selection and
projection. There are several varieties of Join operation. Let's discuss all of them one
by one.

Student1 –

RollNo Name Marks

1 Ashish 98

2 Shivam 72

3 Tarun 53

4 Yash 89

Student2 –

RollNo Name Marks

 1 Anjali 99

4 Dinesh 79

5 Harsh 95

7 Kartik 88

3.1) Condition Join

When you want to join two relations based on the given condition, it is termed as
Condition Join. It is denoted by the symbol ⋈c.

For e.g. – Select the students from Student1 table whose RollNo is greater than the
RollNo of Student2 table.

Student1⋈cStudent1.RollNo>Student2.RollNoStudent2

Example
SELECT * FROM Student1, Student2 WHERE Student1.RollNo >
Student2.RollNo;

Output –

RollNo Name Marks RollNo Name Marks

2 Shivam 72 1 Anjali 99

3 Tarun 53 1 Anjali 99

4 Yash 89 1 Anjali 99

3.2) Equi Join

It is a special case of Condition Join. When you want to join two relations based on
the equality condition, it is termed as Equi Join. It is denoted by the symbol ⋈.
For e.g. - Select the students from Student1 table whose RollNo is equalto the
RollNo of Student2 table.

Student1⋈Student1.RollNo=Student2.RollNoStudent2

Example
SELECT * FROM Student1, Student2 WHERE Student1.RollNo=Student2.RollNo;

Output –

RollNo Name Marks RollNo Name Marks

1 Ashish 98 1 Anjali 99

4 Yash 89 4 Dinesh 79

3.3) Natural Join

Natural Join is that type of join in which equijoin is by default applied to all the
attributes in two or more relation. Its specialty is if you want to consider the equality
between two relations, you don't need to define the equality; it is predefined for all
the attributes if you use Natural Join. It is denoted by the symbol ⋈.

For e.g. - Select the students from Student1 table whose RollNo is equal to the
RollNo of Student2 table.

Student1⋈Student2

Example
SELECT * FROM Student1 NATURAL JOIN Student2;

Output –

RollNo Name Marks RollNo Name Marks

1 Ashish 98 1 Anjali 99
 4 Yash 89 4 Dinesh 79

Relational Calculus in DBMS

Introduction

Relational Calculus uses declarative Language, unlike Relational Algebra which

uses Procedural Language. In this article, we will learn about relational calculus in
DBMS and its types. We will also learn to write queries based on the two types of
relational calculus with the help of examples.

Relational Calculus in DBMS

Relational Calculus in DBMS is just another way of formulating queries. It is non-

procedural and a declarative query language. Let’s first understand the difference
between procedural and declarative query language.

Procedural Language Declarative Language

These languages define how to get the These languages define what to get from
results from the database. the database.
An example of procedural language is An example of Declarative Language is
Relational Algebra. Relational Calculus.
Hence relational calculus is concerned with what to do rather than how to do it.
Simply put, it only provides the information on the query description rather than the
methods to do it.

Why is it called Relational Calculus?

It is called Relational Calculus because it is used to manipulate and describe

relational data in DBMS using a mathematical and logical approach. The “relational”
part refers to representing and organizing the data in a tabular form with the help of
relations or tables. The “calculus” part signifies a system of calculation and
reasoning.
Relational Calculus is based on predicate calculus, a truth-valued function with
arguments. When the values of the arguments are substituted in the predicate
calculus, the resulting expression is called a proposition which can be either true or
false.
Relational calculus is a tailored version of a subset of Predicate Calculus, which
helps communicate with the relational database.

Common Notations Used in Relational Calculus

∧ - represents AND.
∨ - represents OR.
¬ - represents NOT.
∈ - represents Belongs to.
∀ - represents that in a set of tuples, all of them satisfy the condition (Universal
Quantifier).
∃ - represents that in a set of tuples, there is at least one occurrence that satisfies the
condition (Universal Quantifier).

Types of Relational Calculus

There are two types of Relational Calculus.

Tuple Relational Calculus (TRC)

It is a non-procedural query language with which we find tuples that hold true for a
given condition. These given conditions are called predicates. Tuple Relational
Calculus describes the desired information without providing specific information
for obtaining that information, i.e., specifies ‘what’ but not ‘how.’
It goes to each table row and checks whether the predicate condition is satisfied
(true) or not (false). It returns the tuple(s) which hold true for the predicate condition.
Syntax
{t \| P(t)}

Here, t represents the tuples returned as results, and P(t) is the predicate logic
condition or expression.
*Note: TRC is used as a theoretical foundation for optimizing the queries. However,
it cannot be executed in SQL-based RDBMS such as MySQL, SQLite, or
PostgreSQL.
Example
Consider the following Student table
Student_Name Course_Enrolled Age
Student_1 Java 18
Student_5 C++ 16
Student _3 Web development 20
Student_4 C++ 17
Query 1: Create a TRC query to get data of all the Student’s whose age>=17.
TRC Query
{t | t ∈ Student (t) ^ t.Age >= 17

Explanation: The tuple variable (t) goes to every tuple of the Student table. Each
row checks the age of the Student, and only those tuples are returned in the result
whose age is greater than or equal to 17.
The query can be interpreted as “Return all the tuples t which belong to table Student
and have an age greater than or equal to 17.”
Result

Student_Name Course_Enrolled Age

Student _1 Java 18
Student _3 Web development 20
Student _4 C++ 17
Query 2: Create a TRC query to get names of all the Students who are enrolled in
C++ course.
TRC Query
{t| ∃ n ∈ Student(t. Student _Name = n. Studen_Name ∧ t.Course_Enrolled
=”C++”)}

Explanation: The above query returns the Studen_Name for all the tuples which
have Course Enrolled as C++. The result is returned in the tuple t.
Result

Studen_Name
Student _5
Student _4
Domain Relational Calculus (DRC)
The domain of the attributes is used in Domain Relational Calculus. It uses domain
variables to get the column values needed based on predicate conditions.
Syntax:
{<x1,x2,...,xn> \| P(x1,x2,...,xn)}

Here, <x1,x2,...,xn> represents the domain variables used to get the column values,
and P(x1,x2,...,xn) is the predicate which is the condition for results.
*Note: DRC is a theoretical foundation for manipulating and describing data in a
relational database. However, it cannot be executed in SQL-based RDBMS such as
MySQL, SQLite, or PostgreSQL.
Example
Consider the following Student table

Studen_id Gender Age

CN_1 M 18
CN_2 F 16
CN_3 F 20
CN_4 M 17
Query 1: Create a DRC query to get data of all the Student’s whose Gender is M.
DRC Query:
{<x1,x2,x3> \| <x1,x3> ∈ Student ∧ x2 = ‘M’ }

Explanation: In the above query, x1(Student_id), x2(Gender), and x3(Age)

represent the columns that are needed in the result. The predicate condition states
that x1 and x3 should be present while x2 has to follow a matching condition for
each row; that is, z2 should be equal to ‘M.’
Result

Student_id Gender Age

CN_1 M 18
CN_4 M 17
Query 2: Create a DRC query to get Student _id of all the Student’s whose
Age<18.
DRC Query:
{ <x1> \| ∈ Student ∧ x3 < 18 }
Explanation: In the above query, x1(Student _id) represents the column needed in
the result. The predicate condition states that x3 has to follow a matching condition
for each row that x3 < 18.
Result

Student _id
CN_2
CN_4
Use Cases of Relational Calculus in DBMS
Below are the use cases of relational calculus in DBMS.
1. Relational Calculus helps in formulating complex queries which
involves multiple tables, aggregations and conditions. It helps the users
to retrieve the desired data from the database.

2. Relational Calculus also helps in data validation. It enables users to

check whether data satisfies the conditions and also helps in identifying
errors or inconsistencies.

3. Relational Calculus plays an important role in Database Modelling and

Design. It helps in defining the schema, integrity constraints, primary
and foreign key constraints, and other things required in database
design.

4. It can perform advanced data analysis like sorting, filtering, aggregation

and grouping. It helps users to get meaningful insights from large
datasets.
Limitations of Relational Calculus in DBMS
Below are the limitations of relational calculus in DBMS.
1. It is not as user friendly as other query languages such as SQL. It lacks
operations that make complex queries efficient and concise to write.

2. It is a declarative language which only focuses on what to retrieve rather

than how to retrieve.

3. It does not provide a mechanism which optimizes the queries

automatically and also it does not support recursive queries.
 4. It may not be suitable for dealing with semi-structured or non relational
data such as graph data or JSON documents.

5 Marks

1. Explain the purpose of an Entity-Relationship (ER) Model in database

design. Provide at least two advantages of using ER Diagrams.
2. Discuss the history of ER Models, highlighting the contributions of Peter
Chen and the motivation behind proposing ER Diagrams in 1971.
3. Describe the symbols used in ER Diagrams and explain the significance
of each, including rectangles, ellipses, diamonds, lines, primary keys, and
double ellipses.
4. Explain the components of an ER Diagram, including entities, weak
entities, attributes, key attributes, composite attributes, multivalued
attributes, derived attributes, and relationships. Provide examples for
each.
5. Differentiate between one-to-one, one-to-many, many-to-one, and many-
to-many relationships. Provide real-world examples for each type of
relationship.
6. Describe the components of a relational database, including tables, rows
(tuples), columns (attributes), primary keys, foreign keys, and
relationships. Provide examples to illustrate each component.
7. Explain the concept of normalization in a relational database. Why is
normalization important, and how does it help in organizing data
efficiently?
8. Discuss the role of primary keys and foreign keys in maintaining data
integrity within a relational database. Provide examples to demonstrate
their usage.
9. Illustrate the process of drawing an ER Diagram, emphasizing the key
steps involved in identifying entities, relationships, and attributes.
10.Explain the use of colors in ER Diagrams and how they can be employed
to highlight key areas or elements within the diagram.
11.Describe the basic operations in relational algebra, including Select (σ),
Project (∏), Union (∪), Set Difference (-), Cartesian Product (X), and
Rename (ρ). Provide examples for each operation.
12.Explain the concept of derived operations in relational algebra and
discuss their significance. Include Natural Join (⋈), Left, Right, Full
outer join (⟕, ⟖, ⟗), Intersection (∩), and Division (÷).
 13.Differentiate between procedural and declarative query languages.
Explain why relational calculus is considered a declarative language.
14.Discuss the common notations used in relational calculus, including
symbols like ∧, ∨, ¬, ∈, ∀, and ∃. Provide examples to illustrate their
usage.
15.Explain Tuple Relational Calculus (TRC) with syntax and examples.
Highlight its advantages and use cases in querying databases.
16.Describe Domain Relational Calculus (DRC) with its syntax and
examples. Discuss scenarios where DRC is more suitable than TRC.
17.Provide real-world use cases of relational calculus in database
management systems. How can it be applied to solve specific problems or
scenarios?
18.Discuss the limitations of relational calculus in DBMS, highlighting areas
where it may not be as effective or suitable as other query languages.

10 Marks

1. Explain the fundamental difference between Relational Calculus and

Relational Algebra. Provide examples to illustrate their distinctive
features.
2. Describe Tuple Relational Calculus (TRC) and its syntax. Provide a
detailed example of a TRC query, explaining each component of the
query and its result.
3. Discuss the significance of the term "Relational" in Relational Calculus.
How does Relational Calculus manipulate and describe data in a
relational database using a mathematical and logical approach?
4. Provide an in-depth explanation of the common notations used in
Relational Calculus, such as ∧, ∨, ¬, ∈, ∀, and ∃. Illustrate with examples
how these notations are employed in formulating queries.
5. Differentiate between Tuple Relational Calculus (TRC) and Domain
Relational Calculus (DRC). Provide examples for both types, highlighting
when each should be used and their limitations.
6. Explain Domain Relational Calculus (DRC) and its syntax. Offer a
detailed example of a DRC query, breaking down the components and
explaining how it retrieves specific column values based on predicate
conditions.
7. Discuss the limitations of Relational Calculus in DBMS. How do these
limitations impact its usability compared to other query languages like
SQL?
8. Explore the use cases of Relational Calculus in Database Management
Systems. Provide specific examples of scenarios where Relational
Calculus is particularly beneficial in formulating complex queries and
ensuring data integrity.
9. Illustrate the role of Relational Calculus in Database Modeling and
Design. Explain how it contributes to defining database schema, integrity
constraints, and key constraints.
10.Examine the challenges associated with Relational Calculus, especially in
comparison to procedural languages. Discuss the reasons behind its non-
executable nature in SQL-based RDBMS and its implications on query
optimization.