1.

Explain different partitioning techniques used

in parallel database systems.
1. Horizontal Partitioning/Sharding:
Description: Divides dataset based on rows or records,
distributing them across multiple servers or storage
devices.

Advantages:
Greater scalability, as it enables processing large
datasets in parallel.
Load balancing by distributing workload equally among
nodes.
Improved data isolation and fault tolerance.

Disadvantages:
Complex join operations across partitions.
Potential data skew if distribution is uneven.
Challenges in distributed transaction management.

2. Vertical Partitioning:
Description: Divides dataset based on columns or
attributes, with each partition containing a subset of
columns for each row.

Advantages:
Improved query performance by placing frequently
accessed columns in separate partitions.
Efficient data retrieval for queries needing only a subset
of columns.
Simplified schema management for adding or removing
columns.
Disadvantages:
Increased complexity in query execution plans.
Complex joins across partitions.
Limited scalability for datasets continuously growing in
columns.

3. Key-based Partitioning:
Description: Divides data based on a particular key or
attribute value, ensuring data with the same key value is
stored in the same partition.

Advantages:
Even data distribution for efficient key lookups.
Scalability and load balancing across partitions.

Disadvantages:
Potential skew and hotspots if key distribution is
uneven.
Limited query flexibility for queries involving multiple
keys or range queries.
Requires careful partition management.

4. Range Partitioning:
Description: Divides dataset based on predetermined
ranges of values, suitable for datasets with natural
ordering based on a specific attribute.

Advantages:
Natural ordering for efficient data retrieval based on
ranges.
Even data distribution across partitions.
Simplified query planning for range-based conditions.
Disadvantages:
Uneven data distribution across ranges.
Challenges in managing data growth and adjusting
ranges.
Complexity in joins and range queries across partitions.

5. Hash-based Partitioning:
Description: Analyzes data using a hash function to
distribute data randomly among partitions.

Advantages:
Even data distribution for load balancing.
Scalability and parallel processing.
Relatively simple implementation.

Disadvantages:
Inefficient for key-based lookups.
Potential load balancing challenges.
Requires partition management as dataset grows.

6. Round-robin Partitioning:
Description: Distributes data evenly across partitions in
a cyclic manner.

Advantages:
Simple implementation.
Basic load balancing.
Scalability and parallel processing.

Disadvantages:
Unequal partition sizes if data distribution or number of
partitions is not balanced.
Inefficient data retrieval for certain queries.
Limited query optimization for specific patterns.
2. Explain Horizontal fragmentation with
example.
Horizontal fragmentation refers to the process of dividing a
table horizontally by assigning subsets of rows to different
fragments. Each fragment contains a portion of the original
table's rows, and together, these fragments cover the entire
table. Horizontal fragmentation is typically used in
distributed databases to partition data across multiple sites
or servers for improved performance and scalability.

Here's an example to illustrate horizontal fragmentation:

Consider a database table named "Employees" with the

following structure:

| EmployeeID | Name | Department | Salary |

|-----------------|------------|----------------|---------|
| 101 | John | Sales | 50000 |
| 102 | Alice | HR | 60000 |
| 103 | Bob | IT | 55000 |
| 104 | Sarah | Marketing | 48000 |
| 105 | Michael | Finance | 70000 |

Now, suppose we want to horizontally fragment the

"Employees" table based on the "Department" attribute. We
can create separate fragments for each department, where
each fragment contains only the rows corresponding to
employees in that department.
For example, after horizontal fragmentation, we might have
the following fragments:

Fragment 1 (Department: Sales):

| EmployeeID | Name | Department | Salary |
|-----------------|------------|----------------|---------|
| 101 | John | Sales | 50000 |

Fragment 2 (Department: HR):

| EmployeeID | Name | Department | Salary |
|-----------------|------------|----------------|---------|
| 102 | Alice | HR | 60000 |

Fragment 3 (Department: IT):

| EmployeeID | Name | Department | Salary |
|-----------------|------------|----------------|---------|
| 103 | Bob | IT | 55000 |

And so on for other departments.

In this example, we've horizontally fragmented the
"Employees" table based on the "Department" attribute,
creating separate fragments for each department. Each
fragment contains only the rows relevant to that
department, allowing for more efficient data access and
management, especially in distributed database
environments.
3. Explain Vertical fragmentation with example.
Vertical fragmentation is a database design technique where
a table is split vertically, meaning that columns from the
original table are divided into multiple smaller tables based
on the attributes or fields they contain. Each smaller table
typically contains a subset of the columns from the original
table, and they are related to each other through some
common attribute or key.

Here's an example to illustrate vertical fragmentation:

Let's consider a hypothetical database table called
"Employee" with the following columns:

- EmployeeID (Primary Key)

- FirstName
- LastName
- Department
- Salary

Now, we might decide to vertically fragment this table

