MODULE -1 (3 MARKS)

1. Different levels of data abstraction

Data abstraction in DBMS is the process of hiding the complex details of the data storage
and showing only the relevant information to the [Link] is achieved through three
levels:-
i) Physical level – lowest level of abstraction which describes how data is stored in the
database.
ii)Logical level (conceptual)– next level of abstraction which describes what data is stored
and the relationships between them.
iii)View level (external/user view)–highest level of abstraction which shows only a certain
part of the database needed by the user to interact.

These levels make database design simple and improve data independence.

2. Explain types of data models in DBMS

A data model defines how data is structured and related inside a database.
Main types are:
i) Hierarchical data model – data is organized in a tree- like structure .Each child has one
parent.
ii)Network data model – data is represented as records(nodes) connected by
links(edges).child with multiple parent .This allows many-to-many relationships using
graphs.
iii) Relational data model – data is organized in tables (relations) with rows(records/tuples)
and columns (domain/attributes).this data model is the most common.
iv) Object-oriented model – data is stored objects with attributes and methods .Uses
concepts like encapsulation, inheritance in database.
v)entity - relationship data model- conceptual model that uses entities, attributes and
[Link] for designing the database.
Vi)semi-structured/document data model(schemaless)- specification of the data where
individual data items of the same type may have different sets of attributes.

Data models help in organizing and designing the database structure.

3. Define data definition language (DDL)

DDL is a part of SQL used to define and manage the structure of a database.
It deals with creating, altering and deleting database objects.
Common DDL commands include CREATE, ALTER, DROP, TRUNCATE.
For example: CREATE TABLE Student(...) defines a new table.
DDL affects the schema ,creates and manages schema objects and does not handle data
inside tables.

4. Different operations of data manipulation language (DML)

DML is used to insert, modify, delete, and retrieve data from the database.
Main DML operations are:
● INSERT – add new records
● UPDATE – modify existing records
● DELETE – remove records
● SELECT – retrieve information
DML helps users interact with the actual data stored in the tables.

5. Explain two types of data independence

Data independence is the ability to change the database schema at one level without
affecting the schema at the other levels. Ensures applications continues to works even if the
way data is stored or structured changes.
Types:
i)Logical data independence – changes in the logical structure(conceptual schema) do not
affect the external/ user views. e.g.,-adding a new attribute .
ii)Physical data independence – changes in the internal storage or file structure do not
affect the logical schema.e.g.,new indexes,file structure

These make the database flexible and easy to maintain.

6. Example of integrity constraints in DBMS

Integrity constraints are rules defined in the database which ensures correctness and
consistency of stored data.
Types-
● Primary key constraint – it is a combination of NOT NULL and unique
constraints .Ensures each record is unique.
 ● Foreign key constraint –it links a column in one table to the primary key of another
table .this relationship helps to maintain referential integrity between two tables.
● Not Null constraint – it ensures thata a column cannot contain null values.
● Unique constraint- it ensures that all values in a column are distinct across all rows
in a table.
● Distinct constraint- prevents duplicates in the column.
● Key constraint- no two rows can have the same value of primary key or unique
attribute(key).
example - write by ourself
These rules prevent invalid data entries.

7. Role of ER model in database design

The Entity-Relationship (ER) model helps in designing a database at the conceptual level.
It identifies entities, their attributes, and relationships between them.
ER diagrams (ERD) provide a clear blueprint before implementing the database.
They remove confusion and help developers understand system requirements.
Thus, ER modeling is the first step in structured database design.

8. Explain data abstraction in DBMS

Data abstraction is the process of hiding internal /complex details of the data storage and
only shows only required informations to the user.
It divides the database into physical, logical, and view levels.
i) Physical level – lowest level of abstraction which describes how data is stored in the
database.
ii)Logical level (conceptual)– next level of abstraction which describes what data is stored
and the relationships between them.
iii)View level (external/user view)–highest level of abstraction which shows only a certain
part of the database needed by the user to interact.

Users at higher levels don’t need to know how data is stored physically.
This makes the database easier to use and increases flexibility.
It also supports data independence and security.

9. Discuss the purpose of data independence.

 Data independence is the ability to change the database schema at one level without
affecting the schema at the other levels(without affecting the user applications). Ensures
applications continues to works even if the way data is stored or structured changes.
Its main purpose is to separate data storage from data usage.
For example, changing file organization should not affect queries.
It reduces maintenance cost and improves database flexibility .
There are two types: logical and physical data independence.
i)Logical data independence – changes in the logical structure(conceptual schema) do not
affect the external/ user views. e.g.,-adding a new attribute .
ii)Physical data independence – changes in the internal storage or file structure do not affect
the logical schema.e.g.,new indexes,file structure

10. Difference between candidate key and super key

i)A super key is any set of attributes that uniquely identifies a row (record) in a table.
A candidate key is a minimal set of attributes that uniquely identifies a row in a table (no
extra/unnecessary attributes).
ii)A super key consists of primary key , candidate key and others.
CANDIDATE KEY= primary key +other columns(alternate keys)
iii)Every candidate key is a super key,
but every super key is not a candidate key.

Example: In a Student table, {Roll_No} = candidate key, {Roll_No, Name} = super key.
# Candidate keys are used to select the primary key.
(5 MARKS)
1. Describe the main components of database architecture
Database architecture describes how the DBMS is structured to manage data efficiently.
It mainly has three levels: external, conceptual(logical), and internal(physical) levels.
The external level contains different user views, showing only selected data for security and
simplicity.
The conceptual level represents the complete logical structure of the database including
tables, relationships, and constraints.
The internal level deals with how data is physically stored on disks using indexes, file
organization, etc.
These three levels together form the 3-tier architecture of DBMS.
DBMS also contains components like the query processor, storage manager, transaction
manager, and metadata.
The query processor executes user queries, and the storage manager controls data storage.
This architecture improves data independence, security, and system efficiency.

2. Explain different types of keys

Keys are special attributes used to identify records and maintain relationships.
Primary key uniquely identifies each record (e.g., Roll_No in Student table).
Candidate key is a set of minimal attributes that can act as a primary key.
Super key includes candidate key plus extra attributes but still uniquely identifies records.
Foreign key is used to link two tables by referencing the primary key of another table (e.g.,
Dept_ID in Employee table).
Composite key uses more than one attribute for uniqueness.
Alternate key is any candidate key not selected as primary key.
Keys play an important role in relational database design, preventing duplicate or
inconsistent records.
They ensure proper relationships and maintain referential integrity.

3. Define attributes and list types of attributes in ER model

