+
+ Welcome to Database Management Systems —
+ a core course designed to help you understand how data is organized, stored,
+ retrieved, and managed efficiently. This course covers relational models, SQL,
+ normalization, transactions, indexing, and more.
+
+
+
+
+
+
+ Module I: Introduction to Databases
+
+
+ - What is a database and why we need it
+ - File system vs database approach
+ - Advantages of DBMS over file systems
+ - Types of databases: relational, hierarchical, network, object-oriented
+ - Database users: end users, application programmers, DBA
+ - DBMS architecture: 1-tier, 2-tier, 3-tier
+
+
+
+
+
+
+
+ Module II: Entity-Relationship Model
+
+
+ - Entities, attributes, and relationships
+ - Types of attributes: simple, composite, multivalued, derived
+ - Cardinality: one-to-one, one-to-many, many-to-many
+ - Participation constraints: total and partial
+ - ER diagram notation and conventions
+ - Extended ER features: specialization, generalization, aggregation
+
+
+
+
+
+
+
+ Module III: Relational Model and SQL
+
+
+ - Relational model: tables, tuples, attributes, domains
+ - Keys: primary, candidate, foreign, super key
+ - Relational algebra operations
+ - SQL basics: DDL, DML, DCL, TCL
+ - Joins: inner, outer, natural, cross
+ - Subqueries, views, and aggregation functions
+
+
+
+
+
+
+
+ Module IV: Normalization
+
+
+ - Functional dependencies and their types
+ - Anomalies: insertion, deletion, update
+ - Normal forms: 1NF, 2NF, 3NF, BCNF
+ - Decomposition: lossless join and dependency preservation
+ - Multivalued dependencies and 4NF
+ - Practical approach to normalization
+
+
+
+
+
+
+
+ Module V: Transactions and Concurrency Control
+
+
+ - Transaction concept and ACID properties
+ - Transaction states: active, partially committed, committed, failed, aborted
+ - Concurrency problems: lost update, dirty read, unrepeatable read
+ - Concurrency control techniques: locking, timestamps
+ - Two-phase locking protocol
+ - Deadlock detection and recovery
+
+
+
+
+
+
+
+ Module VI: Indexing and Hashing
+
+
+ - Basic concepts of indexing
+ - Dense and sparse indexes
+ - B-tree and B+ tree indexing
+ - Hashing techniques: static and dynamic
+ - Comparison of indexing vs hashing
+ - When to use which technique
+
+
+
+
+
+
+
+ Module VII: Query Processing and Optimization
+
+
+ - Steps in query processing
+ - Query cost estimation
+ - Equivalence of relational expressions
+ - Query optimization techniques
+ - Nested loop joins and merge joins
+ - Query execution plans
+
+
+
+
+
+
+
+ Module VIII: Recovery and Security
+
+
+ - Types of failures: transaction, system, media
+ - Recovery techniques: log-based, shadow paging
+ - Checkpoints and their role in recovery
+ - Database security concepts
+ - Authorization and authentication
+ - SQL injection and prevention
+
+
+
+
+
+
+ By the end of this course, you will understand how to design databases,
+ write efficient SQL queries, normalize data, manage transactions, and
+ handle indexing and recovery — providing a strong foundation for
+ real-world database development and system design.
+
+
+
+ This chapter covers the fundamental concepts of database systems — what
+ they are, why they exist, how they compare to file systems, and the
+ basic architecture of a DBMS.
+
+
+
+
+
+
+ What is a Database?
+
+
+ - A database is an organized collection of related data stored and accessed electronically.
+ - Data represents real-world information — student records, bank transactions, product inventory.
+ - A DBMS (Database Management System) is software that manages and controls access to the database.
+ - Examples of DBMS: MySQL, PostgreSQL, Oracle, MongoDB.
+
+
+
Real-world Example
+
{`University DB
+Tables: Students, Courses, Enrollments, Professors
+Student Zubair (ID: 101) is enrolled in DBMS (CS401)
+taught by Prof. Sharma.`}
+
+
+
+
+
+
+ File System vs DBMS
+
+
+ - Before DBMS, data was stored in flat files managed by the OS.
+ - Data Redundancy: the same data repeated in multiple files.
+ - Data Inconsistency: updating one file does not update others.
+ - Data Isolation: data scattered in different formats, hard to access together.
+ - DBMS solves all three by centralizing data and enforcing rules.
+
+
+
Exam Tip: Always mention the 3 main problems of file systems — redundancy, inconsistency, and data isolation — when comparing with DBMS.
+
+
+
+
+
+
+ Advantages of DBMS
+
+
+ - Reduced Redundancy: data is stored once and shared.
+ - Data Consistency: changes reflect everywhere automatically.
+ - Data Integrity: constraints ensure data accuracy.
+ - Data Security: access control limits who can read or modify data.
+ - Concurrent Access: multiple users can safely access data at the same time.
+ - Backup and Recovery: DBMS provides tools to recover from failures.
+
+
+
+
+
+
+
+ Types of Databases
+
+
+ - Relational: data in tables with rows and columns. Example: MySQL, PostgreSQL.
+ - Hierarchical: tree-like structure. Example: IBM IMS.
+ - Network: graph structure with multiple parent-child relationships.
+ - Object-Oriented: stores objects like in OOP. Example: db4o.
+ - NoSQL: designed for unstructured data at scale. Example: MongoDB, Redis.
+
+
+
Most university syllabi focus on relational databases. NoSQL is mentioned for awareness.
+
+
+
+
+
+
+ Database Users
+
+
+ - End Users: interact with the database through applications.
+ - Application Programmers: write programs to access the database.
+ - DBA (Database Administrator): manages performance, security, and backups.
+ - Data Analysts: query the database to generate reports and insights.
+
+
+
Who does what?
+
{`End User → Uses a form to register for a course
+App Dev → Writes INSERT INTO enrollments...
+DBA → Creates tables, grants permissions, monitors performance`}
+
+
+
+
+
+
+ Three-Schema Architecture
+
+
+ - DBMS uses a 3-level architecture to separate storage from how users see data.
+ - Internal Level: how data is physically stored on disk.
+ - Conceptual Level: the logical structure — tables, relationships, constraints.
+ - External Level: what individual users or applications see (views).
+ - This separation is called Data Independence.
+
+
+
Physical independence = change storage without changing logic. Logical independence = change logic without changing user views.
+
+
+
+
+
+
+ DBMS Languages
+
+
+ - DDL (Data Definition Language): define structure. Example: CREATE, ALTER, DROP.
+ - DML (Data Manipulation Language): manipulate data. Example: INSERT, UPDATE, DELETE, SELECT.
+ - DCL (Data Control Language): access control. Example: GRANT, REVOKE.
+ - TCL (Transaction Control Language): manage transactions. Example: COMMIT, ROLLBACK.
+
+
+
Quick Examples
+
{`DDL: CREATE TABLE students (id INT PRIMARY KEY, name VARCHAR(50));
+DML: INSERT INTO students VALUES (1, 'Zubair');
+DCL: GRANT SELECT ON students TO user1;
+TCL: COMMIT;`}
+
+
+
+
+
+
+ DBMS Architecture: 1-Tier, 2-Tier, 3-Tier
+
+
+ - 1-Tier: database and application on the same machine. Used for personal/local databases.
+ - 2-Tier: client communicates directly with the database server.
+ - 3-Tier: a middle application server sits between client and database. Used in web apps.
+
+
+
3-Tier Example
+
{`Client (Browser)
+ ↓ HTTP request
+App Server (Node.js / Spring Boot)
+ ↓ SQL query
+Database Server (MySQL / PostgreSQL)`}
+
+
+
+ The Entity-Relationship (ER) Model is
+ a high-level conceptual tool used to design databases visually before writing
+ any SQL. It represents real-world data as entities, their attributes, and
+ their relationships.
+
+
+
+
+
+
+ What is the ER Model?
+
+
+ - The ER Model is a blueprint for designing a database before coding.
+
- It helps translate real-world requirements into a visual diagram.
+ - Proposed by Peter Chen in 1976.
+ - The ER Diagram (ERD) is later converted into relational tables.
+
+
+
+
+
+
+
+ Entities and Entity Sets
+
+
+ - An Entity is a real-world object — a student, a course, an employee.
+ - An Entity Set is a collection of similar entities — all students, all courses.
+ - Strong Entity: can exist independently. Example: Student.
+ - Weak Entity: depends on another entity. Example: Dependent (of an employee).
+
+
+
In ER diagrams: Strong entities use a single rectangle. Weak entities use a double rectangle.
+
+
+
+
+
+
+ Attributes
+
+
+ - Simple: cannot be divided further. Example: Age.
+ - Composite: can be divided into sub-parts. Example: Name → First Name, Last Name.
+ - Multivalued: can have more than one value. Example: Phone Numbers.
+ - Derived: calculated from other attributes. Example: Age from Date of Birth.
+ - Key Attribute: uniquely identifies each entity. Example: Student ID.
+
+
+
In ERD: Multivalued = double ellipse. Derived = dashed ellipse. Key attribute = underlined.
+
+
+
+
+
+
+ Relationships
+
+
+ - A Relationship represents an association between two or more entities.
+ - Example: A Student enrolls in a Course.
+ - Unary: self-referencing. Example: Employee manages Employee.
+ - Binary: between two entities. Example: Student enrolls in Course.
+ - Ternary: between three entities. Example: Doctor prescribes Medicine to Patient.
+ - Relationships can also have attributes. Example: 'enrolls' can have a 'grade' attribute.
+
+
+
+
+
+
+
+ Cardinality
+
+
+ - Cardinality defines how many entity instances participate in a relationship.
+ - One-to-One (1:1): A person has one passport.
+ - One-to-Many (1:N): One department has many employees.
+ - Many-to-Many (M:N): A student enrolls in many courses; a course has many students.
+
+
+
Cardinality Notation
+
{`1:1 → Person ——— Passport
+1:N → Department ——< Employee
+M:N → Student >——< Course`}
+
+
+
+
+
+
+ Participation Constraints
+
+
+ - Total Participation: every entity must participate in the relationship. Shown with a double line.
+ - Partial Participation: some entities may not participate. Shown with a single line.
+ - Example: Every employee must work for a department (total), but not every department must have a manager (partial).
+
+
+
+
+
+
+
+ Extended ER Features
+
+
+ - Specialization: dividing an entity into sub-entities. Example: Employee → Manager, Engineer, Clerk. (Top-down)
+ - Generalization: combining multiple entities into one. Example: Car + Truck → Vehicle. (Bottom-up)
+ - Aggregation: treating a relationship as an entity to allow relationships with other entities.
+ - Inheritance: sub-entities inherit attributes from the parent entity.
+
+
+
Specialization is top-down. Generalization is bottom-up. Both lead to the same result in the ERD.
+
+