based on the attributes "EmployeeID" and "Salary" to
create two smaller tables:

1. Table 1: "EmployeeID and Name"

- Columns: EmployeeID (Primary Key), FirstName,
LastName
 - Example data:
| EmployeeID | FirstName | LastName |
|-----------------|--------------|--------------|
| 101 | John | Doe |
| 102 | Jane | Smith |

2. Table 2: "EmployeeID and Salary"

- Columns: EmployeeID (Primary Key), Salary
- Example data:
| EmployeeID | Salary |
|-----------------|------------|
| 101 | 50000 |
| 102 | 60000 |

In this example, the original "Employee" table has been

vertically fragmented into two smaller tables based on the
attributes they contain. The first table contains the
employee ID and name information, while the second table
contains the employee ID and salary information. These
two smaller tables are related to each other through the
common attribute "EmployeeID".

Vertical fragmentation can be useful for optimizing

database performance, especially in scenarios where certain
attributes are accessed or updated more frequently than
others. It allows for better data management and can
improve query performance by reducing the amount of data
that needs to be accessed or manipulated in each
transaction.
4. Explain 2 phase commit (2PC) protocol.
The Two-Phase Commit (2PC) Protocol is a method used
in computer science to ensure that changes to a database or
multiple databases are either entirely applied or entirely
undone, maintaining consistency. Here's how it works:

1. Phase 1 - Prepare Phase:

- The coordinator (which manages the transaction) asks
all participating databases (or nodes) if they are ready to
commit the transaction.
- Each participating database replies with a "Yes" if it is
ready or a "No" if it cannot commit the transaction for some
reason (like a failure or lock conflict).
- If all databases respond with "Yes", the coordinator
moves to Phase 2. If any database replies with "No", the
coordinator aborts the transaction, and all changes are
rolled back.

2. Phase 2 - Commit (or Abort) Phase:

- If all participating databases agreed in Phase 1 (i.e., they
all responded with "Yes"), the coordinator instructs all
databases to commit the transaction simultaneously.
- If any database had responded with "No" in Phase 1, the
coordinator instructs all databases to abort the transaction,
and any changes made are rolled back.
 5. Write a short note on Object Relational Database
Management Systems.

Object-relational databases (ORDBs) are a hybrid between

traditional relational databases and OODBs. ORDBs are
designed to handle both structured and unstructured data,
much like OODBs, but they also support SQL queries and
transactions, much like traditional relational databases.

Advantages of ORDBs

• They work with SQL.

ORDBs can use SQL, which is a language that many
developers already know. This makes them more
familiar and easier to use.

• They can be integrated.

ORDBs can be integrated into existing systems. It makes
them a good choice for companies that want to upgrade
their infrastructure without starting from scratch.

• They are good at handling structured data.

ORDBs can handle structured data well. They are good
for applications that need to do a lot of searching and
sorting.

• They have good support for transactions.

ORDBs can handle transactions well. Even if there are
errors or problems, the data stays consistent and
accurate.

Examples of ORDBs include PostgreSQL, Oracle Database,

and Microsoft SQL Server.
6. Explain what are the Object-oriented features
supported by ORDBMS?
Object-Relational Database Management Systems
(ORDBMS) combine the features of both relational
databases and object-oriented programming. Here are some
object-oriented features supported by ORDBMS:

1. Object Types: ORDBMS allows users to define custom

data types, known as object types, which encapsulate both
data and methods (functions) to operate on that data. These
object types can represent real-world entities, such as
employees, customers, or products, with attributes and
behaviors.

2. Inheritance: ORDBMS supports inheritance, allowing

object types to inherit attributes and methods from other
object types. This enables the creation of class hierarchies
where subclasses inherit properties and behaviors from
their parent classes, promoting code reuse and modular
design.

3. Encapsulation: ORDBMS supports encapsulation,

which means bundling data and methods into a single unit,
called an object. This helps in hiding the internal details of
an object and exposing only the necessary interfaces for
interacting with it, enhancing data security and reducing
complexity.

4. Polymorphism: ORDBMS enables polymorphism,

where objects of different types can respond to the same
message (method call) in different ways. This allows for
flexibility and extensibility in application design, as objects
can be treated uniformly despite their differences in
implementation.

5. Complex Data Structures: ORDBMS supports

complex data structures, such as arrays, collections, and
nested objects, allowing for the representation of more
complex relationships and data models. This facilitates
modeling of real-world scenarios more accurately and
efficiently.

6. User-Defined Methods: ORDBMS allows users to

define custom methods (functions) associated with object
types, enabling the implementation of complex business
logic directly within the database. This reduces the need for
application-level processing and improves performance by
leveraging the database's processing power.

By incorporating these object-oriented features, ORDBMS

extends the capabilities of traditional relational databases,
enabling the modeling of complex data structures and
relationships more effectively while maintaining the
benefits of relational data management.

