DBMS (SET – 1)

Note: Go to 2nd page last line.

01) Discuss the violations caused by each of the following: dirty read, non-
repeatable read and phantoms with suitable example.

Introduction

Database systems follow the ACID properties (Atomicity, Consistency,

Isolation, Durability) to ensure correct and reliable transactions. Among them, Isolation
ensures that concurrently running transactions do not interfere with each other. If isolation
is not properly maintained, it may result in anomalies such as Dirty Read, Non-Repeatable
Read, and Phantom Read. Below are their violations with suitable examples.

1. Dirty Read

Violation: A transaction reads data that has been modified by another transaction but not
yet committed. If the other transaction is rolled back, the read data becomes invalid.

Example:

• Transaction A updates a customer's account balance from 1000 to 1200 but hasn’t
committed.
• Meanwhile, Transaction B reads the updated balance (1200).
• If Transaction A rolls back its change, the data read by Transaction B is incorrect or
"dirty."

Impact: Leads to inconsistency as one transaction relies on uncommitted, potentially

rollback-prone changes from another.
Isolation Level to Prevent: Read Uncommitted allows it; use Read Committed or higher to
avoid.
2. Non-Repeatable Read

Violation: A transaction reads the same row twice and sees different values because
another committed transaction modified the data in between the two reads.
Example:

• Transaction A reads the price of a product as ₹500.

• Transaction B updates the price to ₹600 and commits.
• When Transaction A reads the price again, it sees ₹600 instead of the original ₹500.

Impact: Causes inconsistency within the same transaction.

Isolation Level to Prevent: Read Committed allows it; use Repeatable Read or
Serializable to avoid.
3. Phantom Read

Violation: A transaction re-executes a query and gets a different set of rows because
another transaction inserted, deleted, or updated rows that affect the query result.

Example:

• Transaction A runs a query: SELECT * FROM Orders WHERE amount > 500 and
gets 3 rows.
• Transaction B inserts a new order with amount = 700 and commits.
• When Transaction A re-runs the same query, it now sees 4 rows (an extra "phantom"
row).

Impact: Affects the number of rows returned by a query, not the row content.

Isolation Level to Prevent: Repeatable Read allows it; use Serializable to avoid.

Conclusion
Understanding and preventing read anomalies like dirty reads, non-repeatable
reads, and phantom reads is crucial for maintaining data consistency and correctness in
multi-user environments. By selecting appropriate isolation levels, database systems can
balance performance with the integrity requirements of applications.

(OR)
Note: Make sure you read the below mentioned question because you might know
something about it. If you don’t know either this nor that, read which fits you coz this is
an or choice question from 3rd Unit
What is Concurrency? Explain it in terms of locking mechanism and
two-phase Commit Protocol.

Introduction
Concurrency is the ability of a database to execute multiple transactions
simultaneously while maintaining the consistency and integrity of the data. In a multi-
user environment, concurrency control is essential to prevent anomalies and ensure
reliable transaction processing.

Concurrency
Concurrency Control Concurrency control ensures that multiple transactions
can execute simultaneously without leading to inconsistencies in the database. It
prevents data corruption, dirty reads, and deadlocks by managing the execution order
of transactions.

Locking Mechanism
Locks are used to manage access to data by multiple transactions. They help
enforce isolation, one of the ACID properties, by ensuring that transactions do not
interfere with each other.

Types of Locks:

Shared Lock (S-Lock):

• Allows a transaction to read a data item.

• Multiple transactions can hold shared locks on the same data.

Exclusive Lock (X-Lock):

• Allows a transaction to read and write a data item.

• Only one transaction can hold an exclusive lock on a data item.

Example Scenario:
• Transaction A holds a shared lock on a row to read data.

• Transaction B requests an exclusive lock to update the same row.

• Transaction B must wait until Transaction A releases the shared lock.

Locking Protocols:

Two-Phase Locking (2PL):

• Growing Phase: Transaction acquires all the locks it needs.
• Shrinking Phase: Transaction releases all the locks.

• Ensures serializability and prevents non-repeatable reads and phantoms.

Deadlock Handling:

Detection and Recovery: The system detects deadlocks and aborts one transaction.

Prevention: Uses schemes like wait-die or wound-wait to avoid deadlocks.

Two-Phase Commit Protocol (2PC)

The Two-Phase Commit Protocol is used to ensure atomicity in distributed
database systems, where a transaction involves multiple nodes.

Phases of 2PC:
Prepare Phase:

