Q1 Compare File Processing System with Database Management system.

Basics File System DBMS

The file system is a way of arranging the

DBMS is software for managing the
files in a storage medium within a
database.
Structure computer.

Data Redundant data can be present in a file

In DBMS there is no redundant data.
Redundancy system.

Backup and It doesn’t provide Inbuilt mechanism for It provides in house tools for backup
Recovery backup and recovery of data if it is lost. and recovery of data even if it is lost.

Query There is no efficient query processing in Efficient query processing is there in

processing the file system. DBMS.

There is less data consistency in the file There is more data consistency because
Consistency system. of the process of normalization .

It is less complex as compared to It has more complexity in handling as

Complexity DBMS. compared to the file system.

Security File systems provide less security in DBMS has more security mechanisms
Constraints comparison to DBMS. as compared to file systems.

It has a comparatively higher cost than

It is less expensive than DBMS.
Cost a file system.

In DBMS data independence exists,

mainly of two types:
There is no data independence.
Data 1) Logical Data Independence .
Independence 2)Physical Data Independence.

User Access Only one user can access data at a time. Multiple users can access data at a time.

The users are not required to write The user has to write procedures for
Meaning procedures. managing databases

Data is distributed in many files. So, it Due to centralized nature data sharing is
Sharing is not easy to share data. easy

Data It give details of storage and

It hides the internal details of Database
Abstraction representation of data

Integrity Integrity Constraints are difficult to Integrity constraints are easy to

Constraints implement implement
Basics File System DBMS

To access data in a file , user requires

attributes such as file name, file No such attributes are required.
Attribute s location.

Example Cobol , C++ Oracle , SQL Server

Q2 Need to check.

Q3 Define with an example different type of Entities in ER diagram

An Entity may be an object with a physical existence: a particular person, car, house, or employee or it
may be an object with a conceptual existence – a company, a job, or a university course.

Types of Entity
There are two types of entity:
1. Strong Entity
A Strong Entity is a type of entity that has a key Attribute. Strong Entity does not depend on other Entity
in the Schema. It has a primary key, that helps in identifying it uniquely, and it is represented by a
rectangle. These are called Strong Entity Types.
2. Weak Entity
An Entity type has a key attribute that uniquely identifies each entity in the entity set. But some entity
type exists for which key attributes can’t be defined. These are called Weak Entity types.
For Example, A company may store the information of dependents (Parents, Children, Spouse) of an
Employee. But the dependents can’t exist without the employee. So dependent will be a Weak Entity
Type and Employee will be identifying entity type for dependent, which means it is Strong Entity Type.
A weak entity type is represented by a double rectangle. The participation of weak entity types is always
total. The relationship between the weak entity type and its identifying strong entity type is called
identifying relationship and it is represented by a double diamond.

Strong Entity and Weak Entity

Q 4. Define Triggers. Write syntax and example of trigger.

rigger is a statement that a system executes automatically when there is any modification to the database.
In a trigger, we first specify when the trigger is to be executed and then the action to be performed when
the trigger executes. Triggers are used to specify certain integrity constraints and referential constraints
that cannot be specified using the constraint mechanism of SQL.
Example –
Suppose, we are adding a tuple to the ‘Donors’ table that is some person has donated blood. So, we can
design a trigger that will automatically add the value of donated blood to the ‘Blood_record’ table.
Types of Triggers –
We can define 6 types of triggers for each table:
 1. AFTER INSERT activated after data is inserted into the table.

2. AFTER UPDATE: activated after data in the table is modified.

3. AFTER DELETE: activated after data is deleted/removed from the table.

4. BEFORE INSERT: activated before data is inserted into the table.

5. BEFORE UPDATE: activated before data in the table is modified.

6. BEFORE DELETE: activated before data is deleted/removed from the table.

Q5 Explain five aggregate functions of SQL with example?

1. Count()
The COUNT() function returns the number of rows that match a given condition or are present in a
column.
• COUNT(*): Counts all rows.
• COUNT(column_name): Counts non-NULL values in the specified column.
• COUNT(DISTINCT column_name): Counts unique non-NULL values in the column.
Examples:
-- Total number of records in the table
SELECT COUNT(*) AS TotalRecords FROM Employee;

-- Count of non-NULL salaries

SELECT COUNT(Salary) AS NonNullSalaries FROM Employee;

-- Count of unique non-NULL salaries

SELECT COUNT(DISTINCT Salary) AS UniqueSalaries FROM Employee;
2. SUM()
The SUM() function calculates the total sum of a numeric column.
• SUM(column_name): Returns the total sum of all non-NULL values in a column.
Examples:
-- Calculate the total salary
SELECT SUM(Salary) AS TotalSalary FROM Employee;

-- Calculate the sum of unique salaries

SELECT SUM(DISTINCT Salary) AS DistinctSalarySum FROM Employee;
3. AVG()
The AVG() function calculates the average of a numeric column. It divides the sum of the column by the
number of non-NULL rows.
• AVG(column_name): Returns the average of the non-NULL values in the column.
Examples:
-- Calculate the average salary
SELECT AVG(Salary) AS AverageSalary FROM Employee;

-- Average of distinct salaries

SELECT AVG(DISTINCT Salary) AS DistinctAvgSalary FROM Employee;
4. MIN() and MAX()
The MIN() and MAX() functions return the smallest and largest values, respectively, from a column.
• MIN(column_name): Returns the minimum value.
• MAX(column_name): Returns the maximum value.
Examples:
-- Find the highest salary
SELECT MAX(Salary) AS HighestSalary FROM Employee;
-- Find the lowest salary
SELECT MIN(Salary) AS LowestSalary FROM Employee;
Examples of SQL Aggregate Functions
Let’s consider a demo Employee table to demonstrate SQL aggregate functions . This table contains
employee details such as their ID, Name, and Salary.
Id Name Salary

1 A 802

2 B 403

3 C 604

4 D 705

5 E 606

6 F NULL
1. Count the Total Number of Employees
SELECT COUNT(*) AS TotalEmployees FROM Employee;
Output:
TotalEmployees

6
2. Calculate the Total Salary
SELECT SUM(Salary) AS TotalSalary FROM Employee;
Output:
TotalSalary

