PART B (10*2=20 Marks)

1. Define Data Abstraction and list the levels of Data Abstraction.

Ans - Data abstraction is the process of simplifying complex data by
emphasizing only important details while hiding unnecessary ones. The three
levels of data abstraction are Physical Level, Logical Level, and View Level.

2. Define Integrity Constraints

Ans - Integrity constraints are rules or conditions that ensure the accuracy,
consistency, and validity of data in a database. They are used to maintain the
quality of data by preventing invalid or inconsistent data from being entered into
the database. Integrity constraints can be defined at the column level, table level,
or database level and can include rules such as unique keys, check constraints,
and referential integrity constraints.

3. Write note on Fourth Normal Form.

Ans - Fourth Normal Form (4NF) is a level of database normalization that builds
upon the rules of the first three normal forms (1NF, 2NF, and 3NF). The primary
goal of 4NF is to eliminate multivalued dependencies (MVDs) between non-key
attributes within a table.

A multivalued dependency occurs when a non-key attribute of a table is

dependent on another non-key attribute, rather than on the primary key. In a 4NF-
compliant table, every non-key attribute should be dependent on the primary key
or on the entire set of key attributes, eliminating any MVDs.

While 4NF is a desirable level of normalization, it may not always be practical or

necessary to achieve in all database designs. The decision to use 4NF should be
based on the specific requirements and characteristics of the database being
designed.

4. Boycee-Codd normal form is found to be stricter than third normal form. Justify
the statement.
Ans - Boyce-Codd normal form (BCNF) is considered to be stricter than the third
normal form (3NF) because it addresses an additional type of functional
dependency, called a "trivial" dependency, that is not considered in 3NF.

In 3NF, a table is considered to be in third normal form if all non-key attributes

are dependent only on the primary key or other non-transitive functional
dependencies. However, a table that is in 3NF may still contain functional
dependencies between non-key attributes that are not directly related to the
primary key, known as trivial dependencies.

BCNF requires that a table must not have any non-trivial dependencies between
candidate keys and non-key attributes. This means that every functional
dependency must be a candidate key dependency. In other words, every
determinant must be a candidate key, rather than a non-key attribute.
 Therefore, while 3NF eliminates transitive dependencies, BCNF eliminates trivial
dependencies, making it a stricter form of normalization than 3NF. However, not
all databases need to be in BCNF, and the decision to use it should depend on the
specific needs and requirements of the database design.

5. What are the states of transaction?

Ans - There are four main states of a transaction in database management
systems:

Active: This is the initial state of a transaction, indicating that the transaction is in
progress and has not yet been completed. In this state, the transaction is executing
and making changes to the database.

Partially Committed: This state indicates that the transaction has finished
executing all its operations and is ready to be committed, but has not yet been
fully committed. In this state, the database system has guaranteed that the
transaction will be committed, but the changes are not yet visible to other
transactions.

Committed: This state indicates that the transaction has completed successfully
and all changes made by the transaction have been permanently saved in the
database. Once a transaction has been committed, its changes become visible to
other transactions.

Failed/Aborted: This state indicates that the transaction has encountered an error
or exception during its execution and has been rolled back or aborted. In this
state, any changes made by the transaction are undone and the database is
restored to its state before the transaction started.

6. Illustrate the situation to roll back a transaction.

Ans - Rolling back a transaction means undoing any changes made by the
transaction and restoring the database to its state before the transaction began.
Here's an example situation where a transaction might need to be rolled back:

Suppose a bank customer wants to transfer $1000 from their savings account to
their checking account. The transaction involves two operations: subtracting
$1000 from the savings account and adding $1000 to the checking account.

If there is an error during the transaction, such as insufficient funds in the savings
account, the transaction must be rolled back. This would involve reversing the
first operation (subtracting $1000 from the savings account) and restoring the
original balance.

Once the transaction has been rolled back, the database returns to its original
state, and the balances of both accounts remain unchanged. The system can then
either retry the transaction with corrected information or inform the user of the
 error and request a new transaction.

7. What are data fragmentation? State the various fragmentations with example.
Ans - Data fragmentation is the process of breaking down a database into
smaller, more manageable parts called fragments. There are three main types of
data fragmentation:

Horizontal fragmentation: This type of fragmentation divides a table into multiple

fragments based on rows or tuples. Each fragment contains a subset of the
original table's rows. For example, a sales database could be horizontally
fragmented by region, with each fragment containing only the sales data for a
specific geographic region.

Vertical fragmentation: This type of fragmentation divides a table into multiple

fragments based on columns or attributes. Each fragment contains a subset of the
original table's columns. For example, a customer database could be vertically
fragmented by personal information and billing information, with each fragment
containing only the relevant columns.

Hybrid fragmentation: This type of fragmentation combines both horizontal and

vertical fragmentation. It divides a table into multiple fragments based on both
rows and columns. For example, an inventory database could be hybrid-
fragmented by warehouse location and product type, with each fragment
containing the inventory data for a specific combination of location and product.