• The coordinator sends a "prepare to commit" message to all participating nodes.

• Each node replies with either a vote to commit or abort after writing a log.

Commit Phase:

• If all participants vote to commit:

i. The coordinator sends a commit message.

ii. All participants commit the transaction and release resources.

• If any participant votes to abort:

i. The coordinator sends a rollback message.

ii. All participants abort the transaction.
Key Features:

• Guarantees all nodes commit or none do (atomicity).

• Tolerates failures through logging and recovery processes.

Conclusion
Concurrency control ensures that transactions execute reliably in multi-user
and distributed environments. Locking mechanisms maintain data consistency by
regulating access, while the Two-Phase Commit Protocol enforces atomicity across
distributed databases. Together, they play a crucial role in maintaining the integrity and
robustness of modern database systems.
02) Analyze about the index schemas used in databases.

Introduction

Indexing is a critical concept in database systems, designed to speed up data retrieval

operations. An index schema defines how indexes are structured and implemented within a
database, enabling quick access to rows without scanning the entire table.

1. Single-Level Index

Description: Simple index on a single column.

Use Case: Small datasets or primary key indexing.

Example: Index on StudentID in a Students table.

2. Multi-Level Index

Description: An index on the first-level index to reduce the size of index search space.

Use Case: Suitable when the index itself is too large to fit in memory.

Structure: Hierarchical tree-like index.

3. Clustered Index
Description: Sorts and stores data rows in the order of the index.

Use Case: Useful when data is frequently retrieved in a sorted manner.

Limitations: Only one clustered index per table.

Example: Clustered index on OrderID in the Orders table.

4. Non-Clustered Index

Description: Maintains a separate structure from data rows.

Use Case: Useful for columns used in WHERE clauses or JOINs.

Flexibility: Multiple non-clustered indexes can exist per table.

Example: Index on CustomerName.

5. Composite Index

Description: An index on multiple columns.

Use Case: Optimizes queries involving multiple fields.

Example: Index on (LastName, FirstName) in an Employees table.

6. Bitmap Index
Description: Uses bitmaps for each distinct value of a column.

Use Case: Best for low-cardinality columns like gender or marital status.

Efficiency: High performance for read-heavy operations.

7. Hash Index

Description: Uses hash functions to map keys to index entries.

Use Case: Efficient for equality searches.

Limitation: Not suitable for range queries.

Example: Index on AccountNumber.

Index Schema Considerations

• Performance: Indexes improve read speed but can slow down write operations
(INSERT, UPDATE, DELETE).
• Storage: Indexes require additional disk space.
• Query Optimization: The right combination of indexes can dramatically boost
performance.
• Maintenance: Indexes must be maintained to remain effective, especially in
frequently updated tables.

Conclusion

Index schemas play a fundamental role in the performance and efficiency of

database systems. Understanding the types of indexes and their use cases allows
database designers to create optimized data structures that support quick access and
maintain consistency. Choosing the appropriate index schema depends on the nature of the
queries, data volume, and update frequency. A well-planned indexing strategy is essential
for scalable and high-performance database applications.
03) Create B tree and B+ tree to insert the following key values (the order of the tree
is three) 32, 11, 15, 13, 7, 22, 15, 44, 67, 4.

B-Tree

Definition:

A B-Tree is a self-balancing tree data structure used for storing sorted data
and allowing searches, insertions, and deletions in logarithmic time.

Key Features:

• All leaf nodes are at the same level.

• Each node can contain multiple keys and children.
• Internal nodes store both keys and actual data.
• Efficient for searching, insertion, and deletion.

Properties (Order = m):

• Max m children per node.

• Max m - 1 keys per node.
• All keys in a node are sorted.
• Balanced tree structure.

Use Cases:

Used in databases and file systems for fast disk-based operations.

Step-by-step inserts:
1. Insert 32 → [32]

2. Insert 11 → [11, 32]

3. Insert 15 → Split needed →

o Mid = 15, root becomes [15], children: [11] and [32]

4. Insert 13 → Goes to [11] → becomes [11, 13]

5. Insert 7 → [11, 13] → Split → mid = 11, promote to root →

o Root: [11, 15], children: [7], [13], [32]

6. Insert 22 → goes to [32] → becomes [22, 32]
7. Insert 15 (duplicate): place with [13] → becomes [13, 15]

8. Insert 44 → to [22, 32] → Split → mid = 32, promote →

o Root: [11, 15, 32] → split root → mid = 15 →

o New root: [15], children: [11], [32]

