DBMS ASSIGNMENT-1

Q1 Explain about the three schema architecture in detail?

The Three-Schema Architecture is a framework in database systems that separates the

system’s structure into three distinct levels, aiming to provide data abstraction
and independence. These levels are:

Internal Schema (Physical Level):

This schema describes how data is physically stored in the database, including file
structures, indexing, and storage details. It focuses on optimizing storage,
retrieval efficiency, and the physical management of data. The internal schema is
hidden from users and application developers.
Conceptual Schema (Logical Level):

This is the central level that defines the overall structure of the database in
terms of entities, relationships, and constraints, without focusing on physical
storage. It represents the entire database’s logical view, covering what data is
stored and the relationships between the data elements. The conceptual schema
provides a unified view of data to database administrators and developers,
abstracting away the complexities of physical storage.
External Schema (View Level):

The external schema represents individual user or application views of the

database. It customizes the data presentation for different users by showing only
the relevant data they are authorized to access. This allows for multiple user
perspectives without affecting the underlying data structure.
Benefits:
Data independence: Changes at one level do not affect the others.
Security and customization: Different users can have customized views while
accessing the same database.

Q-2 What are data models? Explain with its classification?

Data models are conceptual frameworks that describe how data is organized, stored,
and managed within a database system. They define the structure of the data,
relationships between data elements, and constraints, offering a blueprint for
designing databases.

Key Components of a Data Model:

Entities: Represent real-world objects or concepts (e.g., customers, products).
Attributes: Characteristics or properties of entities (e.g., name, age).
Relationships: Associations between entities (e.g., a customer placing an order).
Classification of Data Models:
Hierarchical Data Model:

Organizes data in a tree-like structure, with parent-child relationships. Each

child has only one parent, and relationships are represented as one-to-many.
Example: File systems, early mainframe databases.
Network Data Model:

Similar to the hierarchical model, but allows each child to have multiple parents.
It uses a graph structure, making it more flexible for many-to-many relationships.
Example: Early telecommunications and banking systems.
Relational Data Model:

Represents data in tables (relations), where each row is a record and each column
is an attribute. Relationships are established through foreign keys.
Example: SQL-based databases like MySQL, PostgreSQL.
Object-Oriented Data Model:

Integrates object-oriented programming principles where data and its behaviors

(methods) are encapsulated within objects.
Example: Object databases like db4o, ObjectDB.

Q-3 Explain the concept of Generalization, specialization and Aggregation with

example?

Generalization, Specialization, and Aggregation are important concepts in the

Entity-Relationship (ER) model, used to define relationships between entities and
refine database design.

1. Generalization:
Generalization is the process of combining two or more lower-level entities into a
higher-level, more generalized entity. It highlights common features shared by
multiple entities.
Example: In a university database, entities like Professor and Student can be
generalized into a higher-level entity Person, since both share common attributes
like name, address, and ID. This reduces redundancy by consolidating shared
attributes in a general entity.
2. Specialization:
Specialization is the opposite of generalization, where a higher-level entity is
divided into two or more specialized lower-level entities based on unique
attributes or behaviors.
Example: The Person entity can be specialized into Student and Professor, where
Student has additional attributes like course_enrolled, and Professor has
attributes like department and salary.
3. Aggregation:
Aggregation is a concept where a relationship itself is treated as a higher-level
entity. It is useful when entities and relationships need to be abstracted together
to represent more complex associations.
Example: In a project management database, a Works_On relationship between Employee
and Project can be aggregated into a higher-level entity like Project_Assignment,
showing how multiple employees contribute to various projects.

Q-4 Write the comparison between the Relational model, Object-oriented and Semi-
Structured model?

1. Relational Model:
Structure: Data is organized in tables (relations) with rows (tuples) and columns
(attributes). Each table has a primary key to uniquely identify rows, and foreign
keys to establish relationships.
Data Flexibility: Less flexible, requires predefined schemas. Data must adhere to
strict tabular format.
Query Language: Uses SQL for querying and managing data.
Use Case: Best for applications with structured, consistent data and well-defined
relationships (e.g., banking, HR systems).
Example: MySQL, PostgreSQL.

2. Object-Oriented Model:
Structure: Data is stored as objects, which encapsulate both data (attributes) and
behaviors (methods). Supports inheritance, polymorphism, and encapsulation.
Data Flexibility: More flexible as objects can represent complex data and
relationships. It aligns closely with object-oriented programming.
Query Language: Often uses OQL (Object Query Language) or proprietary languages.
Use Case: Suitable for complex applications involving multimedia, CAD, and real-
time systems.
Example: ObjectDB, db4o.