3120
3. Find the Average Salary:
SELECT AVG(Salary) AS AverageSalary FROM Employee;
Output:
AverageSalary

624
4. Find the Highest and Lowest Salary
SELECT MAX(Salary) AS HighestSalary FROM Employee;
Output:
HighestSalary LowestSalary

802 403
Q 6 Design an EER diagram for Hospital Management System. And map it into relational model.
Assume Suitable data.
(Need to check).

Q7 Brief overall database architecture with suitable diagram.

(Need to check).

Q 8 Consider the following employee database.

Employee (empname, street, city, date_of_joining)
Works (empname, company_name,salary)
Company (company_name, city)
Manages (empname, manager_name)

Write the SQL queries for each of the statements given below
a) Modify the database so that "John' now lives in "Mumbai',
b) Find all employees who joined in the month of October
c) Give all employees of 'ABC Corporation' a 10% raise.
d) Find all employees in the database who live in the same cities
as the companies for which they work
e) Find all employees who earn more than average salary of all employees of their company.

Q9 .Explain following relational algebra operators with example

a) Selection operator
b) Union operator
c) Rename operator
d) Cartesian product

Table 1: STUDENT_SPORTS
ROLL_NO SPORTS

1 Badminton

2 Cricket
 ROLL_NO SPORTS

2 Badminton

4 Badminton

Table 2: EMPLOYEE
EMP_NO NAME ADDRESS PHONE AGE

1 RAM DELHI 9455123451 18

5 NARESH HISAR 9782918192 22

6 SWETA RANCHI 9852617621 21

4 SURESH DELHI 9156768971 18

Table 3: STUDENT
ROLL_NO NAME ADDRESS PHONE AGE

1 RAM DELHI 9455123451 18

2 RAMESH GURGAON 9652431543 18

3 SUJIT ROHTAK 9156253131 20

4 SURESH DELHI 9156768971 18

1. Selection operator (σ)

Selection operator is used to selecting tuples from a relation based on some condition. Syntax:
σ (Cond)(Relation Name)
Extract students whose age is greater than 18 from STUDENT relation given in Table 3
σ (AGE>18)(STUDENT)
[Note: SELECT operation does not show any result, the projection operator must be called before the
selection operator to generate or project the result. So, the correct syntax to generate the result
is: ∏(σ (AGE>18)(STUDENT))]
RESULT:
ROLL_NO NAME ADDRESS PHONE AGE

3 SUJIT ROHTAK 9156253131 20

2. Union (U)
Union on two relations R1 and R2 can only be computed if R1 and R2 are union compatible (These two
relations should have the same number of attributes and corresponding attributes in two relations have
the same domain). Union operator when applied on two relations R1 and R2 will give a relation with
tuples that are either in R1 or in R2. The tuples which are in both R1 and R2 will appear only once in the
result relation. Syntax:
Relation1 U Relation2
Find the person who is either student or employees, we can use Union operators like:
STUDENT U EMPLOYEE
RESULT:
ROLL_NO NAME ADDRESS PHONE AGE

1 RAM DELHI 9455123451 18

2 RAMESH GURGAON 9652431543 18

3 SUJIT ROHTAK 9156253131 20

4 SURESH DELHI 9156768971 18

5 NARESH HISAR 9782918192 22

6 SWETA RANCHI 9852617621 21

3 Rename(ρ)
Rename operator is used to giving another name to a relation. Syntax:
ρ(Relation2, Relation1)
To rename STUDENT relation to STUDENT1, we can use rename operator like:
ρ(STUDENT1, STUDENT)
If you want to create a relation STUDENT_NAMES with ROLL_NO and NAME from STUDENT, it
can be done using rename operator as:
ρ(STUDENT_NAMES, ∏(ROLL_NO, NAME)(STUDENT))

When two sets have items in them, A and B, their Cartesian product is all the pairs you can make. One
part of the pair comes from set A. The other part comes from set B. We make every possible pair this
way. The result is a new set of all these pairs. We write this new set as A×B.
A × B = {(a, b) : a ∈ A and b ∈ B}
Example:
Let A = {1, 2} and B = {4, 5, 6}
A × B = {(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6)}
Here the first component of every ordered pair is from set A the second component is from set B.
Cartesian Product of two sets can be easily represented in the form of a matrix where both sets are on
either axis, as shown in the image below. Cartesian Product of A = {1, 2} and B = {x, y, z}

Q 10. Explain concurrency control and explain time Stamp based protocol of concurrency
(Need to check).

Q 11 Why there is need of normalization? Explain INF.2NF,3NE and BCNF with examples.

Why do we need Normalization?

The main reason for normalizing the relations is removing these anomalies. Failure to eliminate anomalies
leads to data redundancy and can cause data integrity and other problems as the database grows.
Normalization consists of a series of guidelines that helps to guide you in creating a good database structure.

Data modification anomalies can be categorized into three types:

o Insertion Anomaly: Insertion Anomaly refers to when one cannot insert a new tuple into a
relationship due to lack of data.
o Deletion Anomaly: The delete anomaly refers to the situation where the deletion of data results in
the unintended loss of some other important data.
o Updating Anomaly: The update anomaly is when an update of a single data value requires multiple
rows of data to be updated.
o

1. First Normal Form (1NF): Eliminating Duplicate Records

A table is in 1NF if it satisfies the following conditions:
• All columns contain atomic values (i.e., indivisible values).
• Each row is unique (i.e., no duplicate rows).
• Each column has a unique name.
• The order in which data is stored does not matter.
Example of 1NF Violation: If a table has a column “Phone Numbers” that stores multiple phone
numbers in a single cell, it violates 1NF. To bring it into 1NF, you need to separate phone numbers into
individual rows.

2. Second Normal Form (2NF): Eliminating Partial Dependency

A relation is in 2NF if it satisfies the conditions of 1NF and additionally. No partial dependency exists,
meaning every non-prime attribute (non-key attribute) must depend on the entire primary key, not
just a part of it.
Example: For a composite key (StudentID, CourseID), if the StudentName depends only
on StudentID and not on the entire key, it violates 2NF. To normalize, move StudentName into a
separate table where it depends only on StudentID.

3. Third Normal Form (3NF): Eliminating Transitive Dependency