o Final root: [15], children: [7], [11, 13], [22, 44]

9. Insert 67 → goes to [22, 44] → becomes [22, 44, 67] → split → promote 44

o Root: [15, 44], children: [7], [11, 13], [22], [67]

10. Insert 4 → goes to [7] → becomes [4, 7]

B+ Tree

Definition:
A B+ Tree is an extended version of a B-Tree where all values are stored at
the leaf level and internal nodes store only keys for indexing.

Key Features:

• All data is found in leaf nodes.

• Internal nodes guide the search process.
• Leaf nodes are linked to form a linked list for range queries.
• More efficient for range-based and sequential access.

Properties:

• Non-leaf nodes contain keys only (no data).

• Leaf nodes are linked for fast traversal.
• Balanced and supports dynamic growth.

Use Cases:
Preferred in database indexing due to faster range queries and data retrieval.
Steps:

1. Insert 32 → Leaf: [32]

2. Insert 11 → [11, 32]
3. Insert 15 → [11, 15, 32] → Split → mid = 15
o Root: [15], leaves: [11] → [15, 32]
4. Insert 13 → into [11] → [11, 13]
5. Insert 7 → [7, 11, 13] → Split → promote 11
o Root: [11, 15], leaves: [7] → [11, 13] → [15, 32]
6. Insert 22 → [15, 32] → [15, 22, 32] → Split → promote 22
o Root: [11, 15, 22] → split root → new root: [15], children: [11], [22]
o Leaves: [7] → [11, 13] → [15] → [22, 32]
7. Insert 15 (duplicate): goes in [15] → [15, 15]
8. Insert 44 → [22, 32] → [22, 32, 44] → split → promote 32
o Root: [15, 32], children: [11], [22], [44]
o Leaves: [7] → [11,13] → [15,15] → [22] → [32,44]
9. Insert 67 → into [32,44] → [32,44,67] → split → promote 44
o Root: [15, 32, 44] → split root → new root [32], children: [15], [44]
o Leaves: [7] → [11,13] → [15,15] → [22] → [32] → [44,67]
10. Insert 4 → into [7] → [4, 7]
04) Demonstrate in detail about: (i)Information Retrieval. (ii)Transaction processing.

(i) Information Retrieval

Definition

Information Retrieval (IR) is the process of obtaining relevant information from

a large collection of data, typically unstructured or semi-structured, such as documents,
web pages, or multimedia.

Key Components

1. Documents: The source data (e.g., web pages, articles).

2. Queries: User input to search for information.
3. Indexing: Structures like inverted indexes used to map keywords to
documents.
4. Retrieval Model: Determines how results are ranked (e.g., Boolean model,
vector space model).
5. Ranking: Orders the results based on relevance to the query.

Process

• User submits a query.

• System searches the index for matching documents.
• Matches are ranked based on relevance.
• Results are presented to the user.

Applications

• Search engines (e.g., Google, Bing)

• Digital libraries
• Online databases

Example: Searching for "climate change impact" on a digital library retrieves a list of
documents ranked by relevance.

(ii) Transaction Processing

Definition

Transaction processing refers to the execution of a series of operations

(transactions) on a database to ensure data integrity, consistency, and reliability,
especially in multi-user environments.
Key Concepts

1. Transaction: A logical unit of work (e.g., transferring funds).

2. ACID Properties:
o Atomicity: All operations in a transaction are completed or none.
o Consistency: Database remains in a valid state before and after the
transaction.
o Isolation: Concurrent transactions do not interfere with each other.
o Durability: Once committed, changes are permanent.
3. Concurrency Control: Mechanisms like locking to ensure isolation.
4. Commit and Rollback:
o Commit: Finalizes the transaction.
o Rollback: Reverts changes if an error occurs.

Process

• Begin transaction.
• Execute operations.
• If successful, commit. Else, rollback.

Applications

• Banking systems
• Online shopping
• Reservation systems

Example: Transferring ₹1000 from Account A to B involves deducting from A and crediting
to B. If either operation fails, the entire transaction rolls back.

Conclusion

Information Retrieval focuses on retrieving relevant data from large datasets,

while Transaction Processing ensures reliable, consistent operations in databases. Both
are essential in modern systems to handle data efficiently and securely.
 05) i) Write the features of Object relation with example. (ii)Examine XML in detail.

(i) Features of Object-Relational Database

Definition

An Object-Relational Database (ORDB) combines features of both relational

databases and object-oriented databases. It supports complex data types, inheritance, and
encapsulation while maintaining the table-based structure of relational databases.