An attribute is a property or characteristic of an entity in ER modeling.
For example, in the entity Student, attributes may include Name, Roll_No, Age, etc.
Attributes are used to describe an entity in detail and store actual data values.
Simple attribute: cannot be divided (e.g., Age).
Composite attribute: can be split into smaller parts (e.g., Full Name → First Name + Last
Name).
Single-valued attribute: holds only one value (e.g., Roll_No).
Multi-valued attribute: holds multiple values (e.g., Phone_Numbers).
Derived attribute: value is calculated from other attributes (e.g., Age from Date_of_Birth).
Attributes help in clearly defining entity properties and building strong database models.

4. Explain with an example how ER modeling is used in designing databases

ER modeling is the first step in designing a database and helps convert real-world
requirements into a clear structure.
It identifies entities, their attributes, and relationships between them.
Example: In a College Database, entities may be Student, Course, and Faculty.
Student has attributes like Roll_No, Name, Phone; Course has Course_ID, Course_Name.
Relationships like Enrolls, Teaches link students with courses and faculty.
The ER diagram shows how these elements interact visually.
This diagram is later converted into relational tables during implementation.
ER modeling avoids confusion because it clearly represents requirements.
It also ensures that the final database is well-structured and free from redundancy.
5. Compare between relational data model and object-oriented data model
The relational model stores data in the form of tables (relations) with rows and columns.
It uses keys, constraints, and normalization to maintain accuracy.
It is simple, easy to understand, and widely used (e.g., MySQL, Oracle).
On the other hand, the object-oriented model stores data in the form of objects similar to
OOP languages.
It supports inheritance, polymorphism, and encapsulation.
Relational model works well for structured data, while object-oriented suits complex data
like images and multimedia.
Relational databases use SQL; object-oriented databases store objects directly without
conversion.
Object-oriented databases handle real-world applications better, but relational databases
are more popular in industry. Both models aim to organize and manage data but follow
different structures and principles.

6. Describe integrity constraints and justify their importance in relational databases

Integrity constraints are rules that ensure the accuracy and consistency of data.
Primary key constraint prevents duplicate records.
Foreign key constraint maintains relationships and ensures referential integrity.
Unique ensures no two values are the same in a column.
Not Null prevents empty values, ensuring meaningful data.
Check constraint restricts values to a specific range (e.g., Age > 18).
These constraints protect the database from invalid, conflicting or incomplete data.
They make data reliable for transactions, queries, and reports.
Without constraints, the database can become inconsistent and unreliable.

7. Explain the concept of data independence with real-world examples

Data independence means changes in one level of the database do not affect users or
applications.
Physical data independence allows changes in physical storage (e.g., changing from HDD to
SSD) without affecting table structure.
Logical data independence allows changing logical schema (adding a new column) without
changing user views.
Example: A bank can add a new attribute like email in the customer table without rewriting
ATM software.
This separation makes the database flexible and easier to maintain.
Developers can modify internal storage without disturbing end users.
Data independence reduces the cost of changes and improves long-term database
efficiency.
It is an essential feature of the 3-level DBMS architecture.
MODULE-2 (3 MARKS)
1. Describe the core operations of relational algebra
Relational algebra provides a set of operations used to manipulate and retrieve data from
relational tables.
The core operations include Selection (σ) to choose specific rows, Projection (π) to select
specific columns, and Union (U) to combine rows of two tables.
Other basic operations are Set Difference (-), Cartesian Product (×) and Rename (ρ).
These operations work on relations and produce a new relation as output.
Relational algebra forms the theoretical basis for SQL queries used in DBMS.

2. Explain the significance of tuple relational calculus

Tuple Relational Calculus (TRC) is a non-procedural query language where users specify
what result they want, not how to get it.

For example: { t | t ∈ Student AND [Link] > 18 }.

It uses variables representing tuples and conditions to describe the required output.

TRC provides a high-level way to express complex queries simply.

It is important because SQL is strongly influenced by relational calculus.

3. Describe the concept of domain relational calculus

Domain Relational Calculus (DRC) is another form of relational calculus that uses domain
variables instead of tuple variables.
Users define queries by specifying required fields and conditions on them.
Example: { <name, age> | Student(name, age) AND age > 18 }.
DRC is declarative and focuses on fields rather than entire tuples.
It provides a theoretical foundation for designing safe and accurate database queries.

4. Explain the roles of Armstrong axioms in database design

Armstrong’s axioms are a set of rules used to derive all functional dependencies in a
relational schema.
The three basic axioms are reflexivity, augmentation, and transitivity.
Using these rules, additional dependencies like union and decomposition can also be
derived.
They help in checking whether a functional dependency is valid or not.
These axioms are essential in the process of normalization and schema design.
5. Define 3NF and its benefits
Third Normal Form (3NF) removes transitive dependencies from a relation.
A table is in 3NF if it is in 2NF and all non-key attributes depend only on the primary key.
3NF reduces redundancy and prevents update anomalies.
It ensures that each fact is stored only once in the database.
As a result, the database becomes more organized, efficient, and easier to maintain.

6. Differentiate between 1NF and 2NF

1NF (First Normal Form) ensures that all values in a table are atomic (no repeating groups
or multivalued attributes).
2NF (Second Normal Form) is achieved when the table is in 1NF and all non-key attributes
fully depend on the primary key.
1NF solves issues of repeated and nested data.
2NF removes partial dependencies found in composite primary key tables.
2NF provides better structure, reducing redundancy compared to 1NF.

7. Difference between SQL3 over traditional SQL

SQL3 (also called SQL:1999) introduced advanced features compared to old SQL.
It added object-oriented features, user-defined types, triggers, recursion, and new
datatypes like BLOB, CLOB.
Traditional SQL mainly supported basic querying and simple data types.
SQL3 also supports methods, inheritance, and advanced constraints.
Overall, SQL3 makes SQL more powerful for complex applications.

8. Describe domain and data dependency in relational design

A domain is a set of valid values allowed for an attribute (e.g., Age between 1–100).
Domain dependency ensures values stored in attributes follow their defined domain.
Data dependency refers to how one attribute depends on another (functional dependency).
For example, Roll_No → Student_Name means Roll_No determines Student_Name.
These dependencies help in normalization and maintaining consistency.

9. Explain the objective of query optimization