3. Semi-Structured Model:
Structure: Data is stored without a rigid schema, often in hierarchical or tree-
like formats (e.g., XML, JSON). Attributes can vary across entries.
Data Flexibility: Highly flexible, accommodating irregular or incomplete data.
Query Language: Uses languages like XPath or XQuery.
Use Case: Ideal for web data, document-based systems, and applications where schema
flexibility is needed.
Example: MongoDB, CouchDB (NoSQL databases).

Q-5 Explain about the DBA and also its roles and responsibilities?

A Database Administrator (DBA) is responsible for managing, maintaining, and

securing a database system to ensure its optimal performance, availability, and
security. DBAs play a critical role in organizations by overseeing the day-to-day
operations of databases, ensuring data integrity, and supporting the needs of users
and applications.

Roles and Responsibilities of a DBA:

Database Design and Implementation:

Design and develop the database structure, including tables, indexes, and
relationships, based on application needs. They may also assist in database
normalization and schema refinement.
Database Security:

Ensure that databases are secure by implementing appropriate access controls,

encryption, and monitoring unauthorized access. DBAs also manage user roles and
permissions.
Backup and Recovery:

Perform regular database backups and establish disaster recovery plans. In the
event of data loss, the DBA restores databases to minimize downtime and data loss.
Performance Tuning:

Monitor and optimize database performance through indexing, query optimization, and
resource allocation (e.g., CPU, memory). This ensures efficient data retrieval and
system responsiveness.
Data Integrity and Quality:

Enforce data integrity rules (constraints, triggers) to ensure the accuracy and
consistency of stored data.
Monitoring and Maintenance:

Regularly monitor the database system’s health, perform updates, patches, and
resolve any issues (e.g., database crashes, slowdowns).

Q-6 Explain about ER Diagram with an example?

An Entity-Relationship (ER) Diagram is a visual representation of the relationships

between entities in a database. It serves as a blueprint for database design,
illustrating how data is structured and how different entities (objects, concepts)
are related. ER diagrams consist of three primary components: entities, attributes,
and relationships.

Key Components:
Entities: Represent real-world objects or concepts (e.g., Employee, Department).
They are depicted as rectangles.
Attributes: Characteristics of entities (e.g., Employee has attributes like name,
ID, and salary). Attributes are shown as ovals.
Relationships: Define how entities are connected (e.g., an Employee works for a
Department). Relationships are shown as diamonds and can be one-to-one, one-to-
many, or many-to-many.
Example:
Consider a university database with the following:

Entities: Student, Course, and Instructor.

Attributes: The Student entity has attributes like Student_ID, Name, and DOB. The
Course entity has attributes like Course_ID and Course_Name.
Relationships:
A Student "enrolls in" a Course (many-to-many relationship).
An Instructor "teaches" a Course (one-to-many relationship).

ASSIGNMENT- II

Q-1 Explain about the relational data model with an example?

The Relational Data Model is a framework for organizing data into tables (also
called relations), where each table consists of rows and columns. It is one of the
most widely used models in database management systems due to its simplicity,
flexibility, and efficiency. In this model, data is stored in tabular format, and
relationships between tables are established using keys.

Key Components:
Relation (Table): A table is a collection of data organized into rows (records) and
columns (attributes). Each row represents a unique instance of the data.
Attributes (Columns): Define the characteristics or properties of the data stored
in a table. Each column has a specific data type.
Tuples (Rows): Represent individual records in the table.
Primary Key: A unique identifier for each row in a table.
Foreign Key: A key used to establish relationships between tables, connecting a
primary key from one table to another.
Example:
Consider a database for a school system with two tables: Students and Courses.

The Students table has columns like Student_ID (Primary Key), Name, and Age.
The Courses table has columns like Course_ID (Primary Key), Course_Name, and
Student_ID (Foreign Key referencing Students).

Q-2 Explain about the concepts of keys? Explain in detail about candidate key,
super key with example?

In the Relational Data Model, keys are used to uniquely identify records in a table
and establish relationships between tables. They ensure data integrity and avoid
duplication.

Key Types:
Primary Key: A column (or combination of columns) that uniquely identifies each row
in a table. It cannot be NULL and must contain unique values.
Foreign Key: A column in one table that references the primary key in another
table, creating a relationship between the two tables.
Unique Key: Ensures all values in a column are unique, but unlike the primary key,
it can accept one NULL value.
Concepts of Super Key and Candidate Key:
Super Key:

