DBMS (LONG ANSWERS)

Q1) Discuss different operations in relational algebra? Explain each operation by giving
suitable example.
Ans) Relational Algebra Operations
Relational algebra provides a set of theoretical operations to manipulate data in relational
databases. Here's a breakdown of some fundamental operations:
1. Selection (σ): This operation filters rows based on a specific condition. It's denoted
by σ followed by a predicate (p) and the relation (r). The predicate defines the
selection criteria using comparison operators (<, >, =, etc.) and logical operators
(AND, OR, NOT).
Example:
Consider a table Students(id, name, major) and you want to find students majoring in
Computer Science (CS).
σ(major = 'CS')(Students)
This expression selects all rows from Students where the major attribute equals 'CS'.
2. Projection (π): This operation selects specific columns from a relation, discarding the
rest. It's denoted by π followed by a comma-separated list of attributes (A) to be
included in the result.
Example:
Continuing with the Students table, suppose you only need student names.
π(name)(Students)
This expression projects only the name column, resulting in a table with just student names.
3. Union (U): This operation combines rows from two compatible relations (having the
same schema). It includes duplicates and eliminates no data.
Example:
Imagine tables Enrolled_CS(student_id, course_name) and Enrolled_Math(student_id,
course_name). You want all courses offered (CS and Math).
Enrolled_CS ∪ Enrolled_Math
This expression combines courses from both tables, potentially containing duplicates if
students are enrolled in courses from both departments.
 4. Set Difference (-): This operation finds rows present in one relation (r) but not in
another (s), both having the same schema.
Example:
Say you want CS courses offered but not taken by any student yet (assuming an empty
Enrolled_CS table initially).
Courses_Offered - Enrolled_CS
This expression identifies courses offered in a hypothetical Courses_Offered table that are not
yet enrolled in by any student.
5. Cartesian Product (x): This operation creates a new relation by combining all rows
from one relation with all rows from another. The resulting relation has all columns
from both input relations.
Example:
Consider tables Students(id, name) and Courses(course_id, name). You might want to create a
temporary relation listing potential student-course combinations.
Students x Courses
This expression creates a new relation with every student paired with every course, which
might be useful for further processing like enrollment planning.
These are just a few core operations in relational algebra. Remember, relational algebra
expressions can be combined to achieve complex data manipulation tasks.

Q2) Distinguish between three major types of architectural data model

Ans) The Three Amigos of Data Modeling: Conceptual, Logical, and Physical
Data modeling is the blueprint for organizing information within a database. It defines the
structure, relationships, and constraints of the data. There are three key levels of data models,
each serving a distinct purpose:
1. Conceptual Data Model (CDM): The Big Picture
Think of the CDM as a high-level overview of the data required by the system. It focuses on
what data is needed, independent of any specific technology or implementation details. Here,
business stakeholders and data architects collaborate to define the core entities (e.g.,
customers, products, orders) and their attributes (e.g., customer name, product price, order
date). The relationships between these entities are also mapped (e.g., a customer can place
many orders, an order contains one or more products).
Example: An e-commerce CDM might identify entities like "Customer" (attributes: name,
address, email), "Product" (attributes: name, price, description), and "Order" (attributes: order
ID, customer ID, date). It would also define the relationship between them, showing that a
"Customer" can place many "Orders" and each "Order" contains one or more "Products."
2. Logical Data Model (LDM): Translating the Vision
The LDM acts as a bridge between the business needs and the technical implementation. It
details how the data will be structured, considering data types, constraints, and relationships.
Here, data types like integer, string, or date are assigned to attributes. Primary and foreign
keys are defined to enforce data integrity and establish relationships between tables. The
LDM is independent of any specific database management system (DBMS), ensuring
flexibility in choosing the technology.
Example: Continuing with the e-commerce example, the LDM would specify data types for
each attribute (e.g., "customer_name" as string, "order_date" as date). It would define a
primary key for each table (e.g., "customer_id" for the "Customer" table) and foreign keys to
link related tables (e.g., "customer_id" in the "Order" table referencing the "Customer" table).
3. Physical Data Model (PDM): Building the House
The PDM is the most specific model, outlining the physical storage of data within a chosen
DBMS. It considers factors like storage optimization, indexing strategies, and access
methods. Here, the focus is on how the data will be physically represented in the database.
The PDM translates the logical model constructs into specific database objects like tables,
columns, indexes, and constraints supported by the chosen DBMS.
Example: The e-commerce PDM might specify the storage engine used by the DBMS (e.g.,
InnoDB in MySQL) and define indexes on frequently accessed columns for faster retrieval. It
would also determine the specific data types supported by the DBMS (e.g., VARCHAR for
"customer_name" instead of a generic string).
In essence, these three data models work together. The CDM defines the "what," the LDM
translates it into a technology-agnostic "how," and the PDM specifies the final, physical
"how" for a particular DBMS. This layered approach ensures a clear roadmap from business
requirements to the actual database implementation.

Q3) Explain sort-merge strategy in external sorting.

Ans) Conquering Big Data: The Sort-Merge Strategy in External Sorting
When dealing with massive datasets that can't fit comfortably in a computer's main memory
(RAM), traditional sorting algorithms become impractical. External sorting comes to the
rescue, employing a clever strategy called sort-merge. Here's how it tackles the challenge:
1. Divide and Conquer: The first step involves breaking down the large dataset into
smaller, manageable chunks. These chunks, called runs, are sized to fit comfortably in
RAM. This allows the use of efficient in-memory sorting algorithms (like quicksort or
merge sort) on each run individually.
 2. Internal Sorting Powerhouse: Each run is then processed independently using an in-
memory sorting algorithm. This ensures that each run becomes a mini-sorted list, with
elements arranged in the desired order (ascending or descending, based on the
requirement).
3. Merging the Sorted Mini-Lists: Here's the magic. Once all the runs are sorted, the
sort-merge strategy takes over. It iterates through these sorted runs, efficiently
combining them into a single, larger sorted list. This merging process is carefully
designed to minimize disk I/O operations, which are much slower compared to in-
memory operations.
There are two common approaches for merging:
• Multi-way Merge: This technique utilizes multiple sorted runs simultaneously. It
maintains a buffer in memory to hold elements from each run's head (beginning). The
element with the smallest value (according to the sorting criteria) is then picked from
the buffer and added to the final sorted output. The corresponding run in the buffer is
then advanced to its next element, and the process repeats. This continues until all
elements from all runs are exhausted, resulting in a fully sorted output.
• Two-way Merge (Recursive): This approach works by repeatedly merging pairs of
sorted runs. It starts by merging the first two runs. The resulting sorted list is then
merged with the third run, and so on. If there are an odd number of runs remaining
after some merges, the last unmerged run is simply appended to the already sorted
output. This process continues recursively until a single, final sorted list is obtained.
4. Temporary Storage: During the merge phase, temporary files might be needed to
store intermediate results. This is because all the sorted runs might not fit in memory
simultaneously. The sort-merge strategy manages these temporary files efficiently,
minimizing the number of disk accesses and ensuring a smooth sorting process.
The sort-merge strategy is a powerful technique for handling large datasets. It leverages the
speed of in-memory sorting for smaller chunks of data and then efficiently combines them
into a final sorted output, making it a crucial tool for data management when dealing with
volumes beyond RAM capacity.