By fragmenting a database, it can be distributed across multiple servers,

improving performance and scalability. However, fragmentation can also increase
the complexity of data retrieval and storage operations, and should be carefully
considered and planned before implementation.

8. Point out the ordered indices with example.

Ans - An ordered index is a data structure used to efficiently search for specific
values in a database table by maintaining a sorted list of values and their
corresponding pointers to the physical location of the data. There are several
types of ordered indices, including:

B-tree index: This is the most commonly used type of index in databases. It is a
balanced tree data structure that stores values and pointers to data in leaf nodes.
Each node has a fixed number of keys, and pointers to child nodes. B-tree indices
allow for efficient range searches and can handle large amounts of data.

Binary tree index: This is a binary tree data structure that stores values and
pointers to data in leaf nodes. Each node has at most two child nodes, and values
are sorted in ascending or descending order. Binary tree indices are simpler than
B-tree indices, but they can be less efficient for large datasets.

Hash index: This is a data structure that uses a hash function to map values to
 physical storage locations. Hash indices are efficient for exact match searches but
cannot be used for range searches.

Bitmap index: This is a data structure that uses a bitmap to represent the presence
or absence of a value in a table. Bitmap indices are efficient for low-cardinality
columns with a small number of distinct values.

For example, a B-tree index could be used to index a customer database by last
name, allowing for efficient searches for specific customers and range searches
for customers with last names between certain values.

9. Distinguish between threads and risks.

Ans - Threads and risks are two important concepts in the context of computer
programming and software development.

Threads refer to lightweight processes that can run concurrently within a single
process, allowing for parallel execution of code. Threads share the same memory
and resources of the process, which can improve performance and responsiveness
of the application. Each thread has its own stack and program counter, but shares
the heap and other resources with other threads.

On the other hand, risks refer to isolated processes that run independently of one
another. Each process has its own memory space, resources, and program
counter, and can communicate with other processes through inter-process
communication (IPC) mechanisms. Processes are typically more secure than
threads since they have their own memory spaces and cannot access the memory
of other processes.

In summary, threads and risks differ in their level of isolation and concurrency.
Threads are lightweight and share resources with other threads in the same
process, while risks are heavier and run in separate memory spaces. Threads are
more suitable for scenarios where fast communication and sharing of resources
are required, while risks are more appropriate for scenarios where security and
isolation are a priority.

10.State the function of XML schema.

Ans - The function of an XML schema is to define the structure, content,
and data types of an XML document. An XML schema is a blueprint or
template that specifies the rules and constraints for the elements, attributes,
and data types that can be used in an XML document.

An XML schema can be used to validate an XML document and ensure that
it conforms to a specific structure and set of rules. It can also be used to
define data types and ensure that the data in an XML document is formatted
correctly.

XML schemas are commonly used in web applications and data interchange
scenarios, where a standardized format is required to ensure interoperability
between different systems and applications.

PART C (5*10=50 Marks)

11.State and explain the architecture of DBMS. Draw the ER diagram for banking
systems. (Home loan applications)
Ans - The architecture of a DBMS (Database Management System) is typically
divided into three main components:

The user interface: This component allows users to interact with the database by
issuing queries, retrieving data, and modifying data. The user interface can take
the form of a graphical user interface (GUI), command-line interface, or
application programming interface (API).

The database engine: This component is responsible for managing the storage and
retrieval of data in the database. It includes the query processor, which parses and
executes user queries, and the storage manager, which handles the physical
storage of data on disk.

The database schema: This component defines the structure of the database,
including tables, columns, relationships, and constraints. It specifies the rules for
data entry and retrieval, ensuring data integrity and consistency.

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

entities, attributes, and relationships in a database. Here is an example of an ER
diagram for a banking system's home loan application:
 banking system's home loan application:

ER diagram for banking system home loan application

In this diagram, there are three main entities: Customer, Loan, and Property. The
Customer entity has several attributes, including CustomerID, Name, and
Address. The Loan entity has attributes such as LoanID, LoanAmount, and
InterestRate. The Property entity has attributes such as PropertyID, PropertyType,
and PropertyValue.

There are also several relationships between the entities. For example, a Customer
can apply for multiple Loans, but each Loan can only be associated with one
Customer. Similarly, a Loan can be associated with one Property, but each
Property can be associated with multiple Loans.

Overall, the ER diagram provides a clear and concise overview of the data model
for the home loan application database, making it easier to understand and
manage the data in the system.

12.Differentiate foreign key constraints and referential integrity constraints with

suitable example.
Ans - Foreign key constraints and referential integrity constraints are both
important concepts in database management systems.

A foreign key constraint is a rule that ensures that values in a column (or set of
columns) in one table correspond to values in a column (or set of columns) in
another table. In other words, it is a way of linking two tables together. The
foreign key is typically a primary key in the referenced table.