A super key is any combination of attributes that can uniquely identify a row in a
table. It may contain more attributes than necessary.
Example: In a table Students (Student_ID, Name, Email), both Student_ID and
(Student_ID, Email) can be super keys because they uniquely identify each student.
However, (Student_ID, Email) has redundant attributes.
Candidate Key:

A candidate key is a minimal super key, meaning it contains only the essential
attributes needed to uniquely identify a record. There can be multiple candidate
keys, but none of them will have unnecessary attributes.
Example: In the same Students table, Student_ID and Email are candidate keys
because each can uniquely identify a student without extra attributes.

Q-3 Illustrate about integrity and key constraints with suitable examples?

Integrity constraints are rules that ensure the accuracy and consistency of data in
a database. They enforce data validity and prevent invalid data from being stored.
Key constraints are a subset of integrity constraints that define how keys behave
in a relational database. Together, they play a crucial role in maintaining data
integrity.

Types of Integrity Constraints:

Entity Integrity:

Ensures that every table has a primary key, and that key must contain unique, non-
null values.
Example: In a Students table, the Student_ID column (primary key) must have a
unique value for every student, and it cannot be NULL.
Referential Integrity:

Ensures that foreign keys correctly reference primary keys in other tables,
maintaining relationships between tables.
Example: If a Courses table has a foreign key Student_ID that references the
Student_ID in the Students table, it guarantees that no course can be assigned to a
non-existent student. If a student is deleted, the database will either restrict
the deletion or cascade the changes.
Key Constraints:
Primary Key Constraint:

A column (or a combination of columns) designated as the primary key must be unique
and cannot contain NULL values.
Example: The Employee_ID column in an Employees table ensures each employee is
uniquely identifiable.
Foreign Key Constraint:

Ensures that the values in a foreign key column correspond to valid values in the
referenced table’s primary key.
Example: In an Orders table, the Customer_ID foreign key must reference a valid
Customer_ID in the Customers table.

Q-4 Write short note on :

a)DDL
b)DML
c)TCL

**a) Data Definition Language (DDL)**:

DDL is a subset of SQL (Structured Query Language) used for defining and managing
all structures in a database. It includes commands that create, alter, and delete
database objects like tables, indexes, and views. Key DDL commands include:
- **CREATE**: To create new database objects (e.g., tables).
- **ALTER**: To modify existing database objects (e.g., adding or deleting
columns).
- **DROP**: To remove database objects permanently.
DDL statements are typically auto-committed, meaning they are immediately saved to
the database upon execution.

**b) Data Manipulation Language (DML)**:

DML is a set of SQL commands used for managing data within database objects. It
allows users to insert, update, delete, and retrieve data. Key DML commands
include:
- **INSERT**: To add new records to a table.
- **UPDATE**: To modify existing records.
- **DELETE**: To remove records from a table.
- **SELECT**: To query and retrieve data from one or more tables.
DML commands may require explicit transaction control, meaning changes may need to
be committed or rolled back.

**c) Transaction Control Language (TCL)**:

TCL is a subset of SQL used to manage transactions in a database. It ensures data
integrity and consistency by grouping multiple DML operations into a single
transaction. Key TCL commands include:
- **COMMIT**: To save all changes made during the current transaction.
- **ROLLBACK**: To undo changes made during the current transaction.
- **SAVEPOINT**: To set a point within a transaction to which you can later roll
back.
TCL is crucial for maintaining data accuracy, especially in multi-user
environments.

Q-5 Explain about the relational calculus and its operations?

**Relational Calculus** is a non-procedural query language used in relational

databases that allows users to specify what data to retrieve without detailing how
to obtain it. Unlike relational algebra, which focuses on operations and processes,
relational calculus emphasizes describing the desired result. There are two primary
forms of relational calculus:

1. **Tuple Relational Calculus (TRC)**:

- In TRC, queries are expressed using tuples. A query is formed by specifying
the properties of tuples that must be satisfied.
- Syntax: `{t | P(t)}`, where `t` is a tuple variable and `P(t)` is a predicate
that defines the conditions.
- **Example**: To retrieve names of students enrolled in a course: `{t.name |
Student(t) AND Enrolled(t, courseID)}`.

2. **Domain Relational Calculus (DRC)**:

- DRC focuses on the attributes of tuples. Queries specify the values of
attributes rather than tuples themselves.
- Syntax: `{<x1, x2, ..., xn> | P(x1, x2, ..., xn)}`, where `xi` represents
domain variables.
- **Example**: To get names of students: `{<name> | ∃ID (Student(ID, name))}`.