A relation is in 3NF if it satisfies 2NF and additionally, there are no transitive dependencies. In simpler
terms, non-prime attributes should not depend on other non-prime attributes.
Example: Consider a table with (StudentID, CourseID, Instructor). If Instructor depends
on CourseID, and CourseID depends on StudentID, then Instructor indirectly depends on StudentID,
which violates 3NF. To resolve this, place Instructor in a separate table linked by CourseID.

4. Boyce-Codd Normal Form (BCNF): The Strongest Form of 3NF

BCNF is a stricter version of 3NF where for every non-trivial functional dependency (X → Y), X must
be a superkey (a unique identifier for a record in the table).
Example: If a table has a dependency (StudentID, CourseID) → Instructor, but neither StudentID nor
CourseID is a superkey, then it violates BCNF. To bring it into BCNF, decompose the table so that each
determinant is a candidate key.

Q12. i Describe ACID properties with examples and

ii explain state transition diagram of transaction.

ANS . i Describe ACID properties with examples and ….

ACID stands for Atomicity, Consistency, Isolation, and Durability. These four key properties define
how a transaction should be processed in a reliable and predictable manner, ensuring that the database
remains consistent, even in cases of failures or concurrent accesses.
1. Atomicity: “All or Nothing”
Atomicity ensures that a transaction is atomic, it means that either the entire transaction completes fully
or doesn’t execute at all. There is no in-between state i.e. transactions do not occur partially. If a
transaction has multiple operations, and one of them fails, the whole transaction is rolled back, leaving
the database unchanged. This avoids partial updates that can lead to inconsistency.
• Commit: If the transaction is successful, the changes are permanently applied.
• Abort/Rollback: If the transaction fails, any changes made during the transaction are
discarded.
2. Consistency: Maintaining Valid Data States
Consistency ensures that a database remains in a valid state before and after a transaction. It guarantees
that any transaction will take the database from one consistent state to another, maintaining the rules and
constraints defined for the data. In simple terms, a transaction should only take the database from
one valid state to another. If a transaction violates any database rules or constraints, it should be rejected,
ensuring that only consistent data exists after the transaction.
3. Isolation: Ensuring Concurrent Transactions Don’t Interfere
This property ensures that multiple transactions can occur concurrently without leading to
the inconsistency of the database state. Transactions occur independently without interference. Changes
occurring in a particular transaction will not be visible to any other transaction until that particular change
in that transaction is written to memory or has been committed.
This property ensures that when multiple transactions run at the same time, the result will be the same as
if they were run one after another in a specific order. This property prevents issues such as dirty
reads (reading uncommitted data), non-repeatable reads (data changing between two reads in a
transaction), and phantom reads (new rows appearing in a result set after the transaction starts).
4. Durability: Persisting Changes
This property ensures that once the transaction has completed execution, the updates and modifications
to the database are stored in and written to disk and they persist even if a system failure occurs. These
updates now become permanent and are stored in non-volatile memory. In the event of a failure, the
DBMS can recover the database to the state it was in after the last committed transaction, ensuring that
no data is lost.
Example: After successfully transferring money from Account A to Account B, the changes are stored
on disk. Even if there is a crash immediately after the commit, the transfer details will still be intact when
the system recovers, ensuring durability.

ANS ii explain state transition diagram of transaction.

1. Active State
• It is the first stage of any transaction when it has begun to execute. The execution of the
transaction takes place in this state.
• Operations such as insertion, deletion, or updation are performed during this state.
• During this state, the data records are under manipulation and they are not saved to the database,
rather they remain somewhere in a buffer in the main memory.
2. Partially Committed
• The transaction has finished its final operation, but the changes are still not saved to the
database.
• After completing all read and write operations, the modifications are initially stored in main
memory or a local buffer. If the changes are made permanent in the database then the state will
change to “committed state” and in case of failure it will go to the “failed state”.
3. Committed
This state of transaction is achieved when all the transaction-related operations have been executed
successfully along with the Commit operation, i.e. data is saved into the database after the required
manipulations in this state. This marks the successful completion of a transaction.
4. Failed State
If any of the transaction-related operations cause an error during the active or partially committed state,
further execution of the transaction is stopped and it is brought into a failed state. Here, the database
recovery system makes sure that the database is in a consistent state.
5. Aborted State
If a transaction reaches the failed state due to a failed check, the database recovery system will attempt
to restore it to a consistent state. If recovery is not possible, the transaction is either rolled back or
cancelled to ensure the database remains consistent.
In the aborted state, the DBMS recovery system performs one of two actions:
• Kill the transaction: The system terminates the transaction to prevent it from affecting other
operations.
• Restart the transaction: After making necessary adjustments, the system reverts the
transaction to an active state and attempts to continue its execution.
6. Terminated State
It refers to the final state of a transaction, indicating that it has completed its execution. Once a transaction
reaches this state, it has either been successfully committed or aborted. In this state, no further actions
are required from the transaction, as the database is now stable.
Example of Transaction States
Imagine a bank transaction where a user wants to transfer $500 from Account A to Account B. The
system should handle the following transaction states:
1. Active State:
• The transaction begins. It reads the balance of Account A and checks if it has enough funds.
• Example: Read balance of Account A = $1000.
2. Partially Committed State:
• The transaction performs all its operations but hasn’t yet saved (committed) the changes to the
database.
• Example: Deduct $500 from Account A’s balance ($1000 – $500 = $500) and temporarily
update Account B’s balance (add $500).
3. Committed State:
• The transaction successfully completes, and the changes are saved permanently in the database.
• Example: Account A’s new balance = $500; Account B’s new balance = $1500. Changes are
written to the database.
4. Failed State:
• If something goes wrong during the transaction (e.g., power failure, system crash), the
transaction moves to this state.
 • Example: System crashes after deducting $500 from Account A but before adding it to
Account B.
5. Aborted State:
• The failed transaction is rolled back, and the database is restored to its original state.
• Example: Account A’s balance is restored to $1000, and no changes are made to Account B.
These states ensure that either the transaction completes successfully (committed) or the database is
restored to its original state (aborted), maintaining consistency and preventing errors.

Q 13 What is Deadlock Explain wait-die and wound wait methods with suitable.

What is Deadlock Detection?