Query optimization aims to find the most efficient way to execute a user query.
DBMS selects the best strategy by analyzing indexes, joins, and execution plans.
The main objective is to reduce response time and minimize disk I/O operations.
Optimized queries improve overall system performance.
Users get faster results even when dealing with large databases.
10. Describe dependency preservation in normalization
Dependency preservation means all functional dependencies of a relation must be
preserved after decomposition.
When a table is divided into smaller tables, no dependency should be lost.
This ensures that the original constraints can still be checked without performing expensive
joins.
Dependency preservation is important for maintaining data consistency.
It is a key requirement in achieving a good database design.

11. Explain the need for join strategy

Join strategy is required to combine rows from two or more tables based on related
columns.
Different strategies like nested-loop join, merge join, and hash join help improve query
performance.
The need arises when data is spread across multiple related tables.
Using the correct join method reduces execution time and resource usage.
Join strategy ensures efficient data retrieval in complex queries.

12. Analyse the equivalence of two relational algebra expressions

Two relational algebra expressions are equivalent if they produce the same result for any
given database state.
Equivalence helps optimize queries by replacing a complex expression with a simpler one.
Example: σ(condition)(π(columns)(R)) may be equivalent to π(columns)(σ(condition)(R))
depending on fields used.
This concept helps DBMS generate efficient execution plans.
It ensures correctness while improving performance.
(5 MARKS)
[Link] the components and operations of relational algebra with examples
Relational algebra is a procedural query language used to retrieve and manipulate data in
relational databases.
Its main components are relations (tables), attributes (columns), and tuples (rows).
The major operations include Selection (σ) for choosing specific rows, Projection (π) for
choosing columns, and Union (U) to combine similar tables.
Set Difference (−) finds records present in one table but not in another, while Cartesian
Product (×) pairs rows of two tables.
Join operations combine related tables using keys.
Rename (ρ) gives temporary names to relations.
Example: σ(age > 20)(Student) selects students older than 20.
These operations create new relations as output and form the foundation for SQL queries.
Thus, relational algebra helps in understanding query processing at the theoretical level.
2. Explain tuple and domain relational calculus with appropriate examples and syntax
Tuple Relational Calculus (TRC) uses tuple variables to express queries.
It focuses on what data to retrieve rather than how.
Syntax example:
{ t | t ∈ Student AND [Link] > 18 }
This gives all tuples from Student where age > 18.
Domain Relational Calculus (DRC) uses domain variables that represent individual attribute
values.
Example syntax:
{ <name, age> | Student(name, age) AND age > 18 }.
DRC is also non-procedural and works at attribute level.
Both calculus provide mathematical foundations for SQL and ensure safe and correct query
formulation.
3. Explain the progression from 1NF to 3.5NF with examples
1NF ensures that all values in each column are atomic, meaning no repeating groups or
multivalued attributes.
Example: Phone numbers must be stored in separate rows, not as a list.
2NF is achieved when the relation is in 1NF and has no partial dependency (only applies to
composite primary keys).
Example: In a table with (Roll_No, Subject) → Marks, if Name depends only on Roll_No, it
violates 2NF.
3NF removes transitive dependency, meaning non-key attributes should depend only on the
primary key.
Example: If City depends on Pincode and Pincode depends on Student_ID, this is transitive.
3.5NF (BCNF) further strengthens 3NF by ensuring every determinant is a candidate key.
It removes all anomalies and produces a clean, dependency-free structure.
This progression improves the database by reducing redundancy and maintaining
consistency.
4. Explain the concept of data dependencies and their role in relational schema
A data dependency shows how one attribute depends on another in a relation.
The most common type is functional dependency (FD), written as X → Y, meaning X uniquely
determines Y.
For example, Roll_No → Student_Name means Roll_No identifies a student's name.
Other dependencies include partial, transitive, and multivalued dependencies.
Dependencies help identify redundant attributes and guide normalization.
Good relational schema design ensures that dependencies are properly preserved.
They also help detect anomalies like update, delete, and insertion issues.
Thus, understanding dependencies is essential for creating reliable and efficient database
structures.
5. Discuss lossless decomposition and its significance in normalization
Lossless decomposition means breaking a relation into two or more smaller relations
without losing any data.
A decomposition is lossless if the original table can be perfectly reconstructed using a join
operation.
Condition: R1 ∩ R2 must be a key for at least one of the resulting relations.
Example: Splitting Student(Roll_No, Name, Dept) into Student1(Roll_No, Name) and
Student2(Roll_No, Dept).
Lossless decomposition avoids duplication and prevents data anomalies.
It ensures accuracy while reducing redundancy through normalization.
Without lossless decomposition, data may become inconsistent after splitting.
Therefore, it is a key requirement for higher normal forms like 3NF and BCNF.
6. Explain the normalisation process up to 5NF with examples
1NF: No repeating groups; values must be atomic. Example: separate contact numbers into
different rows.
2NF: Remove partial dependencies; only applies to composite primary keys.
3NF: Remove transitive dependencies; non-key attributes depend only on the primary key.
BCNF (3.5NF): Every determinant must be a candidate key; strongest version of 3NF.
4NF: Removes multivalued dependencies. Example: a table storing Student → Hobby and
Student → Language must be split.
5NF: Used when a relation needs to be decomposed to eliminate join dependencies.
5NF ensures that no redundant tuples are formed when joining tables.
This step-by-step normalization improves structure, consistency, and removes anomalies.
It results in a highly organized schema suitable for large systems.
7. Analyse the use of relational algebra in formulating complex queries
Relational algebra provides a step-by-step, procedural approach to solve complex queries.
It breaks large operations into smaller logical steps using operators like selection, join,
intersection, and division.
For example, to find students enrolled in all courses, the division operator can be used.
Join operations help combine multiple tables based on matching attributes, forming
complex relationships.
Nested relational algebra expressions allow filtering, grouping, and combining data in
multiple stages.
By rewriting expressions, DBMS can optimize execution and improve performance.
Relational algebra ensures accuracy and provides a theoretical foundation for SQL.
It is essential for designing query processors and understanding how queries are evaluated.
8. Analyse query equivalence in relational algebra with examples
Query equivalence means two different relational algebra expressions produce the same
final result. This is important because the DBMS can choose the faster equivalent query
during optimization. For example, σ age>20 (σ dept='CS' (Student)) is equivalent to σ
(age>20 AND dept='CS') (Student) since selections can be combined.
Also, a selection on a Cartesian product can be written as a join, such as σ [Link] = [Link] (R × S) ≡
R ⨝ S. Even though the expressions look different, both give identical output. Query
equivalence helps reduce execution time, improves efficiency, and ensures the optimizer
chooses the best plan without changing the result.
9. Evaluate join strategies for large databases
Large databases require efficient join strategies to handle huge amounts of data. Nested
Loop Join is simple but slow when both tables are large. Sort-Merge Join sorts both tables
first and then merges them, making it suitable for sorted or range-based data. Hash Join is
very fast because it creates a hash table on one relation and matches rows quickly.
For extremely large datasets, variations like Partitioned Hash Join are used to reduce disk
I/O. Indexes also improve join speed through Index Nested Loop Join. The best strategy
depends on table size, memory availability, and presence of indexes. Choosing the right join
method improves overall query performance in large systems.
10. Analyse the effectiveness of dependency preservation during normalization
Dependency preservation means that after normalization, all functional dependencies can
still be checked without joining tables. This is important because joins increase query cost
and slow down updates. If dependencies are preserved, integrity constraints (like A → B)
can be verified within individual tables.
Higher normal forms like 3NF usually preserve dependencies, while BCNF may sometimes
break them. When dependencies are preserved, data consistency is easier to maintain. If
they are not preserved, the DBMS must join tables to validate rules, which reduces
performance. Thus, dependency preservation ensures both correctness and efficiency after
normalization.
11. Analyse the role of query optimization technique in DBMS
Query optimization is the process of choosing the most efficient way to execute a query. It
analyses different query plans and selects the one with minimum cost in terms of time, CPU,
and disk I/O. Optimization uses techniques like query rewriting, join reordering, index
selection, and choosing equivalent expressions.
The optimizer also selects the best join method, access path, and evaluation order. This
reduces response time and improves performance for large databases. Without
optimization, even simple queries may run slowly. Therefore, query optimization plays a key
role in making DBMS fast, efficient, and scalable.
MODULE -3 (3 MARKS)
1. Define indexing in a database system
Indexing is a technique used to speed up the retrieval of data from a database.
It creates a separate data structure (like a book index) that helps the DBMS find records
faster.
Instead of scanning the entire table, the database uses the index to directly locate the
required row.
Indexes are usually created on frequently searched columns.
This significantly improves query performance.