For example, consider two tables: "Orders" and "Customers". The "Orders" table
has a foreign key constraint on the "CustomerID" column, which references the
"Customers" table. This ensures that every order in the "Orders" table is
associated with a valid customer in the "Customers" table. If an attempt is made
to insert an order with an invalid "CustomerID" value, the foreign key constraint
will prevent it from being inserted.

On the other hand, referential integrity constraints are rules that ensure that
relationships between tables are maintained when records are inserted, updated,
or deleted. Referential integrity constraints typically involve foreign keys and
primary keys.

For example, consider the same two tables: "Orders" and "Customers". In this
case, a referential integrity constraint could be used to ensure that if a customer is
deleted from the "Customers" table, all associated orders in the "Orders" table are
also deleted. This ensures that the relationship between the tables is maintained,
even when records are added, modified, or deleted.
 In summary, foreign key constraints ensure that values in one table correspond to
values in another table, while referential integrity constraints ensure that
relationships between tables are maintained when records are added, modified, or
deleted.

13.Write a short note on: Dynamic SQL and Embedded SQL.

Ans – Dynamic SQL and Embedded SQL are two ways of executing SQL
statements in a database management system.

Dynamic SQL is a method of building SQL statements at runtime, based on

conditions that are not known until the program is executed. Dynamic SQL
allows for more flexibility in constructing SQL statements, as it can be used to
build queries that include variable conditions or optional clauses. Dynamic SQL
is commonly used in applications that require user input, such as search engines
or report generators.

Embedded SQL is a method of embedding SQL statements directly into a

programming language, such as C or Java. In Embedded SQL, SQL statements
are included as strings in the program code, and are pre-processed by a special
pre-compiler to generate the necessary code to execute the statements. Embedded
SQL can be used to provide a high-level programming interface to a database,
and is often used in applications that require direct access to database data, such
as transaction processing systems.

In summary, Dynamic SQL allows for the creation of SQL statements at runtime
based on variable conditions, while Embedded SQL allows for the embedding of
SQL statements directly into program code to provide a high-level programming
interface to a database.

14.Explain the role of functional dependency in the process of normalization. For the
following relation scheme R and set of Functional Dependencies F:
R (A, B, C, D, E), F= {AC→E, B→D, E→A}
List all candidate keys.
Ans - Functional dependency is a concept in database management systems that
plays a crucial role in the process of normalization. Functional dependency refers to the
relationship between two attributes in a table, where the value of one attribute
determines the value of another attribute.

Normalization is the process of organizing data in a database to reduce redundancy and

dependency. Functional dependencies are used to identify the degree of redundancy in a
database schema, which can then be eliminated through the normalization process.

In the given relation scheme R (A, B, C, D, E) and set of functional dependencies F =

{AC→E, B→D, E→A}, we can identify the candidate keys by following these steps:

Identify all the attributes that are not on the right-hand side of any functional
dependency. In this case, the attributes are A, B, and C.

For each of these attributes, generate all possible combinations of attributes that include
the attribute itself. These are potential candidate keys.

For each potential candidate key, check if it is unique. If it is not unique, remove any
redundant attributes and try again.

Using these steps, we can identify the following candidate keys for the given relation:

AB
AC
BC
ABC
Note that in this case, all of the candidate keys have a length of two or three, indicating
that the relation is already in at least 2NF (second normal form). We can verify that the
relation is also in 3NF (third normal form) by checking that all non-prime attributes
(i.e., attributes that are not part of any candidate key) are functionally dependent on a
candidate key. In this case, we can see that all non-prime attributes (D and E) are
functionally dependent on candidate keys (AB and AC), so the relation is in 3NF.

15.Discuss the anomalies of BCNF and Prepare a Database to illustrate BCNF.

Ans - BCNF (Boyce-Codd Normal Form) is a higher level of normalization in
database management systems that aims to eliminate certain anomalies that can
occur in lower levels of normalization, such as 3NF. However, even in BCNF,
there can be certain anomalies that may occur.

One of the main anomalies that can occur in BCNF is the loss of information due
to the decomposition of tables. In BCNF, each table must have a single functional
dependency, meaning that each table should only contain information about a
single entity or relationship. However, this can lead to information loss if a single
entity or relationship is spread across multiple tables.

Another anomaly that can occur in BCNF is the insertion anomaly. This occurs
when a new record cannot be inserted into a table without creating a new table or
modifying an existing table. This can happen if a table is decomposed into
multiple tables in BCNF and a new record requires data that is not present in any
of the decomposed tables.

To illustrate BCNF, we can consider a database for a university that includes the
following tables:

Student (student_id, name, major)

Course (course_id, course_name, instructor)
Enrollment (student_id, course_id, semester, grade)
The Student and Course tables are in 3NF, as they do not have any transitive
dependencies. However, the Enrollment table has a composite primary key
 (student_id, course_id), and also has a functional dependency on student_id. To
bring the Enrollment table into BCNF, we can decompose it into two tables:

Enrollment_1 (student_id, course_id, semester)