When a transaction waits indefinitely to obtain a lock, The database management system should detect
whether the transaction is involved in a deadlock or not.
Wait-for-graph is one of the methods for detecting the deadlock situation. This method is suitable for
smaller databases. In this method, a graph is drawn based on the transaction and its lock on the resource.
If the graph created has a closed loop or a cycle, then there is a deadlock. For the above-mentioned
scenario, the Wait-For graph is drawn below:

What is Deadlock Prevention?

For a large database, the deadlock prevention method is suitable. A deadlock can be prevented if the
resources are allocated in such a way that a deadlock never occurs. The DBMS analyzes the operations
whether they can create a deadlock situation or not, If they do, that transaction is never allowed to be
executed.
Deadlock prevention mechanism proposes two schemes:
• Wait-Die Scheme: In this scheme, If a transaction requests a resource that is locked by another
transaction, then the DBMS simply checks the timestamp of both transactions and allows the
older transaction to wait until the resource is available for execution.
Suppose, there are two transactions T1 and T2, and Let the timestamp of any transaction T be
TS (T). Now, If there is a lock on T2 by some other transaction and T1 is requesting resources
held by T2, then DBMS performs the following actions:
Checks if TS (T1) < TS (T2) – if T1 is the older transaction and T2 has held some resource,
then it allows T1 to wait until resource is available for execution. That means if a younger
transaction has locked some resource and an older transaction is waiting for it, then an older
transaction is allowed to wait for it till it is available. If T1 is an older transaction and has held
some resource with it and if T2 is waiting for it, then T2 is killed and restarted later with random
delay but with the same timestamp. i.e. if the older transaction has held some resource and the
younger transaction waits for the resource, then the younger transaction is killed and restarted
with a very minute delay with the same timestamp.
This scheme allows the older transaction to wait but kills the younger one.
• Wound Wait Scheme: In this scheme, if an older transaction requests for a resource held by a
younger transaction, then an older transaction forces a younger transaction to kill the
 transaction and release the resource. The younger transaction is restarted with a minute delay
but with the same timestamp. If the younger transaction is requesting a resource that is held by
an older one, then the younger transaction is asked to wait till the older one releases it.

Q 14 Explain in detail with example of conflict and view serializability.

(Need to check).

Q 15 Explain following Integrity constraints:

a) Key Constraints.
b) Domain Constraints (Null & Default Constraints)
c) Referential Constraints.
d) Check Constraints.

a) Key Constraints.

Key Constraints
Key constraints ensure that certain columns or combinations of columns in a table uniquely identify each
row. These rules are essential for maintaining data integrity and preventing duplicate or ambiguous
records.
Example:
Student_id Name Semester Age

21CSE101 Ramesh 5th 20

21CSE102 Kamlesh 5th 21

21CSE103 Aakash 5th 22

21CSE102 Mukesh 5th 20

b) Domain Constraints (Null & Default Constraints)

Domain constraints are a type of integrity constraint that ensure the values stored in a column (or attribute)
of a database are valid and within a specific range or domain. In simple terms, they define what type of
data is allowed in a column and restrict invalid data entry. The data type of domain include string, char,
time, integer, date, currency etc. The value of the attribute must be available in comparable domains.
Example:
Student_Id Name Semester Age

21CSE100 Aniket Kumar 6th 20

21CSE101 Shashwat Dubey 7th 21

21CSE102 Manvendra Sharma 8th 22

21CSE103 Ashmit Dubey 5th 20

This table demonstrates domain constraints in action by enforcing rules for each column:
1. Student_Id: Must be unique and follow a specific format like 21CSE###. No duplicates or
invalid formats allowed.
2. Name: Accepts only valid text (no numbers) and cannot be left empty (NOT NULL constraint).
 3. Semester: Allows specific values like 5th, 6th, etc., and ensures valid input (e.g., no 10th if not
permitted).
4. Age: Must be an integer within a reasonable range (e.g., 18-30) and cannot contain invalid data
like negative numbers or text.

c) Referential Constraints.
Referential integrity constraints are rules that ensure relationships between tables remain consistent. They
enforce that a foreign key in one table must either match a value in the referenced primary key of another
table or be NULL. This guarantees the logical connection between related tables in a relational database.
Example:
Here, in below example Block_No 22 entry is not allowed because it is not present in 2nd table.
Student_id Name Semester Block_No

22CSE101 Ramesh 5th 20

21CSE105 Kamlesh 6th 21

22CSE102 Aakash 5th 20

23CSE106 Mukesh 2nd 22

Block_No Block Location

20 Chandigarh

21 Punjab

25 Delhi

Q 16 Write short note on Log based recovery mechanism.

Log-based recovery in DBMS ensures data can be maintained or restored in the event of a system failure.
The DBMS records every transaction on stable storage, allowing for easy data recovery when a failure
occurs. For each operation performed on the database, a log file is created. Transactions are logged and
verified before being applied to the database, ensuring data integrity.

Log Based Recovery

Log in DBMS
A log is a sequence of records that document the operations performed during database transactions. Logs
are stored in a log file for each transaction, providing a mechanism to recover data in the event of a failure.
For every operation executed on the database, a corresponding log record is created. It is critical to store
these logs before the actual transaction operations are applied to the database, ensuring data integrity and
consistency during recovery processes.
For example, consider a transaction to modify a student’s city. This transaction generates the following
logs:

Start Log: When the transaction begins, a log is created to indicate the start of the transaction.
Format:<Tn, Start>
• Here, Tn represents the transaction identifier.
• Example: <T1, Start> indicates that Transaction 1 has started.
•
Operation Log: When the city is updated, a log is recorded to capture the old and new values of the
operation.
Format:<Tn, Attribute, Old_Value, New_Value>
• Example: <T1, City, 'Gorakhpur', 'Noida'> shows that in Transaction 1, the value of
the City attribute has changed from 'Gorakhpur' to 'Noida'.
•
Commit Log: Once the transaction is successfully completed, a final log is created to indicate that the
transaction has been completed and the changes are now permanent.
Format:<Tn, Commit>
• Example: <T1, Commit> signifies that Transaction 1 has been successfully completed.
These logs play a crucial role in ensuring that the database can recover to a consistent state after a system
crash. If a failure occurs, the DBMS can use these logs to either roll back incomplete transactions or redo
committed transactions to maintain data consistency.
Key Operations in Log-Based Recovery
Undo Operation
The undo operation reverses the changes made by an uncommitted transaction, restoring the database to
its previous state.
Example of Undo:
Consider a transaction T1 that updates a bank account balance but fails before committing:
Initial State:
• Account balance = 500.
Transaction T1:
• Update balance to 600.
• Log entry:
<T1, Balance, 500, 600>
Failure:
• T1 fails before committing.
Undo Process:
• Use the old value from the log to revert the change.
• Set balance back to 500.
• Final log entry after undo:
<T1, Abort>
Redo Operation
The redo operation re-applies the changes made by a committed transaction to ensure consistency in the
database.
Example of Redo:
Consider a transaction T2 that updates an account balance but the database crashes before changes are
permanently reflected:
Initial State:
• Account balance = 300.
Transaction T2:
• Update balance to 400.
• Log entries:
<T2, Start><T2, Balance, 300, 400><T2, Commit>
Crash:
• Changes are not reflected in the database.

QP 2
Q1 Identify different users of database management system.
• Database Administrators (DBA): They are responsible for managing, maintaining, and securing the
database system.
• Database Designers: They are responsible for designing the logical and physical structure of the
database.
• System Analysts: They are responsible for analyzing the requirements and specifications of the
database system.
• Application Programmers: They are responsible for writing application programs that use the
database.
• End Users: They are the ones who access the database through the frontend of the application.
• Naive Users: They are end users who have no knowledge of the database design and working.
• Sophisticated Users: They are end users who have some knowledge of the database system and can
use query languages to access the database.
• Online Analytical Processing (OLAP) Users: They are end users who perform complex analysis and
queries on the database.

Q2 Explain all types of integrity constraints with an example?

Already Done.
Q3 Discuss Log based recovery with on example
Already Done.

Q 4 explain three-layer schema architecture with suitable diagram.

1. Physical Level
At the physical level, the information about the location of database objects in the data store is kept.
Various users of DBMS are unaware of the locations of these objects. In simple terms, physical level of
a database describes how the data is being stored in secondary storage devices like disks and tapes and
also gives insights on additional storage details.
2. Conceptual Level
At conceptual level, data is represented in the form of various database tables. For Example, STUDENT
database may contain STUDENT and COURSE tables which will be visible to users but users are unaware
of their storage. Also referred as logical schema, it describes what kind of data is to be stored in the
database.
3. External Level
An external level specifies a view of the data in terms of conceptual level tables. Each external level
view is used to cater to the needs of a particular category of users. For Example, FACULTY of a
university is interested in looking course details of students, STUDENTS are interested in looking at all
details related to academics, accounts, courses and hostel details as well. So, different views can be
generated for different users. The main focus of external level is data abstraction.

Explain Types of data independence.

There are two types of data independence.
• logical data independence
• Physical data independence
Logical Data Independence
• Changing the logical schema (conceptual level) without changing the external schema (view
level) is called logical data independence.
• It is used to keep the external schema separate from the logical schema.
• If we make any changes at the conceptual level of data, it does not affect the view level.
• This happens at the user interface level.
• For example, it is possible to add or delete new entities, attributes to the conceptual schema
without making any changes to the external schema.
Physical Data Independence
• Making changes to the physical schema without changing the logical schema is called physical
data independence.
• If we change the storage size of the database system server, it will not affect the conceptual
structure of the database.
• It is used to keep the conceptual level separate from the internal level.
• This happens at the logical interface level.
• Example – Changing the location of the database from C drive to D drive.

Q5 What is deadlock? Give deadlock prevention methods with suitable example

(Already done)

Q7 Why there is need of normalization? Explain INF, 2NF, 3NF and BCNF with example.
(Already done)

Q 8. Describe ACID properties with examples

Q6. Explain the Relational Algebra operations with suitable example

1 Generalized Project 2) Select 3) Union 4) Rename 5) Natural Join
(Need to check)
Q 9 Give example of serial schedule and equivalent to serial schedule with respect to conflict
serializability. Discuss conflict serializability with example
(Need to check)
Q 10 .Write short note on the following (Any four).
1 Conversion of Specialization to relational schema with suitable example (Need to check).
2 Types of attributes
1. Simple Attribute
An attribute that cannot be further subdivided into components is a simple attribute.
Example: The roll number of a student, the ID number of an employee, gender, and many more.

Simple Attribute

2.Composite Attribute
An attribute that can be split into components is a composite attribute.
Example: The address can be further split into house number, street number, city, state, country, and pin
code, the name can also be split into first name middle name, and last name.

Composite Attribute

3. Single-Valued Attribute
The attribute which takes up only a single value for each entity instance is a single-valued attribute.
Example: The age of a student, Aadhar card number.

Single-Valued

4. Multi-Valued Attribute
The attribute which takes up more than a single value for each entity instance is a multi-valued
attribute. And it is represented by double oval shape.
Example: Phone number of a student: Landline and mobile.
Multi-valued

5. Stored Attribute
The stored attribute are those attribute which doesn’t require any type of further update since they are
stored in the database.
Example: DOB(Date of birth) is the stored attribute.

Stored-attribute

6. Derived Attribute
An attribute that can be derived from other attributes is derived attributes. And it is represented by dotted
oval shape.
Example: Total and average marks of a student, age of an employee that is derived from date of birth.

Derived-attribute

7. Complex Attribute
Those attributes, which can be formed by the nesting of composite and multi-valued attributes, are called
“Complex Attributes“. These attributes are rarely used in DBMS(DataBase Management System). That’s
why they are not so popular.
Example: Address because address contain composite value like street, city, state, PIN code and also
multivalued because one people has more that one house address.
Complex-attribute

Representation
Complex attributes are the nesting of two or more composite and multi-valued attributes. Therefore, these
multi-valued and composite attributes are called ‘Components’ of complex attributes.
These components are grouped between parentheses ‘( )’ and multi-valued attributes between curly braces
‘{ }’, Components are separated by commas ‘, ‘.
For example: let us consider a person having multiple phone numbers, emails, and an address.
Here, phone number and email are examples of multi-valued attributes and address is an example of the
composite attribute, because it can be divided into house number, street, city, and state.