### Operations:
While relational calculus itself does not define operations like relational
algebra, it uses logical operations (AND, OR, NOT) and quantifiers (∃, ∀) to
express conditions. The primary goal is to focus on the “what” of data retrieval,
making it a powerful tool for defining queries in a more declarative manner.
ASSIGNMENT- III

Q-1 What is the need of normalization? Explain.

Normalization is a database design process that organizes data to reduce redundancy

and improve data integrity. The goal is to minimize duplication and avoid data
anomalies, ensuring the database operates efficiently and consistently.

Key Benefits and Need for Normalization:

Eliminate Redundancy:

Redundant data leads to unnecessary storage consumption and can cause data
inconsistency. For example, if the same customer’s information is stored in
multiple tables, updating it in one place but not the other leads to mismatched
data. Normalization ensures data is stored in one place, avoiding duplication.
Improve Data Integrity:

Normalization enforces data integrity by organizing the database into well-

structured tables with clear relationships. This helps maintain accurate data by
preventing anomalies during insertions, updates, and deletions.
Efficient Data Management:

With normalized tables, complex queries are easier to write and maintain. By
reducing redundant data, the database becomes more efficient, as fewer data
manipulations are needed, and search operations can be optimized.
Avoid Data Anomalies:

Without normalization, databases are prone to anomalies such as:

Insertion anomaly: Inability to add new data due to missing dependencies.
Update anomaly: Changing data in one place and not others.
Deletion anomaly: Unintended data loss when deleting data.

Q-2 What is BCNF? How does it differ from 3NF?

Boyce-Codd Normal Form (BCNF) is an advanced version of the Third Normal Form
(3NF). Both are used in the process of database normalization to eliminate
redundancy and prevent update anomalies, but BCNF is stricter than 3NF in dealing
with certain types of functional dependencies.

BCNF (Boyce-Codd Normal Form):

A table is in BCNF if:

It is in 3NF.
For every non-trivial functional dependency (A → B), the left-hand side (A) must be
a super key (i.e., A should uniquely identify every tuple in the table).
BCNF resolves the limitations of 3NF by ensuring that even if a relation is in 3NF,
it does not have partial dependencies or transitive dependencies in cases where the
primary key is composite or where functional dependencies involve super keys.

3NF (Third Normal Form):

A table is in 3NF if:

It is in 2NF.
For every functional dependency (A → B), B is either:
A part of a candidate key.
A non-prime attribute (an attribute not part of any candidate key).
Difference Between BCNF and 3NF:
3NF allows a non-prime attribute to depend on another non-prime attribute if the
latter is part of a candidate key (a more lenient condition).
BCNF requires all determinants (left side of dependencies) to be super keys,
eliminating certain anomalies that 3NF may not handle.

Q-3 What is functional dependency and also write example?

Functional dependency (FD) is a key concept in relational database design that

defines a relationship between two sets of attributes in a table. It occurs when
the value of one attribute (or a group of attributes) uniquely determines the value
of another attribute.

Definition:
A functional dependency is represented as X → Y, where:

X is the determinant (a set of one or more attributes).

Y is the dependent attribute.
This means that for every unique value of X, there is only one corresponding value
of Y. In other words, knowing the value of X allows us to determine the value of Y.

Example:
Consider a table Students with the following attributes:

Student_ID (unique ID of each student)

Student_Name (name of the student)
Course_ID (ID of the course the student is enrolled in)
Course_Name (name of the course)
In this scenario, the following functional dependencies exist:

Student_ID → Student_Name: The value of Student_ID uniquely determines the

student's name.
Course_ID → Course_Name: The value of Course_ID uniquely determines the course
name.

Q-4 Compute the closure of the following set F of functional dependencies for
relation schema R (ABCDE). F = {A->BC, CD->E, B->D, E->A} List the candidate keys
for R.

Given Relation Schema:

R = {A, B, C, D, E}

Set of Functional Dependencies (F):

A → BC
CD → E
B → D
E → A
Step 1: Closure of Attribute Sets
To compute the closure of attributes, we determine which attributes can be derived
from a given attribute set using the functional dependencies. The closure of an
attribute set X (denoted X⁺) includes all attributes that can be functionally
derived from X.

Step 2: Compute A⁺ (Closure of A)

Start with A:

A → BC (From F, A determines B and C)

B → D (Using B, A can determine D)
CD → E (With C and D, A can determine E)
E → A (Since we already have A)
Thus, A⁺ = {A, B, C, D, E}, meaning A can derive all attributes of R.