Enrollment_2 (student_id, course_id, grade)
Both of these tables have a single functional dependency and are in BCNF.
However, this decomposition can result in the loss of information if a single
enrollment record requires data from both tables. To avoid this, we can
denormalize the tables and merge them into a single table:

Enrollment (student_id, course_id, semester, grade)

This table is still in BCNF, as each attribute is functionally dependent on the
composite primary key (student_id, course_id). However, it also avoids the
information loss and insertion anomalies that can occur in the decomposed tables.

16.Briefly explain tuple relational calculus.

Ans - Tuple Relational Calculus is a non-procedural query language used in
relational database management systems. It is used to retrieve data from a
relational database based on logical conditions, using the concept of a tuple,
which is a row in a table.

In Tuple Relational Calculus, a query is expressed in terms of a formula that

describes the desired result set. The formula consists of a variable representing a
tuple, along with logical operators and conditions.

For example, consider a table named "Employees" with columns "EmployeeID",

"Name", "Department", and "Salary". A query in Tuple Relational Calculus to
retrieve the names of all employees whose salary is greater than $50,000 would
be expressed as:

{ t.Name | Employees(t) AND t.Salary > 50000 }

Here, "t" represents a variable that takes on the value of each tuple in the
"Employees" table. The logical operator "AND" is used to combine the conditions
that "t" must satisfy, and the "|" operator is used to specify the attribute(s) to be
included in the result set.

Tuple Relational Calculus is a declarative language, which means that the user
specifies what data is required and the system determines how to retrieve it. It is
often used in conjunction with other query languages such as SQL to provide
additional flexibility in querying relational databases.

17.Suppose you are given a relation

R= (A, B, C, D, E) with the following functional dependencies:
{CE→D, D→B, C→A}
a. Find all candidate keys.
b. Identify the best normal form that R satisfies (1NF,2NF,3NF, or BCNF)
 c. If the relation is not in BCNF, decompose it until it becomes BCNF. At each
step, identify a new relation,
decompose and re-compute the keys and the normal forms they satisfy.
Ans - a. To find all candidate keys, we can use Armstrong's axioms to
determine the closure of each attribute set:

Closure of {C} = {C, A}

Closure of {CE} = {C, E, A, D, B}
Closure of {CD} = {C, D, A, B, E}
Closure of {DE} = {D, E, B, A, C}

The only attribute set whose closure includes all attributes in R is {CE}, so {CE} is the
only candidate key.

b. To determine the best normal form that R satisfies, we need to examine each
functional dependency to see if it violates the normal form rules:

CE→D: This dependency does not violate any normal form rules.

D→B: This dependency does not violate any normal form rules.

C→A: This dependency violates the 2NF rule because A is not fully functionally
dependent on the candidate key {CE}. To satisfy 2NF, we need to decompose R into
two relations: R1 = (C, A) and R2 = (C, D, E, B).

c. R is not in BCNF because the functional dependency C→A violates the BCNF rule.
To decompose R into BCNF, we can use the following steps:

Step 1: Create a new relation R1 = (C, A) to represent the functional dependency C→A.

Step 2: Create a new relation R2 = (C, D, B, E) to represent the remaining attributes and
their dependencies. The candidate key for R2 is {CD}, which can be computed as
follows:

Closure of {CD} = {C, D, B, E}

Step 3: Both R1 and R2 are in BCNF, so we have achieved the desired decomposition.

The final decomposition is:

R1 = (C, A)
R2 = (C, D, B, E)

Both relations are in BCNF and satisfy all the functional dependencies of the original
relation.

18.Define transaction. Explain the ACID Properties of a transaction.

 Ans - In the context of a database management system, a transaction is a
sequence of one or more operations that must be executed as a single, indivisible
unit of work. A transaction can consist of multiple database operations such as
insert, update, delete, and select, and it should either commit all of them or roll
them all back in case of any errors.

The ACID properties are a set of four key properties that ensure the reliability of
transactions in a database system. These properties are as follows:

Atomicity: This property ensures that a transaction is an atomic unit of work,

which means that it should be treated as a single, indivisible operation. Either all
operations within a transaction are completed, or none are. This ensures that if a
transaction fails for any reason, all changes made to the database are rolled back
to their previous state, so the database remains consistent.

Consistency: This property ensures that a transaction brings the database from
one valid state to another. The database constraints and rules must be applied to
maintain the integrity of the data in the database.

Isolation: This property ensures that a transaction is executed independently of

other transactions. It ensures that transactions executing concurrently do not
interfere with each other and produce the same results as if they had executed
serially.

Durability: This property ensures that once a transaction is committed, the

changes made to the database are permanent and cannot be lost due to any system
failures such as power loss, hardware failures, or any other disaster.

Together, these four properties ensure that transactions in a database system are
reliable, consistent, and recoverable in case of any system failures.

19.Brief out the role of time stamp ordering in concurrency control.