7. Describe the term Structured data types.

Structured data types refer to data types that are composed
of multiple elements or components, each with its own
predefined data type and structure. These elements can be
grouped together to form a composite data type, which
represents a single unit of data. Structured data types are
,used to organize and represent complex data in a structured
and organized manner, making it easier to manage and
process.
Examples of structured data types include:

1. Arrays: An array is a collection of elements of the same

data type, arranged in a contiguous memory block. Each
element in the array is accessed using an index or position
within the array.

2. Structures (or Records): A structure is a composite data

type that consists of a collection of named fields, each with
its own data type. Each field within the structure can store
different types of data, allowing for the representation of
complex data structures.

3. Tuples: A tuple is an ordered collection of elements,

where each element can have a different data type. Tuples
are similar to arrays but are immutable, meaning their
elements cannot be modified once they are created.

4. Objects: In object-oriented programming, an object is an

instance of a class that encapsulates data (attributes) and
behaviors (methods) into a single unit. Objects are used to
represent real-world entities and enable interaction between
different components of a system.

8. Explain Query processing and optimization.

Certainly! Let's break down query processing and
optimization in simple terms:
1. Query Processing:
- Understanding the Question: Just like asking a question
in everyday language, when you input a query into a
database system, the system first needs to understand what
you're asking for.
- Finding the Answer: Once the system understands your
query, it figures out the best way to get the information
you're asking for from the database.
- Getting the Data: After figuring out how to get the
information, the system goes and gets it from the database.
- Presenting the Answer: Finally, the system organizes the
information it retrieved from the database and presents it to
you in a format you can understand, like a table or a list.

2. Query Optimization:
- Finding the Best Way: Imagine you're trying to get from
point A to point B. There could be many different routes
you could take, each with its own advantages and
disadvantages. Similarly, query optimization is like finding
the best route to get the information you need from the
database.
- Making it Faster: Just like finding a faster way to get
from point A to point B can save you time, optimizing a
query can make it run faster and more efficiently.
- Using the Right Tools: Sometimes, you might need to
use a map or GPS to find the best route. In query
optimization, the system uses tools like indexes, statistics,
and algorithms to figure out the best way to retrieve the data
you're asking for.
- Getting the Most Accurate Answer: Optimization also
ensures that the information retrieved is accurate and up-to-
date, so you get the most reliable answer to your query.
9. Write a short note on OID.
OID, or Object Identifier, is a unique identifier assigned to
each object in a database. It acts like a special code or tag
that helps the database keep track of different objects. Just
like each book in a library has its own unique number, each
object in a database has its own OID. This makes it easy for
the database to organize and find specific objects quickly
when needed. OIDs play a crucial role in object-oriented
databases by uniquely identifying objects and facilitating
efficient data retrieval and manipulation.

10. Compare RDBMS with ORDBMS.

11. What is NoSQL? Explain its features,
advantages and disadvantages.
NoSQL, or "Not Only SQL," databases are non-relational
databases designed for flexibility, scalability, and
performance in handling large volumes of unstructured
data. They offer:

• Flexible Schema: NoSQL databases don't require a

fixed schema, making them adaptable to changing
data structures.
• Scalability: They can scale horizontally across
multiple nodes to handle large data volumes and high
traffic.
• High Availability: Many NoSQL databases provide
built-in replication and fault-tolerance for high data
availability.
• Performance: Optimized for high-speed reads and
writes, suitable for real-time applications.
• Variety of Data Models: Support key-value,
document, column-family, and graph data models for
diverse use cases.
Advantages:
• Scalability to handle large data and traffic.
• Flexibility to handle diverse data types and structures.
• Performance for high-speed reads and writes.
• Cost-effectiveness for large-scale applications.
• High availability with built-in replication and fault-
tolerance.

Disadvantages:
• Lack of ACID transactions, sacrificing consistency
for scalability and performance.
• Limited query capabilities compared to SQL
databases.
• Learning curve for developers new to NoSQL
concepts and query languages.
• Eventual consistency model may not be sufficient for
applications requiring strong consistency.
• Less mature tooling and ecosystem compared to SQL
databases.

12. Explain types of NoSQL databases with

example.
Graph Databases: Focus on relationships between data.
Ideal for social networks and recommendation systems.
Examples: Amazon Neptune, Neo4j

Key-Value Stores: Store data as key-value pairs.

Efficient for quick data retrieval based on keys.
Examples: Memcached, Redis, Oracle Coherence
Column-Family Stores: Store data in columns instead of
rows, optimized for fast read and write performance.
Examples: Apache HBase, Google Bigtable, Apache
Accumulo

Document-Based Stores: Store data in flexible,

document-like structures. Good for content management
and e-commerce.
Examples: MongoDB, CouchDB, IBM
CloudantCompare

13. RDBMS with NoSQL.