Step 3: Candidate Keys

A candidate key is a minimal set of attributes that can determine all other
attributes in the relation.

From A⁺ = {A, B, C, D, E}, we see that A alone can determine all attributes of R.
Therefore, A is a candidate key.
Step 4: Check for Other Candidate Keys
Now, check other combinations:

B⁺ = {B, D} (B → D, and no further dependencies)

C⁺ = {C} (C alone does not derive any more attributes)
D⁺ = {D} (D alone does not derive any more attributes)
E⁺ = {A, B, C, D, E} (E → A, and from A, we get the closure as previously computed)
Since no other minimal set can derive all attributes, A and E are candidate keys.

Q-5 Write a short note on:

i)Lossless Decomposition
ii) Dangling Tuples
iii)Multi valued Dependency

i) Lossless Decomposition:
Lossless decomposition is a property of database decomposition that ensures no data
is lost when a relation (table) is divided into two or more sub-relations. In other
words, after decomposing a table, the original relation can be perfectly
reconstructed by joining the sub-relations. Lossless decomposition is crucial for
preserving the integrity and completeness of data during normalization.

Example: A table R(A, B, C) is decomposed into two tables R1(A, B) and R2(B, C). If
the join of R1 and R2 results in the original R without loss or duplication of
information, the decomposition is lossless.
ii) Dangling Tuples:
Dangling tuples refer to records in one table that have no corresponding matching
records in a related table when foreign key constraints are not enforced or
properly maintained. This situation can occur in database joins, leading to
incomplete or incorrect query results.

Example: If a table Orders references a non-existent customer in the Customers

table via a foreign key, the order record is said to have a dangling tuple because
there is no valid customer associated with it.
iii) Multi-valued Dependency (MVD):
A multi-valued dependency (MVD) occurs when one attribute in a relation determines
multiple independent values of another attribute. It generalizes functional
dependencies to handle cases where attributes are not strictly dependent but have
multiple associations.

Example: In a table Movie(Title, Actor, Genre), there can be multiple actors for a
single movie title, and multiple genres, leading to an MVD: Title →→ Actor and
Title →→ Genre. MVD is used in 4th Normal Form (4NF) to remove redundancy
associated with such cases.

Q-6 Explain the concept of Query Optimization?

Query Optimization is the process of improving the efficiency of a database query

by finding the most cost-effective way to execute it. The goal of query
optimization is to minimize the resources required (such as CPU time, memory, or
disk I/O) to retrieve the correct results from a database, especially when dealing
with large datasets.

How it Works:
When a query is submitted to a database management system (DBMS), the query
optimizer generates multiple possible execution plans. Each execution plan
represents a different strategy to retrieve the required data, involving different
paths like table scans, index lookups, or joins. The optimizer evaluates these
plans based on factors like:

Estimated execution cost: Resources required to execute the plan.

Data distribution: How the data is stored and accessed.
Index availability: Use of indexes to speed up data retrieval.
Join methods: Different ways to join tables (e.g., nested loops, hash joins).
Example:
If a query involves multiple tables, the optimizer may decide which table to access
first, what indexes to use, or whether to use a full table scan. An optimal plan
could reduce query execution time from seconds to milliseconds.

ASSIGNMENT- IV

Q-1 Discuss the basic concepts of transaction and write ACID properties.

A transaction in a database is a sequence of operations performed as a single

logical unit of work. A transaction ensures that either all operations within it
are completed successfully, or none are applied to the database, maintaining
consistency and integrity. Transactions are essential in multi-user environments
where multiple users may be accessing or modifying the database simultaneously.

Example:
A bank transfer transaction might involve two operations: debiting one account and
crediting another. Both operations must either succeed together or fail together to
ensure data consistency.

ACID Properties:
The ACID properties (Atomicity, Consistency, Isolation, and Durability) are key
principles that ensure reliable transaction processing in a database.

Atomicity:

Ensures that all operations within a transaction are completed successfully or none
are applied. If any part of the transaction fails, the entire transaction is rolled
back.
Example: In a money transfer, either both debit and credit happen, or neither
happens.
Consistency:

Ensures that a transaction takes the database from one consistent state to another.
The integrity of the database must be maintained after the transaction.
Example: Bank account balances must remain valid after a transfer.
Isolation:

Ensures that transactions are executed independently. The intermediate state of a

transaction is invisible to other transactions.
Example: Two simultaneous transfers should not interfere with each other.
Durability:

Guarantees that once a transaction is committed, its results are permanent, even in
the event of system failure.
Example: After a bank transfer is completed, the changes remain saved even if the
system crashes.