Ans - In a database system that allows concurrent transactions, it is essential to
ensure that transactions do not interfere with each other and produce consistent
results. Concurrency control mechanisms are used to manage and coordinate
concurrent transactions.

One such mechanism is time stamp ordering, which is a technique used to ensure
serializability of transactions. In time stamp ordering, each transaction is assigned
a unique timestamp when it starts. The timestamp represents the order in which
the transaction started and provides a mechanism for determining the relative
order of transactions.

When a transaction wants to read or write a data item, the system checks the
timestamp of the transaction against the timestamps of the other transactions that
have accessed the same data item. If the timestamps of the other transactions are
greater than the timestamp of the current transaction, it means that the other
 transactions started before the current transaction, and the system aborts the
current transaction to maintain the serializability of transactions.

On the other hand, if the timestamps of the other transactions are less than or
equal to the timestamp of the current transaction, it means that the other
transactions started after the current transaction or are concurrent with it. In this
case, the system checks whether the concurrent transactions have conflicting
operations. If there are no conflicts, the system allows the current transaction to
proceed, and the timestamp of the data item is updated to the timestamp of the
current transaction.

Time stamp ordering helps to prevent conflicts and ensures that transactions are
executed in a serializable order, which means that the end result is the same as if
the transactions had been executed one after the other in some order. This
technique is widely used in modern database systems to manage concurrency and
ensure consistency of data.

20.Discuss about how locking mechanism is used for concurrency control.

Ans - Locking is a mechanism used for concurrency control in database systems.
It is used to prevent conflicting accesses to shared data items by multiple
transactions. The basic idea behind locking is to acquire a lock on a data item
before accessing it and release the lock once the operation is completed.

Locks can be of two types: shared locks and exclusive locks. A shared lock
allows multiple transactions to read the data item, but it prevents any transaction
from writing to it until the shared lock is released. An exclusive lock, on the other
hand, allows only one transaction to access the data item for both reading and
writing, and it prevents all other transactions from accessing it until the exclusive
lock is released.

When a transaction wants to access a data item, it requests a lock on that item. If
the item is already locked by another transaction, the requesting transaction is
blocked and has to wait until the lock is released. Once the transaction has
acquired the lock, it can perform its operation on the data item. After the
operation is completed, the transaction releases the lock.

Locking mechanisms can be implemented using different protocols, such as two-

phase locking (2PL), multiple granularity locking (MGL), and optimistic
concurrency control (OCC).

Two-phase locking is a protocol that ensures serializability of transactions by

requiring all transactions to acquire a lock before accessing a data item and
holding the lock until the transaction completes. This protocol is simple and
widely used in database systems.

Multiple granularity locking is a protocol that allows different types of locks to be

acquired on the same data item, depending on the operation being performed. For
 example, a transaction may acquire a shared lock on a table to read from it, and
an exclusive lock to modify it. This protocol provides more flexibility than 2PL
but requires more complex implementation.

Optimistic concurrency control is a protocol that assumes that conflicts between

transactions are rare, and it allows transactions to access data items without
acquiring locks. Instead, it checks for conflicts at the end of the transaction and
rolls back any transaction that conflicts with others. This protocol can improve
performance in situations where conflicts are infrequent, but it requires additional
overhead to handle rollbacks.

Locking mechanisms are widely used in modern database systems to manage

concurrency and ensure consistency of data. The appropriate locking protocol
depends on the nature of the system and the frequency and type of access to data
items.

21.Explain how shadow paging concept is used for recovery mechanism.

Ans - Shadow paging is a concept used in recovery mechanisms for database
systems. It is a technique used to ensure that transactions can be undone or redone
in case of a system failure or error. The basic idea behind shadow paging is to
maintain two copies of the database: a main copy and a shadow copy.

The shadow copy is a static snapshot of the database that is created at the start of
a transaction. This snapshot represents the state of the database at that point in
time, and it is used to ensure that the transaction can be rolled back if necessary.
The main copy is the current state of the database, which is updated by the
transaction as it executes.

During the transaction, all changes made to the database are recorded in a log file.
This log file contains a record of all updates made to the database, along with a
pointer to the corresponding page in the shadow copy. This log file allows the
system to recover from failures by using the shadow copy as a reference point.

In case of a system failure, the system uses the log file to determine which
updates were made to the database after the shadow copy was created. It then
applies these updates to the shadow copy to bring it up to date with the current
state of the database. This process is known as redoing.

On the other hand, if a transaction needs to be rolled back, the system simply
discards all changes made to the main copy and uses the shadow copy as the
current state of the database. This process is known as undoing.

Shadow paging provides a simple and efficient mechanism for recovery in

database systems. It allows the system to recover quickly from failures by using a
static snapshot of the database as a reference point. However, it requires
additional storage space to maintain the shadow copy, which can be a
disadvantage in systems with limited resources.
22.Write Short notes on indexing and Hashing techniques with suitable example.
Ans - Indexing and hashing are two common techniques used for efficient data
access in database systems.

