Introduction

1. Banking Systems
   Databases store customer information, account details, transactions, loans, and credit records, ensuring data consistency, security, and concurrent access.

2. Airline Reservation Systems
   Database systems manage flight schedules, seat availability, passenger details, bookings, and cancellations while preventing double booking.

3. University and Education Systems
   Databases maintain student records, course registrations, grades, attendance, and faculty data, supporting multiple users.

4. E-commerce Applications
   Online platforms use databases to handle product catalogs, customer profiles, orders, payments, and inventory management.

5. Hospital and Healthcare Systems
   Databases store patient records, medical histories, prescriptions, diagnostic reports, and billing information with strict access control.

6. Telecommunication Systems
   Database systems manage call detail records, customer plans, billing data, and network usage at very large scale.

7. Social Media Platforms
   Databases store user profiles, posts, comments, likes, messages, and relationships, enabling real-time data access.

8. Library Management Systems
   Databases track books, authors, issued and returned books, members, and fines efficiently.

9. Government and E-Governance Systems
   Databases manage citizen records, tax data, land records, voting information, and public service delivery systems.

10. Manufacturing and Inventory Systems
    Databases monitor production data, inventory levels, suppliers, orders, and supply chain operations.

• Data Redundancy and Inconsistency
  In a file-processing environment, different application programs are developed independently over time. As a result, the same data may be stored in multiple files. For example, a student enrolled in both the Music and Mathematics departments may have personal details stored in two separate files. If the storage required for one student record is $2$ KB and it is duplicated in $3$ files, the total storage becomes $6$ KB. If one copy is updated while others are not, the system enters an inconsistent state.

• Difficulty in Accessing Data
  File-processing systems do not support flexible queries. If a clerk needs a list of students living in a specific postal-code area, and no such program exists, the options are to manually filter data or write a new program. For example, extracting $500$ relevant records from a file of $10{,}000$ students requires scanning the entire file, leading to inefficient data access.

• Data Isolation
  Data is scattered across multiple files with different formats, making integration difficult. For instance, combining student academic data stored in one file with fee details stored in another requires custom programs, increasing complexity and development time.

• Integrity Problems
  Integrity constraints must be enforced through application code. For example, consider a department account balance that must never fall below $\$0$. If an account has a balance of $$2000$, a withdrawal of $$2500$ should be disallowed. In file systems, such checks must be implemented in every relevant program, making updates and maintenance difficult.

• Atomicity Problems
  Operations must be executed completely or not at all. Consider a fund transfer of $\$500$ from account $A$ to account $B$: \[ A = 3000,\quad B = 2000 \] After debit: \[ A = 2500 \] If a system failure occurs before crediting $B$, the database becomes inconsistent. Ensuring atomicity is difficult in file-processing systems.

• Concurrent-Access Anomalies
  Simultaneous data access by multiple users can lead to incorrect results. For example, if account $A$ has a balance of $\$10{,}000$ and two withdrawals of $$500$ and $$100$ occur concurrently, both programs may read the same initial balance and write back $$9500$ and $$9900$. The correct balance should be: \[ 10{,}000 - 500 - 100 = 9400 \]

• Security Problems
  File-processing systems lack fine-grained access control. For instance, payroll staff may need access only to salary data, not academic records. Since access control is embedded in individual programs, enforcing security policies consistently becomes difficult.

Data models can be broadly categorized into four types:

• Relational Model
  The relational model organizes data and the relationships among data using a collection of tables (also called relations). Each table consists of multiple columns (attributes), and each column has a unique name. The database is structured as fixed-format records, where each record corresponds to a row in the table. The relational model is a type of record-based model and is the most widely adopted model; the majority of modern database systems are based on it.

• Entity-Relationship (E-R) Model
  The E-R model represents data using entities—objects or things in the real world that are distinguishable from one another—and the relationships between these entities. This model is extensively used in database design to conceptually structure data.

• Semi-Structured Data Model
  The semi-structured model allows individual data items of the same type to have different sets of attributes, unlike relational or E-R models where all items of a type share the same attributes. Common formats include JSON and XML, which are widely used for representing semi-structured data.