2. Types of indices used in a database

Databases commonly use the following types of indices:
1️⃣ Primary Index – built on the primary key; entries follow the sorted order of the key.
2️⃣ Secondary Index – created on non-key attributes for faster search.
3️⃣ Clustered Index – table data is physically arranged based on the index.
4️⃣ Non-clustered Index – index is separate; table remains unchanged.
These indices improve the speed of data retrieval.
3. Describe B-tree and its purpose in storage system
A B-tree is a balanced tree data structure used in databases to store sorted data.
Each node can have multiple keys and children, making the tree shallow and efficient.
B-trees ensure that all leaf nodes are at the same level, providing consistent access time.
They are mainly used in indexing to support fast searching, insertion, and deletion.
Because B-trees minimize disk access, they are ideal for large databases.

4. One advantage of using hashing in data access

Hashing provides direct access to data using a hash function.
It allows constant-time (O(1)) average access for search operations.
Unlike indexing, hashing does not require maintaining sorted data.
It is very efficient for equality searches, such as finding a record by ID.
Thus, hashing speeds up data retrieval significantly.

5. Full form of ACID in transaction management

ACID stands for:
● Atomicity
● Consistency
● Isolation
● Durability
These properties ensure safe and reliable execution of database transactions.
ACID guarantees that data remains correct even during failures or concurrent access.

6. Differences between primary and secondary indexing

A primary index is built on the primary key and stores records in sorted order of that key.
A secondary index is created on non-key attributes and does not define physical order.
Primary index ensures faster access for key-based queries.
Secondary index allows searching based on other frequently used fields.
Primary index is mandatory in many systems; secondary is optional.

7. Role of timestamp ordering in concurrency control

Timestamp ordering assigns a unique timestamp to each transaction.
Operations are executed based on these timestamps to avoid conflicts.
Older transactions get priority over newer ones.
This prevents problems like dirty reads, lost updates and inconsistent retrievals.
It ensures serializability by following a time-based order.

8. Serializability in scheduling
Serializability means arranging concurrent transactions so that the final result is the same as
if the transactions were executed one after another. It ensures correctness when many
users access the database at the same time. A schedule is serializable if it avoids conflicts
like reading uncommitted data or overwriting values incorrectly. It helps maintain
consistency and prevents errors caused by interleaving operations.
Example: If T1 updates a balance and T2 reads it, serializability ensures they run in an order
that gives a correct final value.

9. Two types of locks used in concurrency control

The two main types of locks are Shared Lock (S-Lock) and Exclusive Lock (X-Lock).
● A shared lock allows multiple transactions to read the same data at the same time.
● An exclusive lock ensures only one transaction can write/update the data, preventing
others from reading or writing it simultaneously.
These locks help prevent problems like lost updates and dirty reads by controlling
access to data items.

10. Any two techniques used in database methods

1. Locking Technique: Controls concurrent data access by allowing or blocking
operations using shared and exclusive locks.
2. Timestamp Ordering: Every transaction gets a timestamp, and operations are
allowed or rejected based on the order of timestamps to avoid conflicts.
Both techniques help maintain consistency and ensure safe execution of multiple
transactions.

11. Importance of ACID properties

ACID properties ensure reliable transaction processing.
● Atomicity makes sure a transaction is fully completed or not done at all.
● Consistency ensures data is valid before and after transactions.
● Isolation keeps transactions independent, preventing interference.
 ● Durability ensures changes remain permanent even after failures.
These properties protect the database from corruption during crashes, errors, or
multiple accesses.

12. Compare locking and timestamp methods

● Locking controls access using shared/exclusive locks. Transactions wait if data is
locked. It may cause issues like deadlocks.
● Timestamp ordering uses timestamps to decide which transaction’s operation
should occur first. No waiting occurs, but some operations may be rolled back.
Locking focuses on controlling access, while timestamping focuses on maintaining
order. Both aim to provide safe concurrency.
(5 MARKS)
1. The structure and working principle of a B-tree
A B-tree is a self-balanced search tree used to store large amounts of data on disk. It keeps
data sorted and allows fast searching, insertion, and deletion. A B-tree node contains
multiple keys and child pointers, not just one like a binary tree. All leaves of a B-tree are at
the same level, which ensures balanced height. When inserting, if a node is full, it is split,
and the middle key moves up. During deletion, keys may be borrowed or nodes merged to
maintain balance. B-trees reduce disk I/O and are commonly used in DBMS indexes and file
systems.

2. Short note on ACID properties and its types