Complex attributes

Components
Email, Phone number, Address(All are separated by commas and multi-valued components are
represented between curly braces).
Complex Attribute: Address_EmPhone(You can choose any name).
8. Key attribute
Key attributes are those attributes that can uniquely identify the entity in the entity set.
Example: Roll-No is the key attribute because it can uniquely identify the student.
9. Null Attribute
This attribute can take NULL value when entity does not have value for it.
Example –The ‘Net Banking Active Bin’ attribute gives weather particular customer having net banking
facility activated or not activated.
For bank which does not offer facility of net banking in customer table ‘Net Banking Active Bin’ attribute
is always null till Net banking facility is not activated as this attribute indicates Bank offers net banking
facility or does not offers.
10. Descriptive Attribute
Descriptive attribute give information about the relationship set example given below. Here Start Date is
the descriptive attribute of Manages relationship.
Descriptive-Attribute

3) 2PL concurrency control protocol

Two Phase Locking
The Two-Phase Locking (2PL) Protocol is a key technique used in database management systems to
manage how multiple transactions access and modify data at the same time. When many users or
processes interact with a database, it’s important to ensure that data remains consistent and error-free.
Without proper management, issues like data conflicts or corruption can occur if two transactions try to
use the same data simultaneously.
The Two-Phase Locking Protocol resolves this issue by defining clear rules for managing data locks. It
divides a transaction into two phases:
1. Growing Phase: In this step, the transaction gathers all the locks it needs to access the required
data. During this phase, it cannot release any locks.
2. Shrinking Phase: Once a transaction starts releasing locks, it cannot acquire any new ones.
This ensures that no other transaction interferes with the ongoing process.
Types of Lock
Shared Lock (S): Shared Lock is also called a read-only lock, allows multiple transactions to access the
same data item for reading at the same time. However, transactions with this lock cannot make changes
to the data. A shared lock is requested using the lock-S instruction.
Exclusive Lock (X): An Exclusive Lock allows a transaction to both read and modify a data item. This
lock is exclusive, meaning no other transaction can access the same data item while this lock is held. An
exclusive lock is requested using the lock-X instruction.

4)Trigger –
is a statement that a system executes automatically when there is any modification to the database. In a
trigger, we first specify when the trigger is to be executed and then the action to be performed when the
trigger executes. Triggers are used to specify certain integrity constraints and referential constraints that
cannot be specified using the constraint mechanism of SQL.

Example –
Suppose, we are adding a tuple to the ‘Donors’ table that is some person has donated blood. So, we can
design a trigger that will automatically add the value of donated blood to the ‘Blood record’ table.

Types of Triggers –

We can define 6 types of triggers for each table:

1. AFTER INSERT activated after data is inserted into the table.

2. AFTER UPDATE: activated after data in the table is modified.

3. AFTER DELETE: activated after data is deleted/removed from the table.

 4. BEFORE INSERT: activated before data is inserted into the table.

5. BEFORE UPDATE: activated before data in the table is modified.

6. BEFORE DELETE: activated before data is deleted/removed from the table.

5) What is Lossless Decomposition

Lossless join decomposition is a decomposition of a relation R into relations R1, and R2 such that if we
perform a natural join of relation R1 and R2, it will return the original relation R. This is effective in
removing redundancy from databases while preserving the original data.
In other words by lossless decomposition, it becomes feasible to reconstruct the relation R from
decomposed tables R1 and R2 by using Joins.
Only 1NF,2NF,3NF, and BCNF are valid for lossless join decomposition.
In Lossless Decomposition, we select the common attribute and the criteria for selecting a common
attribute is that the common attribute must be a candidate key or super key in either relation R1, R2, or
both.
Decomposition of a relation R into R1 and R2 is a lossless-join decomposition if at least one of the
following functional dependencies is in F+ (Closure of functional dependencies)

QP 3
Q1 What is data abstraction and data independence.
Database systems comprise complex data structures. In order to make the system efficient in terms of
retrieval of data, and reduce complexity in terms of usability of users, developers use abstraction i.e. hide
irrelevant details from the users. This approach simplifies database design.
Level of Abstraction in a DBMS
There are mainly 3 levels of data abstraction:
• Physical or Internal Level
• Logical or Conceptual Level
• View or External Level
Physical or Internal Level
This is the lowest level of data abstraction. It tells us how the data is actually stored in memory. Access
methods like sequential or random access and file organization methods like B+ trees and hashing are
used for the same. Usability, size of memory, and the number of times the records are factors that we
need to know while designing the database.
Suppose we need to store the details of an employee. Blocks of storage and the amount of memory used
for these purposes are kept hidden from the user.
Logical or Conceptual Level
This level comprises the information that is actually stored in the database in the form of tables. It also
stores the relationship among the data entities in relatively simple structures. At this level, the information
available to the user at the view level is unknown.
We can store the various attributes of an employee and relationships, e.g. with the manager can also be
stored.
The logical level thus describes the entire database in terms of a small number of relatively simple
structures. Although implementation of the simple structures at the logical level may involve complex
physical-level structures, the user of the logical level does not need to be aware of this complexity. This
is referred to as physical data independence. Database administrators, who must decide what information
to keep in the database, use the logical level of abstraction.
View or External Level
This is the highest level of abstraction. Only a part of the actual database is viewed by the users. This
level exists to ease the accessibility of the database by an individual user. Users view data in the form of
rows and columns. Tables and relations are used to store data. Multiple views of the same database may
exist. Users can just view the data and interact with the database, storage and implementation details are
hidden from them. Even though the logical level uses simpler structures, complexity remains because of
the variety of information stored in a large database. Many users of the database system do not need all
this information; instead, they need to access only a part of the database. The view level of abstraction
exists to simplify their interaction with the system
Example: In case of storing customer data,
• Physical level – it will contains block of storages (bytes,GB,TB,etc)
• Logical level – it will contain the fields and the attributes of data.
• View level – it works with CLI or GUI access of database

Data Abstraction

The main purpose of data abstraction is to achieve data independence in order to save the time and cost
required when the database is modified or altered.
Data Independence
Data Independence is mainly defined as a property of DBMS that helps you to change the database
schema at one level of a system without requiring to change the schema at the next level. it helps to keep
the data separated from all program that makes use of it.
We have namely two levels of data independence arising from these levels of abstraction:
• Physical level data independence
• Logical level data independence