• Object-Based Data Model
  With the rise of object-oriented programming (e.g., Java, C++, C#), databases evolved to support object-oriented concepts. In this model, objects can be stored in the database along with their methods, supporting encapsulation and object identity. Modern relational databases often integrate object-oriented features, effectively extending the relational model with objects and procedures stored in the database.

Database systems use multiple levels of data abstraction to simplify user interaction while hiding complexity. These levels are:

• Physical Level or Internal
  This is the lowest level of abstraction that describes how data are physically stored. It details the complex low-level data structures used to manage information efficiently.

• Logical Level or Conceptual
  The middle level of abstraction specifies what data are stored and the relationships among them. It uses simplified structures to represent the database while hiding the underlying physical complexity, providing physical data independence. Database administrators primarily interact with this level to determine which information is stored.

• View Leve or Externall
  The highest level of abstraction presents only the portion of the database relevant to a user or application. It simplifies user access and interaction by hiding unnecessary details. A database can provide multiple views tailored for different users’ needs.

There are two types of data independence:

• Physical Data Independence
  The ability to change the internal (physical) schema without changing the conceptual schema. It hides changes in storage structure from users.

  Example: Changing file organization from heap file to B+ tree index or adding an index on RollNo does not affect the logical structure of the table.

• Logical Data Independence
  The ability to change the conceptual schema without changing the external (view) schema. It hides changes in logical structure from users.

  Example: Adding a new attribute Email to the Student table does not affect users who only access Name and RollNo.

Database systems can have multiple schemas, organized according to the levels of abstraction:

• Physical Schema: Describes the database design at the physical level.

• Logical Schema: Describes the database design at the logical level. This is the most important schema for application programs, as programmers construct applications using the logical schema.

• View Schemas (Subschemas): Describe different views of the database at the view level.

• Authorization and Integrity Manager

  • Verifies user access rights.

  • Enforces integrity constraints.

  • Prevents unauthorized data access or invalid updates.

• Transaction Manager

  • Ensures database correctness during failures.

  • Coordinates concurrent operations safely.

  • Prevents conflicting updates.

• File Manager

  • Controls disk space allocation.

  • Maintains physical file structures.

  • Organizes how records are stored on disk.

• Buffer Manager

  • Moves data between disk and main memory.

  • Caches frequently used data in RAM.

  • Decides which pages remain in memory and which are replaced.

  • Enables databases larger than RAM to be processed efficiently.

• Data Files

  • Store the actual database records.

• Data Dictionary (Metadata Repository)

  • Stores schema definitions.

  • Contains structure and constraint information.

  • Used internally by the DBMS.

• Indexes

  • Provide fast lookup of records.

  • Store pointers to matching data rows.

  • Example: index on EmployeeID speeds up search.

• DDL Interpreter

  • Processes schema definition commands.

  • Updates metadata in the data dictionary.

• DML Compiler

  • Translates queries into low-level execution plans.

  • Generates multiple alternative plans.

  • Performs query optimization.

  • Chooses the lowest-cost execution strategy.

• Query Evaluation Engine

  • Executes the selected execution plan.

  • Runs low-level database operations.

• Each transaction must preserve database correctness.

• Temporary inconsistency may occur during execution.

• Final committed state must be consistent.

• Atomicity

  • A transaction executes completely or not at all.

  • If any step fails, all prior changes are rolled back.

  • No partial updates are allowed.

• Consistency

  • A transaction must preserve all integrity constraints.

  • Database moves only from one valid state to another valid state.

  • Rules, keys, and constraints must remain satisfied after commit.

• Isolation

  • Concurrent transactions must not interfere with each other.

  • Intermediate results of one transaction are hidden from others.

  • Effect is equivalent to serial (one-by-one) execution.

• Durability

  • Once a transaction is committed, its results are permanent.

  • Changes survive system crashes and power failures.

  • Achieved using logs and recovery mechanisms.

• Transaction manager consists of:

  • Concurrency-control manager

  • Recovery manager

• If a transaction fails:

  • its effects must be completely undone.

  • database must be restored to the earlier state.

• This is handled by the recovery manager.

• Multiple transactions may run simultaneously.

• Concurrent updates can cause conflicts.

• The concurrency-control manager:

  • coordinates concurrent execution,

  • prevents data inconsistency,

  • enforces isolation.

• Naive Users — use predefined interfaces (forms, web apps, teller screens).

• Application Programmers — write application programs using DML calls.

• Sophisticated Users (Analysts) — directly use query tools for analysis.

• Database Administrators (DBA) — use administration tools for control and maintenance.

• Naive users → Application Interfaces

• Programmers → Application Programs

• Analysts → Query Tools

• DBA → Administration Tools

• Application programs are processed by the Compiler and Linker.

• This produces Object Code.

• DML queries inside programs are extracted for further processing.

• DDL Interpreter — processes schema definitions and updates metadata.

• DML Compiler and Organizer — parses and optimizes DML queries.

• Output is given to the Query Evaluation Engine.

• Query Evaluation Engine — executes optimized queries.

• Buffer Manager — manages data pages in main memory.

• Authorization & Integrity Manager — checks permissions and constraints.

• Transaction Manager — ensures ACID properties.

• File Manager — handles file organization on disk.

• Actual Data Tables

• Indexes for fast access

• Data Dictionary (metadata)

• Statistical Data for query optimization

• User submits request (query/program/interface).

• Query or program is compiled or interpreted.

• DML is optimized by the query processor.

• Storage manager checks authorization and integrity.

• Buffer manager fetches required data pages.

• Data is read/written on disk.

• Results are returned to the user.