ACID stands for Atomicity, Consistency, Isolation, and Durability.
● Atomicity: Ensures a transaction happens completely or not at all.
● Consistency: Keeps the database valid before and after every transaction.
● Isolation: Prevents transactions from interfering with each other during execution.
● Durability: Guarantees that completed changes remain stored even if the system
crashes.
These properties make transactions reliable and help maintain correctness, even
when many users access the database or when failures occur.

3. Describe serializability and its type in concurrency control.

Serializability ensures that the outcome of concurrent transactions is the same as if they
were executed one after another. It is used to guarantee correctness in concurrency control.
There are two main types:
 1. Conflict Serializability: Two schedules are conflict-serializable if they can be
transformed into a serial schedule by swapping non-conflicting operations.
2. View Serializability: Two schedules are view-equivalent if they read and write the
same values in the same order, even if their operation order differs.
Serializability helps avoid problems like dirty reads, lost updates, and inconsistent
results.

4. Discuss various database recovery techniques.

Recovery techniques restore the database to a correct state after failures like system crash,
transaction failure, or disk failure.
● Log-based Recovery: The system maintains logs of all operations. Using undo and
redo, the DBMS can roll back incomplete transactions and reapply completed ones.
● Checkpointing: The DBMS periodically saves a snapshot of the database, reducing
the amount of work needed during recovery.
● Shadow Paging: Instead of overwriting pages, a shadow copy is made. If a failure
occurs, the original pages are used.
● ARIES algorithm: A modern recovery method using write-ahead logging,
checkpoints, and three phases – analysis, redo, and undo.
These techniques ensure durability and consistency.

5. How timestamp-based scheduling ensures concurrency control?

In timestamp scheduling, each transaction gets a unique timestamp when it starts.
Operations are allowed or rejected based on the order of these timestamps. If an operation
violates the timestamp order, the transaction is rolled back and restarted. This prevents
conflicts like reading old values or overwriting new ones.
The main rules include the read timestamp and write timestamp for each data item. The
scheduler compares timestamps to decide whether a read/write is valid. This method avoids
deadlocks because transactions never wait—they are simply aborted and restarted if
needed.

6. How locking protocols maintain database consistency?

Locking protocols use different types of locks to control access to data items. The most
common is the Two-Phase Locking (2PL) protocol.
● In the growing phase, a transaction obtains all required locks.
● In the shrinking phase, it releases them.
This prevents multiple transactions from modifying the same data item at the same
 time. Locks such as shared and exclusive locks avoid conflicts like dirty reads and lost
updates. Strict versions of 2PL ensure that all writes are committed safely before
releasing locks. These protocols guarantee serializability and maintain consistency.

7. Compare and analyse optimistic vs pessimistic concurrency control.

● Pessimistic control assumes conflicts will occur. It uses locks to stop other
transactions from accessing data. It is good for high-conflict environments but may
cause waiting and deadlocks.
● Optimistic control assumes conflicts are rare. Transactions run freely without locks.
At commit time, validation checks detect conflicts; if found, the transaction is rolled
back.
Optimistic control works well when there are many read operations and fewer
updates. Pessimistic control works better in systems with frequent writes or high
competition for data.

8. The role of serializability in ensuring correctness of schedules.

Serializability allows multiple transactions to run concurrently but guarantees the final result
is equivalent to a serial execution. It prevents issues such as dirty reads, lost updates, and
inconsistent results. By ensuring a schedule behaves like a correct serial schedule,
serializability preserves data correctness even when operations interleave. Conflict and view
serializability give formal methods to test whether a schedule is safe. Thus, serializability is
the foundation of concurrency control in DBMS.

9. How ACID properties influence recovery techniques?

Recovery methods are designed to preserve ACID properties during and after failures.
● Atomicity: Recovery uses logs to undo incomplete transactions so that partial
changes are removed.
● Consistency: Checkpoints and validations ensure data remains valid after recovery.
● Isolation: Even during recovery, unfinished transactions do not affect others.
● Durability: Redo operations reapply committed changes to ensure they remain in the
database after crashes.
Thus, recovery mechanisms like logging, shadow paging, and ARIES directly support
ACID and maintain database reliability.
MODULE 4 (3 MARKS)
1. Summarise the role of authentication in database security.
Authentication is the first line of defense in database security, ensuring that only legitimate
users gain access to the system. It verifies the identity of individuals attempting to log in,
typically through credentials such as usernames and passwords. However, modern systems
require stronger authentication mechanisms like biometrics, security tokens, or multi-factor
authentication (MFA) to prevent unauthorized access. MFA enhances protection by
demanding multiple proofs of identity—for instance, something the user knows (password),
something they have (OTP), and something they are (biometric). Weak authentication
systems are highly vulnerable; attackers may steal or guess credentials, leading to serious
data breaches. Thus, robust authentication is essential for maintaining the confidentiality
and integrity of sensitive database information.

2. Basic concept of access control in DBMS.

Access control in databases is the process of defining and enforcing policies that determine
which users can perform specific operations—such as reading, writing, or deleting data—on
particular objects. It ensures that only authorized actions are carried out, thus maintaining
data confidentiality and integrity. Access Control Lists (ACLs) are commonly used to specify
which users or roles have what level of access to each resource. In centralized databases,
access control decisions are made at a single point, whereas distributed databases require
synchronization across multiple nodes. Common access control models include DAC, MAC,
and RBAC, each offering a different level of flexibility and security. Effective access control
not only prevents external attacks but also limits insider threats by ensuring that no user
exceeds their assigned privileges.

3. Explain how authorization differs from authentication.

Authorization defines what authenticated users are permitted to do once their identity has
been verified. It involves assigning specific rights, roles, and privileges that regulate access
to database objects and operations. Authorization ensures that each user performs only
those actions that align with their responsibilities, preventing accidental or intentional
misuse of data. Models such as Discretionary Access Control (DAC), Mandatory Access
Control (MAC), and Role-Based Access Control (RBAC) are used to structure authorization
policies. In DAC, users can assign permissions to others, whereas MAC enforces system-wide
policies. RBAC simplifies management by grouping permissions under predefined roles.
Authorization, therefore, acts as a critical layer of defense that complements authentication,
safeguarding databases from both internal and external misuse.

4. What is the need for strong authentication methods in enterprise databases?

Enterprise databases store critical and sensitive information like employee records,financial
info,and customer details. So strong authentication prevents unauthorized access and
cyberattacks. Simple passwords can be easily guessed or stolen. Strong authentication
ensures:
● Only authorized user.
● Protection against password theft and unauthorized access.
● Support for methods like multi-factor authentication (MFA), biometrics, or smart
cards provide better protection.
● Compliance with security standards like GDPR or HIPAA.
● reduces risks of data breaches, insider misuse, and protects financial as well as
personal data.