Key Features

1. User-Defined Types (UDTs): Allows creation of complex types.

2. Inheritance: Objects can inherit attributes and behaviors.

3. Encapsulation: Methods can be associated with data types.

4. Polymorphism: Same operation behaves differently based on object type.

5. Table Inheritance: Tables can inherit from other tables.

6. Object Identifiers (OIDs): Unique identifiers for each row/object.

7. Nested Tables and Arrays: Supports structured data in a single column.

8. Querying with SQL Extensions: Extended SQL to support object queries.

Advantages
• Supports complex data types and structures.

• Increases modeling capabilities through inheritance and encapsulation.

• Maintains relational structure, enabling use of SQL.

• Enhances flexibility and scalability in database design.

Disadvantages

• More complex to design and manage than traditional RDBMS.

• May require additional training and expertise.

• Performance overhead due to object management features.

• Limited support in some relational database systems.
Example

(ii) Examine XML in Detail

Definition

XML (eXtensible Markup Language) is a markup language designed to store and

transport data in a self-descriptive, hierarchical format.

Key Characteristics

1. Platform Independent: Works across all platforms.

2. Human and Machine Readable: Easily readable and editable.

3. Self-Descriptive Structure: Tags clearly describe the data.

4. Supports Nested Elements: Hierarchical representation.

5. Custom Tags: Users can define their own tags.

6. Extensibility: Can be extended without affecting existing data.

Structure of XML Document

<employee>

<emp_id>101</emp_id>

<name>Johan</name>
<department>IT</department>
</employee>

Components

• Elements: Start and end tags enclosing data.

• Attributes: Provide metadata within tags.

• DTD/XSD: Define structure and data types.

Applications

• Web services (SOAP, REST)

• Data interchange between systems

• Configuration files (e.g., AndroidManifest.xml)

Advantages

• Easy data sharing

• Facilitates data validation

• Compatible with multiple technologies (Java, .NET, etc.)

Conclusion

Object-Relational databases blend object-oriented capabilities with relational models

for complex data handling. XML, on the other hand, is pivotal for structured data storage
and transport, supporting interoperability between diverse systems.
 DBMS (SET – 2)
01) When is a transaction said to be deadlocked? (ii)Explain the deadlock
prevention methods with an example?

(i) When is a Transaction Said to be Deadlocked?

Definition:

A transaction is said to be deadlocked when two or more transactions are waiting

for each other to release resources, resulting in an indefinite wait state. This typically
occurs in database systems where multiple transactions lock resources such as tables or
rows.

Conditions for Deadlock:

1. Mutual Exclusion: At least one resource is held in a non-shareable mode.

2. Hold and Wait: A transaction holding a resource is waiting for additional

resources.

3. No Preemption: Resources cannot be forcibly taken; they must be released

voluntarily.

4. Circular Wait: A set of transactions are waiting for each other in a circular
chain.

Example:

• Transaction T1 locks resource A and waits for resource B.

• Transaction T2 locks resource B and waits for resource A.

• Both transactions wait indefinitely — this is a deadlock.

Impact:

Deadlocks can halt the progress of transactions and degrade overall system performance.
Resolving or preventing them is crucial for maintaining database efficiency.

(ii) Deadlock Prevention Methods with Example

1. Wait-Die Scheme:

• Older transaction can wait for a younger one.

• Younger transaction requesting a resource held by an older one is aborted

(dies).

Example:
• T1 (older) requests a lock held by T2 (younger) → T1 waits.
 • T2 requests a lock held by T1 → T2 dies (aborted).

2. Wound-Wait Scheme:

• Older transaction wounds (forces rollback of) younger one holding the
resource.

• Younger transaction waits for older one.

Example:

• T1 (older) requests lock held by T2 (younger) → T2 is aborted.

• T2 requests lock held by T1 → T2 waits.

3. Timeout-Based Scheme:

• A transaction waits for a limited time.

• If not granted within the time, it is rolled back.

4. Resource Ordering:

• Resources are assigned a global order.

• Transactions request resources in ascending order to avoid circular wait.

Example:

• If A < B, all transactions must lock A before B. This prevents cyclic

dependencies.

Conclusion: Deadlocks can severely affect database performance. Understanding when

a deadlock occurs and using prevention strategies such as Wait-Die, Wound-Wait, and
resource ordering can help ensure smooth transaction processing and system reliability.
02) Demonstrate the structure of B+ tree and give the algorithm for search in the B+
tree with example.