Indexing involves creating a separate data structure, known as an index, that maps
the values of a particular attribute to the corresponding records in a table. The
index allows for faster access to the records that match a specific value or range
of values. There are several types of indexes, including B-tree, Bitmap, and Hash
indexes.

B-tree indexes are commonly used in relational database systems. They are
balanced tree structures that store key-value pairs, where the key is the indexed
attribute value and the value is a pointer to the corresponding record in the table.
B-trees are efficient for both range queries and equality queries and can handle
large amounts of data.

Bitmap indexes are used for attributes with low cardinality, where the attribute
values are discrete and have a small number of distinct values. Bitmap indexes
store a bitmap for each attribute value, where each bit represents the presence or
absence of a record with that value. Bitmap indexes are efficient for equality
queries but less efficient for range queries.

Hashing is another technique used for efficient data access. Hashing involves
applying a hash function to the value of a particular attribute to obtain a hash
code. The hash code is used to access a bucket of records that share the same hash
code. If there are multiple records in the bucket, they can be searched sequentially
to find the desired record.

Hashing is efficient for equality queries but less efficient for range queries. It is
also sensitive to hash collisions, where multiple records have the same hash code,
which can lead to degraded performance.

For example, consider a table of employee records with attributes such as name,
age, salary, and department. An index can be created on the department attribute
to allow for faster access to records belonging to a specific department. A B-tree
index can be used to efficiently handle both equality queries (such as finding all
records in the 'Sales' department) and range queries (such as finding all records in
departments with salaries above a certain threshold).

In contrast, hashing can be used to efficiently handle equality queries on attributes

with low cardinality, such as a boolean attribute indicating whether an employee
is currently employed or not. A hash function can be applied to the attribute value
to obtain a hash code, which can be used to access a bucket of records with the
same value.

23.Explain about the advantage of using RAID.

 Ans - RAID, or Redundant Array of Inexpensive Disks, is a technology used in
storage systems that provides advantages in terms of data reliability, performance,
and cost-effectiveness. Some of the advantages of using RAID are:

Data redundancy: RAID provides redundancy by distributing data across multiple

disks and using techniques such as mirroring, parity, or both, to ensure that data
can be recovered in case of a disk failure. This provides a high level of data
protection and helps to prevent data loss.

Improved performance: RAID can improve the performance of storage systems

by using techniques such as striping, which distributes data across multiple disks
to allow for parallel access. This can increase the speed of read and write
operations and improve overall system performance.

Scalability: RAID allows for scalability by providing the ability to add additional
disks to the system to increase storage capacity. This allows for easy expansion of
storage systems as data needs grow.

Cost-effectiveness: RAID can be a cost-effective solution for storage systems as it

uses multiple, inexpensive disks rather than a single, large disk. This can provide
cost savings while also providing improved data reliability and performance.

High availability: RAID can provide high availability by using techniques such as
mirroring or redundancy to ensure that data is always available even in case of a
disk failure. This helps to minimize downtime and ensure that critical data is
always accessible.

Overall, RAID provides a range of advantages for storage systems, including

improved data reliability, performance, scalability, and cost-effectiveness. These
advantages make it a popular technology for a wide range of applications,
including enterprise storage, cloud storage, and personal storage devices.

24.Explain how B and B+ tree are processed? Give one example for each.
Ans - B-tree and B+ tree are both types of balanced tree data structures that are
commonly used in database systems for indexing and efficient data retrieval.

B-tree processing involves the following steps:

Search the root node for the key value.

If the key value is found in the root node, return the corresponding record.
If the key value is not found in the root node, use the pointers in the root node to
move down to the appropriate child node.
Repeat steps 2 and 3 until the key value is found or the leaf node is reached.
Here's an example of a B-tree with the values (1, 3, 4, 7, 10, 12, 15, 16, 19, 20):

[7,15]
 / \
[3,4] / \ [10,12]
/ \
[1,2] [16,19,20]

Suppose we want to search for the key value 10. We start at the root node, which
contains the values 7 and 15. Since 10 is greater than 7 but less than 15, we move
down to the right child node, which contains the values 10 and 12. We find the
key value 10 in this node and return the corresponding record.

B+ tree processing is similar to B-tree processing, but with some key differences:

Only leaf nodes contain record pointers. Internal nodes only contain index values
and pointers to child nodes.
All leaf nodes are at the same level, forming a linked list that allows for efficient
range queries.
Here's an example of a B+ tree with the values (1, 3, 4, 7, 10, 12, 15, 16, 19, 20):
[7,15]
/ \
[1,3,4] / \ [10,12]
/ \
[15,16,19] [20]

Suppose we want to search for the key value 10. We start at the root node, which
contains the values 7 and 15. Since 10 is greater than 7 but less than 15, we move
down to the right child node, which contains the values 10 and 12. Since this is a
leaf node, we return the corresponding record pointer.