5. What is the purpose of the access control list (ACL)?

An Access Control List (ACL) is used to specify permissions for users and groups in a
database. It lists which user can perform what actions such as read, write, modify, or delete.
ACL ensures fine-grained control over database resources and prevents unauthorized
access. It is commonly used in distributed systems, file systems, and networks for secure
data handling.

6. Compare access control techniques used in centralized and distributed systems.

● In centralized systems, all access control decisions are made by a single authority. It
is easy to manage and monitor but may become a bottleneck.
● In distributed systems, access control is handled across multiple locations, making it
flexible and scalable. However, ensuring consistent security policies is harder.
Both aim to protect data but differ in complexity and administrative structure.

7. What is mandatory access control?

Mandatory Access Control (MAC) is a strict security model where access permissions are
decided by the system, not by users. Each data item is assigned a security level, and users
can access data only if their clearance matches or exceeds the level. It is commonly used in
military and government systems where data confidentiality is extremely important.

8. Concept of role-based access control.

Role-Based Access Control (RBAC) is one of the most efficient and scalable models for
managing user permissions in large database systems. Instead of assigning permissions
directly to individuals, RBAC associates privileges with predefined roles—such as “Admin”,
“Editor”, or “Viewer”. Users are then assigned roles based on their job responsibilities,
automatically inheriting the corresponding permissions. This approach simplifies
administration, enhances consistency, and minimizes human error in privilege assignment.
RBAC is particularly effective in large enterprises with dynamic staff structures, ensuring
users access only what they need. However, if too many roles are created or poorly
managed, the system can become complex. Regular reviews and clear role hierarchies are
necessary to maintain RBAC efficiency and security.

9. How encryption enhances database security?

Encryption plays a vital role in safeguarding data by converting it into an unreadable form
that can only be decrypted using a specific key. It ensures data confidentiality both at rest
(stored data) and in transit (data being transmitted over networks). Even if unauthorized
individuals gain physical or network access, encrypted data remains unintelligible without
the decryption key. Encryption algorithms such as AES or RSA are widely used in modern
database systems to secure sensitive information like passwords or financial records.
Implementing encryption not only protects against external breaches but also strengthens
compliance with privacy regulations. Hence, encryption acts as a powerful tool that
reinforces other database security measures by making data unreadable to intruders.

10. Common threats to database authorization mechanism.

Common threats include:
● SQL Injection, where attackers trick the system to gain unauthorized access.
● Privilege Escalation, where users gain higher permissions than allowed.
● Weak passwords, leading to unauthorized entry.
● Insider threats, where authorized users misuse their privileges.
These threats can compromise data integrity, confidentiality, and availability.

11. The importance of user session auditing in security.

User session auditing tracks all actions performed by users during their database sessions. It
helps detect suspicious activities, policy violations, and unauthorized access. Auditing
creates logs that are useful during security reviews and forensic investigations. It
strengthens accountability and ensures transparency in database operations.

12. Analyse a scenario where weak authentication leads to a data breach.

If a system uses simple or reused passwords, attackers can easily guess or crack them using
brute-force attacks. Once they log in as a legitimate user, they can access confidential data,
modify records, or even delete information. For example, if an employee’s weak password is
stolen, hackers may gain access to customer records, causing financial loss and privacy
violations. This shows why strong authentication is essential.
(5 MARKS)
1. Explain in detail on various authentication mechanisms in the database.
Authentication mechanisms verify the identity of users before allowing access to a database.
1. Password-Based Authentication: The most common method where users enter a
username and password. Strong passwords and hashing techniques improve
security.
2. Multi-Factor Authentication (MFA): Requires two or more verification steps such as
password + OTP or biometrics. It greatly reduces unauthorized access.
3. Biometric Authentication: Uses fingerprints, facial recognition, or retina scans. Very
secure as biometric data is unique.
4. Token-Based Authentication: Users receive security tokens or smart cards that
generate unique codes for login.
5. Certificate-Based Authentication: Digital certificates verify identity, often used in
enterprise and cloud databases.
These mechanisms ensure only legitimate users access the database, preventing
attacks and data theft.

2. Importance and process of authorization in database.

Authorization decides what actions an authenticated user can perform.
Importance:
● Protects sensitive information by limiting access.
● Ensures users can only perform tasks relevant to their job.
● Maintains integrity by preventing accidental or intentional data modification.
Process:
1. User is first authenticated.
2. System checks user roles, privileges, and permissions.
3. Based on settings, the system grants or denies access to tables, views, or operations
like SELECT, UPDATE, DELETE.
4. Admins can manage permissions using GRANT and REVOKE commands.
This process keeps the database secure and prevents misuse.

3. Access control models with examples.

Three main access control models:
 1. Discretionary Access Control (DAC):
o DAC allows users to control access to their owned resources.
o It offers flexibility but depends on user discretion.
o Common in systems emphasizing collaboration.
o Vulnerable if users unknowingly grant access to malicious parties.
2. Mandatory Access Control (MAC):
o System enforces strict rules based on security levels (Top Secret, Secret,
Public).
o Example: Government databases where users with "Secret" clearance cannot
view "Top Secret" data.
3. Role-Based Access Control (RBAC):RBAC assigns permissions based on job
responsibilities rather than individuals.
● Each role encapsulates a specific set of operations (e.g., “Manager”, “Analyst”).
● Users inherit permissions when assigned to roles.
● Simplifies large-scale administration and minimizes privilege errors.
These models ensure structured and secure access in databases.
4. The relationship among authentication, authorization and access control.
Authentication, authorization, and access control together form the foundation of database
security. Authentication verifies who the user is, authorization determines what that user is
allowed to do, and access control enforces those permissions on database objects. These
three components work in a layered manner—first confirming identity, then granting
appropriate permissions, and finally ensuring those permissions are applied correctly. For
example, a database might authenticate a user using a password, authorize them to view
certain tables, and use access control rules to restrict operations like deletion or
modification. If any one of these layers fails, data confidentiality and integrity can be
compromised. Therefore, they must function cohesively to establish a secure and well-
regulated database environment.

5. Different types of privileges and their management.