Data Independence
Physical Level Data Independence
It refers to the characteristic of being able to modify the physical schema without any alterations to the
conceptual or logical schema, done for optimization purposes, e.g., the Conceptual structure of
the database would not be affected by any change in storage size of the database system server. Changing
from sequential to random access files is one such example. These alterations or modifications to the
physical structure may include:
• Utilizing new storage devices.
• Modifying data structures used for storage.
• Altering indexes or using alternative file organization techniques etc.
Logical Level Data Independence
It refers characteristic of being able to modify the logical schema without affecting the external schema
or application program. The user view of the data would not be affected by any changes to the conceptual
view of the data. These changes may include insertion or deletion of attributes, altering table structures
entities or relationships to the logical schema, etc.

Q2 Draw Extended E-R diagram for, Hospital Management System.

Q3 Explain types of joins with suitable example. Types of Join statements

The type of join statement you use depends on your use case. There are four different types of join
operations:

• (INNER) JOIN: Returns dataset that have matching values in both tables
• LEFT (OUTER) JOIN: Returns all records from the left table and matched records from the right
• RIGHT (OUTER) JOIN: Returns all records from the right table and the matched records from the
left
• FULL (OUTER) JOIN: Returns all records when there is a match in either the left table or right
table

Inner Joins

If you were to think of each table as a separate circle in a Venn diagram, the inner join would be the shaded
area where both circles intersect.

The INNER JOIN keyword selects all rows from the tables as long as a join condition satisfies. This
keyword will create a result-set made up of combined rows from both tables where a common field exists.
Here is the syntax for an inner join:
SELECT column name(s)
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;

Right outer Joins

This join statement takes all the records from Table B whether or not they have NULL values and the
matching columns from Table A.

Right join returns all the rows of the rightmost table of and the matching rows for the leftmost table. RIGHT
JOIN is also known as RIGHT OUTER. Here is the syntax:

SELECT column_name(s)
FROM table1
RIGHT JOIN table2
ON table1.column_name = table2.column_name;

Left outer Joins

Left join is similar to right join. Left join returns all the rows of the leftmost table and the matching rows
for the rightmost table. Below is the syntax:
SELECT column_name(s)
FROM table1
LEFT JOIN table2
ON table1.column_name = table2.column_name;

In this example, all of the records from the Customers table are listed (whether or not they have NULL
values) along with the matching columns in the Orders table.

Full Joins

Full joins are also known as full outer joins. This basically means that a query would combine data and
return records from both tables no matter if they had NULL values.

FULL JOIN creates a result-set by combining the results of the left and right joins, including all the rows.
For the rows that do not match. the result-set (joined table) will shows NULL values. The syntax is as
follows:

SELECT column_name(s)
FROM table1
FULL OUTER JOIN table2
ON table1.column_name = table2.column_name
WHERE condition;

Q4 Explain any five relational algebra operators with suitable example.

Already done

Q5 Define deadlock and Explain deadlock handling.

Already done

Q 6 What is 2PL, Explains its types.

Need to check.

Q7 What is Trigger, Explain with Syntax and example:

Need to check.

Q8 Explain view and conflict serializability with suitable example.

Need to check.

Q 9 What is normalization. Explain INF, 2NF,3NF with suitable example

Already done

Q 10 ACID properties of transaction with example.

Already done

Transaction state diagram and explain TCL commands need to check.

Types of users in DBMS

Already done

QP 4

Q1 Explain the concept of data independence

In the context of a database management system, data independence is the feature that allows the schema
of one layer of the database system to be changed without any impact on the schema of the next higher
level of the database system. ” Through data independence, we can build an environment in which data
is independent of all programs, and through the three schema architectures, data independence will be
more understandable. Data via two card stencils along with centralized DBMS data is a form of
transparency that has value for someone.
It can be summed up as a sort of immunity of user applications that adjusts correctly and does not change
addresses, imparting the class of data and their order. I want the separate applications not to be forced to
deal with data representation and storage specifics because this decreases quality and flexibility. DBMS
permits you to see data with such a generalized sight. It actually means that the ability to change the
structure of the lower-level schema without presenting the upper-level schema is called data
independence.

Discuss the differences between logical and physical data independence.

Physical Data Independence Logical Data Independence

It mainly concern about how the data is stored It mainly concerned about the structure or the
into the system. changing data definition.

It is difficult to retrieve because the data is mainly

It is easy to retrieve.
dependent on the logical structure of data.

As compared to the logical independence it is As compared to the physical independence it is not

easy to achieve physical data independence. easy to achieve logical data independence.

Any change at the physical level, does not The change in the logical level requires a change at
require to change at the application level. the application level.

The modifications made at the internal level The modifications made at the logical level is
may or may not be needed to improve the significant whenever the logical structure of the
performance of the structure. database is to be changed.

It is concerned with the internal schema. It is concerned with the conceptual schema.

Example: Change in compression techniques,

Example: Add/Modify or Delete a new attribute.
Hashing algorithms and storage devices etc.

Q 3 Describe weak entity, Provide an example of weak entity and strong entity.

What is a Strong Entity?

A strong entity is not dependent on any other entity in the schema. A strong entity will always have a
primary key. Strong entities are represented by a single rectangle. The relationship of two strong entities
is represented by a single diamond. Various strong entities, when combined together, create a strong
entity set.
What is a Weak Entity?
A weak entity is dependent on a strong entity to ensure its existence. Unlike a strong entity, a weak entity
does not have any primary key. It instead has a partial discriminator key. A weak entity is represented by
a double rectangle. The relation between one strong and one weak entity is represented by a double
diamond. This relationship is also known as an identifying relationship.

example of weak entity and strong entity.

Need to check.

Q4 List and briefly explain SQL aggregate functions with suitable examples.

Need to check.

Q5 Explain the concept of First Normal Form (INF). Give example for the same.

First Normal Form

If a relation contains a composite or multi-valued attribute, it violates the first normal form, or the relation
is in the first normal form if it does not contain any composite or multi-valued attribute. A relation is in
first normal form if every attribute in that relation is single-valued attribute.
A table is in 1 NF if:
 • There are only Single Valued Attributes.