Definition:

The B+ tree is a balanced tree data structure that maintains sorted data and allows
efficient insertion, deletion, and search operations. It is widely used in database indexing.

Structure of B+ Tree:

• Internal Nodes: Only store keys and serve as routing indexes.

• Leaf Nodes: Store the actual data or pointers to data records.

• Linked Leaf Nodes: Leaf nodes are linked using pointers to facilitate range
queries.

• Balanced: All leaf nodes appear at the same level.

Example Structure (Order d = 3):

• Internal nodes: [15 | 30]

• Leaf nodes: [5 10], [15 20], [30 40 50] (linked together)

Search Algorithm in B+ Tree:

Input: B+ tree root node, search key k

Steps:

1. Start from the root node.

2. At each internal node:
o Compare k with the keys.

o Follow the pointer to the appropriate child node.

3. Repeat the process until a leaf node is reached.

4. At the leaf node, search for the key k.

5. If found, return the associated data pointer; otherwise, return NULL.

Pseudocode:

Example:

Consider searching for key 20 in the B+ tree:

Steps:

• Start at root [15 | 30]

• 20 > 15 and < 30 → go to middle child [15 20]

• In leaf [15 20], search for 20 → Found

Advantages of B+ Tree:

• Efficient range queries due to linked leaf nodes.

• Tree remains balanced, ensuring log-time operations.

• All data pointers are stored at leaf level.

Conclusion:

B+ trees provide an efficient and scalable data structure for indexing in databases.
The separation of internal routing and leaf data storage enables fast search, insertion, and
range-based operations, making it ideal for use in file systems and RDBMS.
03) Examine the algorithms for SELECT and JOIN operations.

1. SELECT Operation Algorithms:

The SELECT operation retrieves tuples from a relation that satisfy a specified condition.

a. Linear Search (Brute Force):

• Scans each tuple in the relation.

• Time Complexity: O(n)

• Best for small relations or no index available.

b. Binary Search:

• Applicable if the relation is sorted on the search attribute.

• Time Complexity: O(log n)

• Requires sorted data or indexing.

c. Index Search:
• Uses an index (e.g., B+ tree or Hash index) to quickly locate tuples.

• Very efficient for large datasets.

• Time Complexity: Depends on index type (B+ tree: O(log n))

2. JOIN Operation Algorithms:

JOIN combines related tuples from two relations based on a common attribute.
a. Nested Loop Join:
• For each tuple in relation R, scan all tuples in S.

• Time Complexity: O(m × n)

• Simple but inefficient for large relations.

b. Block Nested Loop Join:

• Improves basic nested loop by loading blocks of data into memory.

• Reduces number of disk I/O operations.

c. Sort-Merge Join:
• Sort both relations on the join key.

• Merge them using two pointers.

• Time Complexity: O(m log m + n log n + m + n)
d. Hash Join:

• Build a hash table on the smaller relation.

• Probe with tuples from the larger relation.

• Efficient for equality joins.

Example:

Step-1:

Employees Table

CREATE TABLE Employees (

emp_id INT PRIMARY KEY,

name VARCHAR(50),

dept_id INT

);
Departments Table

CREATE TABLE Departments (

dept_id INT PRIMARY KEY,

dept_name VARCHAR(50)

);

Step-2:
Insert into Departments
INSERT INTO Departments (dept_id, dept_name) VALUES

(1, 'IT'),

(2, 'HR'),

(3, 'Finance');

Insert into Employees

INSERT INTO Employees (emp_id, name, dept_id) VALUES

(101, 'Johan', 1),

(102, 'Alexandar', 2),

(103, 'Meena', 1),

(104, 'Kiran', 3);
Step-3:

Query

SELECT * FROM Employees WHERE dept_id = 1;

emp_id name dept_id

101 Johan 1

103 Meena 1

Step-4:

Query

SELECT Employees.name, Departments.dept_name

FROM Employees

INNER JOIN Departments ON Employees.dept_id = Departments.dept_id;

name dept_name

Johan IT

Alexander HR

Meena IT

Kiran Finance

Conclusion:

Efficient SELECT and JOIN operations are crucial for query performance. Algorithm
choice depends on data size, indexing, and join conditions. Index-based SELECT and
optimized JOIN techniques like Hash and Sort-Merge significantly reduce execution time.
04) Describe about object database concepts.

Definition:

An Object Database (OODB) is a type of database that stores data in the form of
objects, similar to how objects are used in object-oriented programming languages like
Java, C++, or Python. It integrates database capabilities with object-oriented programming
to provide a more natural and seamless way of managing complex data.