In summary, B-tree and B+ tree are both balanced tree data structures that are
commonly used in database systems. B-tree processing involves searching for the
key value by recursively traversing the tree, while B+ tree processing is similar
but with additional features such as linked leaf nodes and record pointers.

25.Differentiate structured and unstructured data. Give the structure of XML.

Ans - Structured data refers to data that has a specific format or structure and is
typically organized in a tabular or hierarchical format. Examples of structured
data include data in spreadsheets, databases, and tables.

Unstructured data, on the other hand, refers to data that does not have a specific
format or structure and is typically not organized in a pre-defined manner.
Examples of unstructured data include text documents, images, audio and video
files, and social media posts.

XML (Extensible Markup Language) is a markup language that is used to

structure data in a hierarchical manner. XML uses tags to define elements and
attributes to provide additional information about those elements. Here's an
example of the structure of XML:
 <?xml version="1.0" encoding="UTF-8"?>
<bookstore>
<book category="cooking">
<title lang="en">Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book category="children">
<title lang="en">Harry Potter and the Philosopher's Stone</title>
<author>J.K. Rowling</author>
<year>1997</year>
<price>10.99</price>
</book>
<book category="web">
<title lang="en">Learning XML</title>
<author>Erik T. Ray</author>
<year>2003</year>
<price>39.95</price>
</book>
</bookstore>

In this example, the XML document contains information about books in a

bookstore. The top-level element is bookstore, which contains several child
elements, each of which represents a book. The book element has an attribute,
category, which indicates the genre of the book. Each book element contains
several child elements, including title, author, year, and price, which provide
additional information about the book. The title element also has an attribute,
lang, which indicates the language in which the book is written.

26.State the steps to create DTD and XML Schema.

Ans - Creating a DTD (Document Type Definition) and an XML Schema
involves defining the structure and rules for validating the content of an XML
document. The steps to create a DTD and XML Schema are as follows:

Determine the structure of the XML document: Before creating a DTD or XML
Schema, you need to determine the structure of the XML document, including the
elements and attributes that it will contain.

Define the root element: The root element is the top-level element of the XML
document. In the DTD, you can define the root element using the DOCTYPE
declaration, while in XML Schema, you can define it using the xs:element tag.

Define the elements: After defining the root element, you can define the other
elements that will be used in the XML document. In the DTD, you can use the
ELEMENT keyword to define an element, while in XML Schema, you can use
 the xs:element tag.

Define the attributes: You can define the attributes that will be used in the XML
document. In the DTD, you can use the ATTLIST keyword to define attributes,
while in XML Schema, you can use the xs:attribute tag.

Define the entities: You can define entities that represent common elements that
can be reused in the XML document. In the DTD, you can use the ENTITY
keyword to define entities, while in XML Schema, you can use the xs:include or
xs:import tags.

Validate the XML document: After defining the DTD or XML Schema, you can
use a validating parser to validate the XML document against the rules defined in
the DTD or XML Schema.

These are the basic steps involved in creating a DTD or XML Schema. It's
important to note that both DTD and XML Schema have different syntax and
features, so it's important to choose the appropriate one for your needs.

27.Discuss about the homogeneous and heterogeneous databases.

Ans - Homogeneous and heterogeneous databases are two types of database
architectures that differ in how they are designed and managed.

A homogeneous database is a database system in which all the components, such

as hardware, software, and data models, are the same across all the nodes or
servers that make up the database system. This means that the same database
management system (DBMS) software is used on all servers, and all data is stored
using the same data model. Homogeneous databases are typically easier to
manage and maintain than heterogeneous databases, as they have a consistent
structure and are less complex. However, they may not be as flexible as
heterogeneous databases, as they may not be able to support different types of
data models or database management systems.

On the other hand, a heterogeneous database is a database system in which

different components, such as hardware, software, and data models, are used
across different nodes or servers that make up the database system. This means
that different DBMS software can be used on different servers, and different data
models can be used to store different types of data. Heterogeneous databases are
typically more complex and difficult to manage than homogeneous databases, as
they require integration and coordination across different systems and platforms.
However, they can be more flexible than homogeneous databases, as they can
support different types of data models and database management systems.

In summary, homogeneous databases are characterized by a consistent structure

and easier management, while heterogeneous databases are characterized by
greater flexibility but greater complexity. The choice between a homogeneous
and heterogeneous database architecture will depend on the specific needs and
 requirements of the organization or application, and should be carefully
considered before making a decision.

28.Give XML representation of University database system.

Ans -
Here is an example of an XML representation of a University database system:

<University>
<Students>
<Student id="001">
<Name>John Doe</Name>
<Major>Computer Science</Major>
<GPA>3.5</GPA>
</Student>
<Student id="002">
<Name>Jane Smith</Name>
<Major>History</Major>
<GPA>3.2</GPA>
</Student>
</Students>
<Professors>
<Professor id="101">
 <Name>Dr. Robert Johnson</Name>