Q-3 Explain Log based recovery in brief?

Log-based recovery is a crucial mechanism in database management systems designed

to ensure data integrity and durability in the event of a failure, such as a system
crash or power loss. This recovery technique utilizes a log file that records all
changes made to the database in a sequential manner, allowing the system to restore
the database to a consistent state.

Key Components of Log-Based Recovery:

Log File:

The log file contains entries for every transaction operation, including
timestamps, data modifications, and transaction start/commit/abort actions. This
provides a comprehensive record of all changes made.
Write-Ahead Logging (WAL):

Before any changes are applied to the database, the corresponding log entry is
written first. This ensures that in case of a crash, the system can use the log to
replay or undo operations as needed.
Recovery Process:

Undo: If a transaction is aborted, the recovery process uses the log to revert
changes made by that transaction, ensuring that no partial changes persist in the
database.
Redo: After a crash, the system can replay the log entries for committed
transactions to restore the database to its most recent state.

Q-4 Explain Locking techniques for concurrency control?

Locking techniques are essential mechanisms in database management systems used for
concurrency control, ensuring that multiple transactions can operate on the
database without interfering with one another. Locks prevent conflicts by
regulating access to data items, thereby maintaining consistency and integrity
during simultaneous transactions.

Types of Locks:
Shared Lock (S Lock):

Allows multiple transactions to read (or share) a data item simultaneously.

However, no transaction can modify the data until all shared locks are released.
Example: If Transaction T1 holds a shared lock on a data item, Transaction T2 can
also acquire a shared lock but cannot write to that item.
Exclusive Lock (X Lock):

Grants a transaction exclusive access to a data item for both reading and writing.
Only one transaction can hold an exclusive lock on a data item at any given time.
Example: If Transaction T1 holds an exclusive lock, no other transaction can
acquire any lock (shared or exclusive) on that data item until T1 releases the
lock.
Locking Protocols:
Two-Phase Locking (2PL):
Transactions acquire locks in the growing phase and release them in the shrinking
phase. This ensures that once a transaction releases a lock, it cannot acquire any
new locks, preventing deadlock situations.
Strict Two-Phase Locking (S2PL):
A stricter version of 2PL where transactions are not allowed to release any locks
until they have completed, ensuring serializability.

Q-5 Discuss on strict two phase –locking protocol and time-stamp based protocol?

Strict Two-Phase Locking Protocol (S2PL)

Strict Two-Phase Locking (S2PL) is a concurrency control protocol that enhances the
traditional two-phase locking mechanism by ensuring that once a transaction
releases a lock, it cannot acquire any more locks. This approach has two distinct
phases:

Growing Phase: A transaction can acquire locks but cannot release any.
Shrinking Phase: A transaction releases locks and cannot acquire new ones.
Key Features:
Serializability: S2PL guarantees serializability, meaning the execution of
concurrent transactions is equivalent to some serial execution.
Deadlock Prevention: Although it does not prevent deadlocks outright, it simplifies
deadlock detection because the order of lock acquisition is well-defined.
Time-Stamp Based Protocol
Time-stamp based protocols use timestamps to manage concurrency. Each transaction
is assigned a unique timestamp upon its initiation, which determines the order of
transaction execution. The key components include:

Timestamp Ordering: Transactions are executed based on their timestamps. If a

transaction T1 wants to read or write a data item, the protocol checks the
timestamps of conflicting transactions.
Conflict Resolution: If T1's timestamp is older, it can proceed; otherwise, it may
be rolled back if it violates consistency rules.
Key Features:
Non-Blocking: This approach avoids locking and blocking issues, allowing greater
concurrency.
Ensures Serializability: It guarantees that the results of transactions will be
equivalent to some serial execution order based on timestamps.

Q-6 How concurrency is performed? Explain the protocol that is used to maintain
the concurrency concept?

Concurrency control is essential in database management systems to ensure that

multiple transactions can execute simultaneously without leading to
inconsistencies. The goal is to manage simultaneous operations while maintaining
the integrity of the database. Various protocols are used to achieve effective
concurrency control, primarily focusing on maintaining data consistency and
isolation among transactions.

Key Protocols for Concurrency Control:

Locking Protocols:

Two-Phase Locking (2PL): Transactions acquire locks on data items before accessing
them. It has two phases: a growing phase, where locks are acquired, and a shrinking
phase, where locks are released. This method ensures serializability but may lead
to deadlocks.
Strict Two-Phase Locking (S2PL): A variant of 2PL where transactions hold locks
until they complete, preventing the release of locks before finishing.
Timestamp-Based Protocols:
Each transaction is assigned a unique timestamp, and transactions are executed
based on these timestamps. This ensures that conflicting operations adhere to a
predetermined order, allowing the system to maintain consistency without the need
for locking.
Optimistic Concurrency Control:

Transactions execute without restrictions, but before committing, the system checks
for conflicts. If a conflict is detected, the transaction is rolled back and must
be re-executed.

Q-7 What is serializability ? Write an algorithm for testing conflict

serializabilty of a schedule.

Serializability is a fundamental concept in database management systems that

ensures the correctness of concurrent transaction execution. A schedule (a sequence
of operations from multiple transactions) is said to be serializable if its outcome
is equivalent to that of some serial execution of the transactions, meaning the
transactions can be reordered without affecting the final database state.
Serializability guarantees that concurrent transactions produce results that are
consistent with executing them one after the other.

Algorithm for Testing Conflict Serializability

To test if a schedule is conflict-serializable, we can use a precedence graph (also
known as a serialization graph). Here’s a brief algorithm:

Create Nodes: For each transaction in the schedule, create a node in the graph.

Add Edges:

For every pair of conflicting operations (e.g., reads and writes) between
transactions:
If transaction T1 executes an operation before transaction T2, add a directed edge
from T1 to T2.
Conflicting operations are those that access the same data item, where at least one
is a write.
Check for Cycles:

After constructing the graph, check for cycles.

If the graph contains no cycles, the schedule is conflict-serializable; otherwise,
it is not.

ASSIGNMENT- V

Q-1 Write short note on following:

i) Nested and Parameterized constructor
ii) Branching and looping construct in ANSI SQL
iii)Distributed database

i) Nested and Parameterized Constructors

Nested Constructors are constructors defined within a class that call other
constructors of the same class to initialize objects with different parameter sets.
This allows for a more streamlined initialization process, reducing redundancy in
code. In many programming languages like C++ and Java, constructors can invoke
other constructors using the this keyword.

Example:
class Example {
int value;

Example() {
this(0); // Calls the parameterized constructor
}

Example(int value) {
this.value = value;
}
}

ii) Branching and Looping Constructs in ANSI SQL

Branching Constructs in ANSI SQL enable decision-making within queries. The CASE
statement is the primary branching construct, allowing different actions based on
conditions.

Example:
SELECT
CASE
WHEN score >= 90 THEN 'A'
WHEN score >= 80 THEN 'B'
ELSE 'C'
END AS grade
FROM students;

iii) Distributed Database

A distributed database is a database that is spread across multiple physical
locations but appears to users as a single, unified database. These databases can
be located in the same physical site or in different geographical locations.

Key Characteristics:

Transparency: Users interact with the database as if it were centralized.

Scalability: Easily accommodates growth by adding more nodes.
Fault Tolerance: Offers improved reliability; if one node fails, others can
continue to operate.
Advantages:

Enhanced performance due to localized data access.

Better data availability and disaster recovery.

Q-2 Explain various types of joins with examples.

1. Inner Join:
Returns only the rows that have matching values in both tables.

Example:

SELECT A.id, A.name, B.salary

FROM Employees A
INNER JOIN Salaries B ON A.id = B.employee_id;

2. Left Join (Left Outer Join):

Returns all rows from the left table and the matched rows from the right table. If
there is no match, NULL values are returned for columns from the right table.
Example:

SELECT A.id, A.name, B.salary

FROM Employees A
LEFT JOIN Salaries B ON A.id = B.employee_id;

3. Right Join (Right Outer Join):

Returns all rows from the right table and the matched rows from the left table. If
there is no match, NULL values are returned for columns from the left table.

Example:

SELECT A.id, A.name, B.salary

FROM Employees A
RIGHT JOIN Salaries B ON A.id = B.employee_id;

4. Full Join (Full Outer Join):

Returns all rows when there is a match in either the left or right table. Rows with
no match in either table will have NULLs.

Example:

SELECT A.id, A.name, B.salary

FROM Employees A
FULL JOIN Salaries B ON A.id = B.employee_id;

5. Cross Join:
Returns the Cartesian product of both tables, combining all rows from the first
table with all rows from the second.

Example:

SELECT A.id, B.salary

FROM Employees A
CROSS JOIN Salaries B;

Q-3 Explain triggers and assertion and explain it with through with proper
query?

Triggers:
A trigger is a set of instructions automatically executed in response to certain
events on a specified table. These events can include INSERT, UPDATE, or DELETE
operations. Triggers are used for enforcing business rules, auditing changes, or
maintaining derived data.