• Attribute Domain does not change.
• There is a unique name for every Attribute/Column.
• The order in which data is stored does not matter.
Rules for First Normal Form (1NF) in DBMS
To follow the First Normal Form (1NF) in a database, these simple rules must be followed:
1. Every Column Should Have Single Values
Each column in a table must contain only one value in a cell. No cell should hold multiple values. If a
cell contains more than one value, the table does not follow 1NF.
• Example: A table with columns like [Writer 1], [Writer 2], and [Writer 3] for the same book
ID is not in 1NF because it repeats the same type of information (writers). Instead, all writers
should be listed in separate rows.
2. All Values in a Column Should Be of the Same Type
Each column must store the same type of data. You cannot mix different types of information in the same
column.
• Example: If a column is meant for dates of birth (DOB), you cannot use it to store names. Each
type of information should have its own column.
3. Every Column Must Have a Unique Name
Each column in the table must have a unique name. This avoids confusion when retrieving, updating, or
adding data.
• Example: If two columns have the same name, the database system may not know which one
to use.
4. The Order of Data Doesn’t Matter
In 1NF, the order in which data is stored in a table doesn’t affect how the table works. You can organize
the rows in any way without breaking the rules.
Example:
Consider the below COURSES Relation :

• In the above table, Courses has a multi-valued attribute, so it is not in 1NF. The Below Table
is in 1NF as there is no multi-valued attribute.

Q6 Discuss conflict serializability with suitable example.

Need to check.

Q7 Describe the overall architecture of DBMS with suitable diagram

Components of a Database System
Query Processor, Storage Manager, and Disk Storage. These are explained as following below.

Architecture of DBMS

1. Query Processor
It interprets the requests (queries) received from end user via an application program into instructions. It
also executes the user request which is received from the DML compiler. Query Processor contains the
following components –
• DML Compiler: It processes the DML statements into low level instruction (machine
language), so that they can be executed.
• DDL Interpreter: It processes the DDL statements into a set of table containing meta data
(data about data).
• Embedded DML Pre-compiler: It processes DML statements embedded in an application
program into procedural calls.
• Query Optimizer: The Query Optimizer executes instructions generated by the DML
Compiler and improves query execution efficiency by choosing the best query plan,
considering factors such as indexing, join order, and available system resources. For instance,
if a query involves joining two large tables, the optimizer will select the best join order to
minimize query execution time.
2. Storage Manager
Storage Manager is an interface between the data stored in the database and the queries received. It is
also known as Database Control System. It maintains the consistency and integrity of the database by
applying the constraints and executing the DCL statements. It is responsible for updating, storing,
deleting, and retrieving data in the database. It contains the following components:
• Authorization Manager: It ensures role-based access control, i.e,. checks whether the
particular person is privileged to perform the requested operation or not.

• Integrity Manager: It checks the integrity constraints when the database is modified.

• Transaction Manager: It controls concurrent access by performing the operations in a

scheduled way that it receives the transaction. Thus, it ensures that the database remains in the
consistent state before and after the execution of a transaction.
 • File Manager: It manages the file space and the data structure used to represent information
in the database.

• Buffer Manager: It is responsible for cache memory and the transfer of data between the
secondary storage and main memory.

3. Disk Storage
It contains the following essential components:
• Data Files: It stores the actual data in the database.
• Data Dictionary: It contains the information about the structure of database objects such as
tables, constraints, and relationships. It is the repository of information that governs the
metadata.
• Indices: Provides faster data retrieval by allowing the DBMS to find records quickly,
improving query performance.
Levels of DBMS Architecture
The structure of a Database Management System (DBMS) can be divided into three main components:
the Internal Level, the Conceptual Level, and the External Level.
1. Internal Level
This level represents the physical storage of data in the database. It is responsible for storing and
retrieving data from the storage devices, such as hard drives or solid-state drives. It deals with low-level
implementation details such as data compression, indexing, and storage allocation.
2. Conceptual Level
This level represents the logical view of the database. It deals with the overall organization of data in the
database and the relationships between them. It defines the data schema, which includes tables, attributes,
and their relationships. The conceptual level is independent of any specific DBMS and can be
implemented using different DBMSs.
3. External Level
This level represents the user’s view of the database. It deals with how users access the data in the
database. It allows users to view data in a way that makes sense to them, without worrying about the
underlying implementation details. The external level provides a set of views or interfaces to the database,
which are tailored to meet the needs of specific user groups.
Schema Mapping in DBMS
The three levels are connected via schema mapping, ensuring that changes at one level (e.g., the
conceptual level) are accurately reflected in the others. This process maintains data independence,
allowing changes in physical storage (internal level) without affecting the logical or user views.
Role of Database Administrator (DBA)
In addition to these three levels, a DBMS also includes a Database Administrator (DBA) component,
which is responsible for managing the database system. The DBA performs critical tasks such as:
• Database design and architecture.
• Security management: Implementing role-based access control (RBAC), encryption, and
ensuring strong authentication measures such as multi-factor authentication (MFA).
• Backup and recovery: Regularly creating backups and preparing recovery plans in case of
data loss.
• Performance tuning: Optimizing database performance, including query optimization,
indexing, and resource management to ensure the DBMS runs efficiently

Q8 What is deadlock? Explain wait-die and wound-wait methods with suitable Example

Done

Q 9 Draw an E-R diagram for library management system. Convert it into relational schema

need to check

Q 10Explain the following Relational Algebra operations with suitable example.

1) Project 2) Select 3) Union 4) Rename Already done

5) Set difference need to check

Q 11 Consider the following employee database.

Employee (empname, street, city, date_ of _joining)

Works (empname, company_name,salary)

Company (company_name, city)

Write SQL queries for the following statements.

L. Modify the database so that "John' now lives in 'Mumbai"

2. Find all employees who joined in the month of October.

3. Give all employees of ' ABC Corporation" à 10% raise

4. Find all employees who cam more than average salary of all employees

of their company s.com

5. List name of companies starting with letter."A"

Need to check.

Q 12 Why there is need of normalization? Explain INF, 2NF 3NF and BCNF with

Done.

Q13 Describe ACID properties with examples

Done.