Key Concepts:

1. Objects:

o Encapsulate both state (attributes) and behavior (methods).

o Instances of classes and can be stored and retrieved directly from the
database.

2. Classes and Inheritance:

o Data types are defined using classes.

o Inheritance allows one class to inherit attributes and methods from
another.
3. Object Identity (OID):

o Each object has a unique identifier that distinguishes it from all other
objects.
o OIDs are used instead of primary keys.

4. Encapsulation:

o Internal state of objects is hidden.

o Access is only through methods defined in the class.

5. Polymorphism:

o Allows the same method to behave differently based on the object it is

acting upon.

6. Persistence:

o Objects remain stored in the database beyond the execution of a

program.

o The system automatically handles object storage and retrieval.

 7. Relationships:

o Objects can be related through references, allowing direct links (like

pointers) between objects.

8. Query Language:

o OODBs often support OQL (Object Query Language), which is similar

to SQL but supports object operations.

Advantages:

• Seamless Integration with OOP Languages: No need for mapping between

object code and relational tables.

• Better for Complex Data: Efficient in handling complex data like CAD,
multimedia, and engineering designs.

• Improved Performance: Direct access to objects can be faster than

relational joins.

• Supports Reusability and Modularity: Encourages code reuse via

inheritance and encapsulation.

Disadvantages:

• Complex Implementation: Requires deeper understanding of object

concepts.

• Less Mature: Compared to relational databases, OODBs are less widely

adopted and mature.

• Compatibility Issues: May face integration challenges with existing relational

systems.

Example:
class Employee {

int emp_id;

string name;

Department dept; // Object reference

};
Here, the Employee class contains a reference to a Department object, which would be
stored in the database as an object, maintaining relationships naturally.

Conclusion:

Object databases provide a powerful way to manage complex and interrelated data
by unifying programming and database models. While not as widely used as relational
databases, they are ideal in applications involving rich data structures and object-oriented
programming environments.
05) i)Compare homogeneous and heterogeneous databases. ii)Explain about
distributed data storage.

(i) Compare Homogeneous and Heterogeneous Databases (8 Marks)

Definition:

A homogeneous database system uses the same DBMS, data model, and schema
across all sites. A heterogeneous database system, on the other hand, involves different
DBMSs, data models, or schemas at various locations.

System Compatibility:

Homogeneous systems are easier to integrate and maintain due to uniformity in

software and data structure. Heterogeneous systems need special middleware to translate
and coordinate operations between different platforms.

Data Communication:

In homogeneous databases, communication is seamless because all nodes

understand the same protocol and format. Heterogeneous databases face challenges in
communication due to differences in syntax, data types, and semantics.

Schema and Query Processing:

Homogeneous databases share a common schema, which simplifies query

formulation and optimization. In contrast, heterogeneous systems may require schema
mapping and transformation logic to process queries across diverse sources.
Examples:

• Homogeneous: All sites running Oracle DB.

• Heterogeneous: One site using Oracle and another using MySQL or SQL
Server.

Performance and Maintenance:

Homogeneous systems typically perform better and are easier to maintain due to
consistency. Heterogeneous systems offer flexibility but are more complex to troubleshoot,
update, or extend.
(ii) Explain about Distributed Data Storage (8 Marks)

Definition:

Distributed data storage refers to storing parts of a database on multiple physical locations
(servers or sites) while appearing as a single logical database to the user.

Types of Data Distribution:

1. Fragmentation:

o Dividing a table into smaller pieces (fragments).

o Can be horizontal (rows), vertical (columns), or mixed.

2. Replication:

o Copying data across multiple sites for reliability and faster access.

o Increases data availability and fault tolerance.

3. Centralized Storage with Access Control:

o One site stores data, others access it remotely.

Advantages:
• Improved Performance: Local access to frequently used data.
 • Scalability: Easy to add more nodes and distribute load.

• Fault Tolerance: Redundancy ensures continued operation in case of site

failure.

• Data Locality: Data is located closer to where it is most needed.

Disadvantages:

• Complex Management: Synchronization and consistency must be

maintained.

• Security Challenges: More points of attack due to distribution.

• Increased Costs: Higher overhead for maintaining multiple sites.

Conclusion:

Homogeneous databases offer simplicity, whereas heterogeneous systems provide

flexibility with complexity. Distributed data storage enhances availability and performance
but requires efficient management strategies to ensure data integrity and consistency.