<Department>Computer Science</Department>
<Salary>80000</Salary>
</Professor>
<Professor id="102">
<Name>Dr. Mary Williams</Name>
<Department>History</Department>
<Salary>75000</Salary>
</Professor>
</Professors>
<Courses>
<Course id="CS101">
<Title>Introduction to Computer Science</Title>
<Department>Computer Science</Department>
<Credits>3</Credits>
<Professor>Dr. Robert Johnson</Professor>
</Course>
<Course id="HIS101">
<Title>Introduction to History</Title>
<Department>History</Department>
<Credits>3</Credits>
<Professor>Dr. Mary Williams</Professor>
</Course>
</Courses>
</University>

In this example, the University database system consists of three main components:
Students, Professors, and Courses. Each component has its own set of attributes
and elements. For example, a Student has an id attribute, a Name element, a Major
element, and a GPA element. Similarly, a Professor has an id attribute, a Name
element, a Department element, and a Salary element. A Course has an id
attribute, a Title element, a Department element, a Credits element, and a
Professor element.

This XML representation can be used to store and retrieve data about the
University's students, professors, and courses, and can be processed by various
software tools and applications.

PART D (1*20=20 Marks)

29.State the need for normalization of a database and explain the various normal
forms (1st, 2nd, 3rd. BCNF, 4th and 5th with suitable examples.

Ans – Normalization is the process of organizing a database in a way that reduces data
redundancy and improves data integrity. The main need for normalization is to prevent
data anomalies that can occur when data is stored redundantly or in a non-standardized
format. Normalization ensures that each piece of data is stored in only one place and
that all related data is stored together.

There are several normal forms in database design, each with its own set of rules
and requirements for achieving that level of normalization. The most commonly
used normal forms are:

First Normal Form (1NF): This requires that each column in a table contains only
atomic values, meaning that each value in a column is indivisible. For example, a
column in a customer table that contains a list of phone numbers would violate
1NF, because it contains multiple values.

Second Normal Form (2NF): This requires that a table be in 1NF and that all non-
key columns in the table are fully dependent on the primary key. This means that
each column in a table should be related only to the primary key, and not to any
other columns in the table. For example, a customer order table might have a
primary key of order ID and non-key columns for customer name and address. If
a customer's name and address were repeated in multiple rows for different
orders, this would violate 2NF.

Third Normal Form (3NF): This requires that a table be in 2NF and that all non-
key columns in the table are not transitively dependent on the primary key. This
means that each non-key column should be directly related to the primary key,
and not to any other non-key columns. For example, a customer order table might
have a primary key of order ID and non-key columns for product name, price, and
quantity. If the price was dependent on the product name, rather than directly on
the order ID, this would violate 3NF.

Boyce-Codd Normal Form (BCNF): This requires that a table be in 3NF and that
all non-key columns are functionally dependent on the primary key, with no
dependencies between non-key columns. This means that each non-key column
should be directly related to the primary key, and not to any other non-key
columns. For example, a customer order table might have a primary key of order
ID and non-key columns for product name, price, and supplier name. If the
supplier name was dependent on the product name, rather than directly on the
order ID, this would violate BCNF.

Fourth and Fifth Normal Forms (4NF and 5NF): These are higher levels of
normalization that are not commonly used in most databases. 4NF requires that a
table be in BCNF and that all multi-valued dependencies are removed. 5NF
requires that a table be in 4NF and that all join dependencies are removed.

In general, it is a good practice to normalize a database to at least 3NF, as this

helps to reduce data redundancy and improve data integrity. However, there may
be cases where denormalization is appropriate to improve performance or
simplify queries.
 30.A car rental company maintains a database for all vehicles in its current fleet for
all vehicles it includes the vehicle identification number, license number,
manufacturer, model, date of purchase and colour. Special data are included for
certain types of vehicles.
Truck: Cargo capacity
Sports cars: horse power, renter age requirement
Vans: number of passengers
Off road vehicles: ground clearance, drive train (four or two-wheel drive)
Construct an ER model for the car rental company database.

Ans - Here is an ER model for the car rental company database:

The ER model includes the following entities and attributes:

Vehicle
VehicleID (primary key)
LicenseNumber
Manufacturer
Model
DateOfPurchase
Colour
Truck
VehicleID (foreign key referencing Vehicle)
CargoCapacity
SportsCar
VehicleID (foreign key referencing Vehicle)
HorsePower
RenterAgeRequirement
Van
VehicleID (foreign key referencing Vehicle)
PassengerCapacity
OffRoadVehicle
VehicleID (foreign key referencing Vehicle)
GroundClearance
DriveTrain
In this ER model, the Vehicle entity is the parent entity, with Truck,
SportsCar, Van, and OffRoadVehicle as its child entities. The child entities
each have attributes that are specific to the type of vehicle. The VehicleID
attribute is used as a foreign key in each child entity to establish a one-to-
one relationship between the parent and child entities. This allows the
database to store information about each type of vehicle while still
maintaining a centralized database of all vehicles in the company's fleet.