In database systems, privileges define the specific actions a user can perform on database
objects such as tables or views. Common privileges include SELECT, INSERT, UPDATE, and
DELETE, among others. Managing privileges effectively is crucial to maintaining data security
and preventing unauthorized operations. Database administrators grant and revoke
privileges using SQL commands like GRANT and REVOKE. To simplify management, privileges
are often grouped under roles or user categories, ensuring consistent policy enforcement.
Improper privilege management can lead to users gaining more access than necessary,
creating potential security risks. Therefore, regular privilege audits, principle of least
privilege, and role-based allocation are vital practices to ensure secure and organized access
to database resources.

6. A real-world case where access control failure leads to data leakage.

A real-world example of access control failure can be observed in a financial institution
where misconfigured privileges allowed employees to access customer records unrelated to
their job functions. Due to a lack of proper role-based policies and auditing, sensitive data
such as account numbers and personal details were exposed internally, leading to severe
legal and reputational consequences. This incident highlights how improper access control
can lead to internal data leakage even without external hacking attempts. The failure
occurred because roles were not clearly defined, and access rights were assigned manually
without periodic reviews. To prevent such cases, organizations must enforce principle of
least privilege, use automated role management, and conduct regular access audits to
detect anomalies. Proper configuration and continuous oversight are essential to prevent
data exposure and maintain user trust.

7. Effectiveness of role-based access control.

RBAC is highly effective because:
● It simplifies management by assigning roles instead of individual permissions.
● Reduces human errors and maintains consistency.
● Ensures the principle of least privilege by giving users only required access.
● Provides easy auditing and monitoring of role permissions.
● Works well in large enterprises where hundreds of users need controlled access.
Thus, RBAC ensures secure, organized, and scalable access control.

8. Analyse the challenges of implementing authorization in cloud-based databases.

Implementing authorization in cloud-based databases presents unique challenges due to the
distributed and multi-tenant nature of cloud environments. Unlike traditional systems
where data and access policies are managed locally, cloud platforms require dynamic and
scalable authorization mechanisms that work across multiple data centers and user groups.
One of the main challenges is maintaining consistent access policies while accommodating
frequent changes in users, roles, and virtual resources. Compliance with diverse data
protection regulations across regions adds another layer of complexity. Moreover, ensuring
secure communication between different cloud services and preventing privilege escalation
in shared infrastructures are major concerns. Hence, effective cloud-based authorization
demands automation, continuous monitoring, and policy enforcement tools that adapt to
the evolving cloud landscape while maintaining strict security standards.
9. How auditing and login contribute to database security?
Auditing and logging are essential components of database security that help in monitoring
user activities and maintaining accountability. Auditing involves tracking actions performed
on the database, such as login attempts, data modifications, or privilege changes. Logs
record these activities chronologically, serving as valuable evidence during security
investigations or policy compliance checks. They help detect unauthorized access, identify
misuse, and prevent potential breaches by revealing unusual patterns. In enterprise
environments, audit trails are crucial for meeting regulatory requirements such as GDPR or
HIPAA. Effective auditing and logging not only deter malicious activities but also aid
administrators in tracing security incidents and strengthening preventive controls.

10. How access control mechanism can prevent insider threat?

Insider threats arise when authorized individuals misuse their legitimate access to
compromise data security. Access control mechanisms are critical in minimizing such risks.
By applying the principle of least privilege, users are granted only the permissions necessary
for their specific tasks, limiting the potential damage from internal misuse. Role segregation
ensures that sensitive operations require multiple levels of authorization. Continuous
auditing and monitoring can detect unusual activity, such as unauthorized data downloads
or policy violations, in real time. Combining these strategies creates a culture of
accountability and deterrence. Therefore, well-designed access control policies not only
protect against external attackers but also effectively prevent insider threats within the
organization.
MODULE 5 (3 MARKS)
[Link] of data quality in data warehouse system.
• Data quality is the cornerstone of meaningful analytics and business intelligence. High
quality data ensures accuracy, consistency, and reliability of analytical results.
• Poor-quality data leads to misleading insights, incorrect decision-making, and financial or
strategic losses.
• Quality dimensions include completeness, accuracy, timeliness, and consistency across
integrated sources.
• Data cleansing, validation rules, and transformation checks during ETL processes help
maintain quality.
• Reliable, high-quality data improves stakeholder trust, supports predictive modeling, and
enhances the value of the entire warehouse system.

2. The challenges in integrating data from multiple sources into a warehouse.

• Integration involves combining data from heterogeneous systems, each with its own
schema, format, and data standards.
• Major challenges include schema mismatches, redundancy, inconsistent naming
conventions,and synchronization issues.
• Handling different data types (structured, semi-structured) requires careful
transformation
logic.
• Data duplication and conflict resolution must be managed to avoid incorrect aggregations.
• Effective data integration tools, metadata management, and well-defined ETL pipelines
are essential to ensure consistency across all data sources.

3. Compare OLAP and OLTP.

• OLAP (Online Analytical Processing) is designed for complex queries, analysis, and
decision support using historical data.
• OLTP (Online Transaction Processing) focuses on fast, real-time transactional updates
like sales or bookings.
• OLAP systems use multidimensional data models (cubes) for slicing, dicing, and
aggregation.
• OLTP systems prioritize speed and accuracy in concurrent transactions.
• Together, OLTP provides the operational data, and OLAP transforms it into strategic
insights for analysis and forecasting.

4. Effectiveness of using indexing in data warehouse.

• Indexing enhances query performance by allowing faster data retrieval without scanning
entire tables.
• Common warehouse indexes include bitmap and B-tree indexes for optimized aggregation
and filtering.
• Proper indexing supports faster join operations between fact and dimension tables.
• Over-indexing can slow down data loading, so balance between query performance and
ETL speed is crucial.
• Well-planned indexing strategies significantly reduce query latency and improve user
experience in large analytical systems.
5. The risk associated with SQL injection in data warehouses.
• SQL injection is a serious threat where attackers manipulate queries to access or modify
unauthorized data.
• A compromised query can lead to data corruption, leakage of sensitive warehouse
information, or unauthorized updates.
• Attackers may use injected code to bypass authentication or extract confidential data.
• Preventive measures include input validation, use of parameterized queries, and limited
database privileges.
• Regular security audits and secure coding practices are vital to ensure the warehouse’s
integrity against injection attacks.

6. Analyse the impact of using star schema vs snowflake schema.

• Star schema uses denormalized dimension tables, resulting in simpler joins and faster
query processing. It is ideal for dashboards, summary reports, and high-speed analytics.
• Snowflake schema normalizes dimensions into multiple related tables, reducing
redundancy and improving storage efficiency.
• Star schema enhances usability because analysts can easily understand the model.
• Snowflake schema supports better data integrity through reduced duplication and
controlled hierarchical structures.
• Organizations choose between the two based on performance needs, storage constraints,
and the complexity of dimensional hierarchies.