Example: Suppose we want to log every time a salary is updated in an Employees

table. We can create an AFTER UPDATE trigger:
CREATE TRIGGER salary_update_trigger
AFTER UPDATE ON Employees
FOR EACH ROW
BEGIN
INSERT INTO SalaryAudit (employee_id, old_salary, new_salary, change_date)
VALUES (OLD.id, OLD.salary, NEW.salary, NOW());
END;
Assertions:
An assertion is a condition defined on the database that must always be true for
all data in the database. Assertions help maintain data integrity by checking that
certain constraints are met before allowing data modifications.

Example: Suppose we want to ensure that no employee’s salary exceeds a specified

limit:

CREATE ASSERTION check_salary_limit

CHECK (NOT EXISTS (SELECT * FROM Employees WHERE salary > 200000));

Q-4 . Explain the following feature of ORACLE:

(i) Sequence (ii) Triggers (iii) SQL loader

(i) Sequence
In Oracle, a sequence is a database object that generates a series of unique
numbers, often used for creating primary key values. Sequences help ensure that no
two rows have the same identifier, making them crucial for maintaining data
integrity. You can define parameters such as the starting value, increment, and
maximum limit.

Example:
CREATE SEQUENCE emp_seq
START WITH 1
INCREMENT BY 1
NOCACHE;

(ii) Triggers
Triggers are procedural code automatically executed in response to specific events
on a table or view, such as INSERT, UPDATE, or DELETE. They are used to enforce
business rules, validate input, and maintain audit trails.

Example:
CREATE OR REPLACE TRIGGER salary_check
BEFORE INSERT ON Employees
FOR EACH ROW
BEGIN
IF :NEW.salary < 0 THEN
RAISE_APPLICATION_ERROR(-20001, 'Salary cannot be negative.');
END IF;
END;

(iii) SQL Loader

SQL Loader is a tool in Oracle that facilitates the bulk loading of data from
external files into Oracle tables. It supports various file formats and can handle
large volumes of data efficiently. Users define a control file that specifies how
the data is formatted and how it should be inserted into the database.

Example: A simple control file might look like this:

LOAD DATA
INFILE 'data.csv'
INTO TABLE Employees
FIELDS TERMINATED BY ','
(id, name, salary)

Q-5 How is the database organized in oracle?

In Oracle, a database is organized into a structured hierarchy that optimizes data
storage, retrieval, and management. The primary components of this organization are
as follows:

1. Tablespaces:
A tablespace is a logical storage unit in Oracle that groups related logical
structures. It contains segments that store data. Each database has at least one
tablespace, often named SYSTEM, which holds essential system data. Other
tablespaces can be created for user data, indexes, etc.

2. Segments:
Each tablespace contains segments, which are the next level of organization. A
segment is a set of extents that stores data for a specific logical structure, such
as a table or an index.

3. Extents:
An extent is a contiguous block of data blocks in the storage space. When a segment
needs more space, Oracle allocates additional extents.

4. Data Blocks:
The smallest unit of storage in Oracle, a data block contains rows of a table or
index entries. The size of a data block can be configured during database creation.

5. Schemas:
A schema is a collection of database objects owned by a single user, including
tables, views, indexes, and procedures. Each user has its own schema.

Q-6 Explain the concept of dedicated and multi-threaded server?

In Oracle databases, the concepts of dedicated and multi-threaded servers pertain

to how client connections are handled and the allocation of server resources.

Dedicated Server
In a dedicated server architecture, each client connection to the Oracle database
is assigned a separate server process. This means that for every user or
application that connects to the database, a new dedicated process is created.

Advantages:

Isolation: Each connection operates independently, reducing the risk of one

connection affecting another.
Performance: Dedicated resources can lead to better performance for resource-
intensive applications.
Disadvantages:

Resource Intensive: This approach consumes more memory and CPU resources,
especially with many concurrent users, as each connection requires its own server
process.
Multi-Threaded Server (MTS)
In a multi-threaded server architecture, multiple client connections share a pool
of server processes. Instead of creating a dedicated server process for each
connection, MTS allows multiple connections to be serviced by fewer server
processes.

Advantages:

Efficiency: Reduces resource usage as multiple client connections share the same
server processes, leading to better scalability for high-concurrency environments.
Lower Overhead: It minimizes the overhead associated with managing numerous
separate processes.
Disadvantages:

Complexity: Increased complexity in managing shared resources, which can lead to

contention issues under heavy loads.