7. Construct a conceptual model of a simple detailed data warehouse.

• A retail warehouse typically revolves around a Sales fact table storing metrics such as
quantity sold, revenue, and discount.
• Dimension tables include Product, Customer, Time, Store/Location, and Promotions.
• The model supports analysis of customer buying patterns, seasonal trends, product
performance, and regional sales.
• Time dimension helps track daily, monthly, and yearly sales patterns.
• This conceptual layout enables retailers to perform forecasting, inventory planning, and
marketing analysis.
8. Design a query to detect anomalies in warehouse using SQL.
• Data anomalies include unusually high values, missing values, or inconsistent records.
• Example query:
SELECT * FROM Sales WHERE quantity > 1000 AND region=’Test’;
• Such queries help identify incorrect ETL loads, test records left accidentally, or fraudulent
entries.
• Anomaly detection ensures integrity and trustworthiness of analytical outputs.
• Regular anomaly checks improve data governance and reduce reporting errors

9. Describe the mechanism in SQL injection in the ETL process.

• Parameterized queries prevent attackers from injecting malicious SQL code into ETL
scripts.
• Input validation ensures only clean, expected data is passed into queries.
• Stored procedures reduce exposure by separating logic from direct SQL execution.
• Least-privilege access prevents ETL users from executing dangerous commands.
• These steps collectively protect warehouse systems from manipulation during data
loading.

10. Compose a data layout for customer feedback analysis.

• A customer feedback mart focuses on analyzing satisfaction, complaints, and product
experience.
• Fact table may store Ratings, Sentiment Scores, or Feedback counts.
• Dimensions include Customer, Product, Region, Time, and Feedback Category.
• This structure helps identify trends in customer perception across regions or products.
• Supports decision-making for product improvements and service enhancements.
(5 MARKS)
1. Evaluate the effectiveness of ETL tools in a data warehouse project.
• ETL tools automate data extraction, cleansing, transformation, and loading, ensuring
consistent data flow.
• They reduce manual effort and errors, improving the quality of integrated data.
• Tools like Informatica, Talend, and SSIS handle large-scale data efficiently.
• They offer features like scheduling, error handling, and metadata tracking.
• ETL tools significantly enhance reliability, speed, and maintainability of warehouse
projects.

2. The role of metadata in a data warehouse environment.

• Metadata describes the structure, meaning, origin, and transformation of warehouse data.
• Technical metadata explains schemas, table definitions, and ETL rules.
• Business metadata provides definitions for metrics (e.g., “total sales” meaning).
• Metadata assists users in understanding data lineage and supports auditing.
• It enhances governance, transparency, and usability of warehouse systems.
3. Examine how data redundancy is handled in data warehousing.
• Redundancy is managed using dimension normalization or snowflake schemas.
• Deduplication during ETL removes repeated records across sources.
• Shared dimensions (e.g., Time dimension) reduce duplication across fact tables.
• Referential integrity constraints ensure consistent relationships.
• Controlled redundancy may remain for faster query performance when needed.

4. The impact of indexing strategies in improving query performance.

• Indexes reduce data retrieval time by avoiding full table scans.
• Bitmap indexes are ideal for low-cardinality attributes like gender or region.
• B-tree indexes support high-cardinality attributes like customer IDs.
• Index tuning improves join performance between fact and dimension tables.
• Proper indexing significantly improves analytical query speed in large warehouses

5. The benefits and limitations of using commercial DBMS for data warehousing.
• Commercial DBMS like Oracle, Teradata, and SQL Server offer robust performance,
scalability, and security.
• They provide enterprise-level features such as partitioning, replication, and workload
management.
• Vendor support ensures reliability and quick troubleshooting.
• Limitations include high licensing cost and vendor lock-in risk.
• Organizations must balance cost, flexibility, and performance while choosing DBMS
platforms.

6. Security measures to protect data warehouse from SQL injection.

• Input validation ensures only safe and expected values enter SQL statements.
• Parameterized statements isolate user input from SQL logic.
• Stored procedures restrict direct SQL execution by users.
• Access control limits privileges, reducing potential damage.
• Security audits and IDS systems help detect suspicious query patterns

7. Create a dimensional model for an educational institute’s data warehouse.

• Fact table: Student Performance containing marks, attendance, grades, or scores.
• Dimensions: Subject, Teacher, Class, Semester, Student, Department.
• The model supports performance comparisons across classes, teachers, or subjects.
• Enables academic trend analysis (e.g., semester-wise improvements).
• Useful for institutional planning, curriculum tuning, and evaluation.

8. Design a complete ETL pipeline for importing sales data into a warehouse.
• Fact table: Student Performance containing marks, attendance, grades, or scores.
• Dimensions: Subject, Teacher, Class, Semester, Student, Department.
• The model supports performance comparisons across classes, teachers, or subjects.
• Enables academic trend analysis (e.g., semester-wise improvements).
• Useful for institutional planning, curriculum tuning, and evaluation

9. Compose a warehouse schema for hospital management system.

• Fact table: Treatments with measures like cost, duration, and success rate.
• Dimensions include Patient, Doctor, Department, Time, Diagnosis, Procedure.
• Supports analytics such as most common treatments or cost trends.
• Helps monitor doctor performance and patient recovery patterns.
• Enables hospital administrators to optimize resources and care quality.

10. Create a plan to audit data integrity within a warehouse.

• Use audit trails to track data changes and access attempts.
• Implement referential integrity checks to ensure relationships remain valid.
• Use triggers for change logging during ETL or updates.
• Conduct periodic completeness and consistency checks.
• Integrity audits improve reliability and ensure compliance with governance standards.

11. Design a dashboard for warehouse-based decision support.

• Dashboards present KPIs like revenue trends, sales growth, and customer insights.
• Tools like Tableau, Power BI, and QlikSense create interactive visualizations.
• Filters enable drill-down analysis across regions, products, or time periods.
• Dashboards support real-time monitoring of business performance.
• They help decision-makers identify opportunities and resolve bottlenecks

12. Build a defense framework to detect and block SQL injection attempts.
• Use Web Application Firewalls (WAF) and Intrusion Detection Systems (IDS) to flag
malicious queries.
• Input sanitization and encoding prevent injection payload execution.
• Parameterized queries eliminate dynamic SQL vulnerabilities.
• Machine learning models can detect abnormal query patterns.
• Combined, these measures build a multi-layer defense against SQL injection attacks.