Types of DBMS Models

Before the Relational model became the global standard, databases went through several evolutionary stages. Understanding these helps you appreciate why we use SQL today.

---

Learning Objectives

After completing this chapter, you will be able to:

• Describe the Hierarchical, Network, and Relational data models.
• Explain the advantages and disadvantages of each model.
• Understand why the Relational model won.
• Differentiate between DBMS and RDBMS.
• Compare modern NoSQL models with the classic models.
• Answer interview questions on DBMS types.

---

1. Hierarchical Model (1960s-1970s)

Structure: Data is organized as a tree — parent-child relationships, with each child having exactly one parent.

                        Organization
                       /      |       \
                 Finance    HR      Engineering
                 /    \       |       /    |    \
           Payroll  Budget  Hiring  Dev   QA   Ops

Representation: Records connected via pointers. Navigation is top-down from root to leaves.

Pros	Cons
Very fast for simple lookups	Cannot handle M:N relationships
Easy to understand (like a file system)	Structural changes are difficult
Good for hierarchical data (org charts)	Data must be accessed via parent path

Examples: IBM IMS (still used in banking mainframes), Windows Registry, XML files.

---

2. Network Model

Structure: A graph-like structure where records can have multiple parents.

      Student A ──┐
                  ├── Course X
      Student B ──┤
                  ├── Course Y
      Student C ──┘

Representation: Sets and pointers. Each record can be a member of multiple sets, enabling M:N relationships.

Pros	Cons
Supports M:N relationships	Extremely complex to design
More flexible than hierarchical	Navigation requires knowing pointer paths
Fast access via predefined paths	No data independence (change breaks apps)

Legacy: Influenced modern Graph Databases (Neo4j). The complexity killed it for general use.

---

3. Relational Model (Current Standard)

Structure: Data in tables (relations) with rows (tuples) and columns (attributes). Relationships enforced via keys (Primary/Foreign).

Student Table                    Course Table
┌─────────┬─────────┐           ┌──────────┬───────────┐
│ Std_ID  │ Name    │           │ Course_ID│ Title     │
├─────────┼─────────┤           ├──────────┼───────────┤
│ 101     │ Rahul   │           │ C01      │ DBMS      │
│ 102     │ Priya   │           │ C02      │ OS        │
└─────────┴─────────┘           └──────────┴───────────┘

Enrollment Table
┌─────────┬──────────┐
│ Std_ID  │ Course_ID│
├─────────┼──────────┤
│ 101     │ C01      │
│ 101     │ C02      │
│ 102     │ C01      │
└─────────┴──────────┘

Pros	Cons
Logical data independence	Joins can be expensive
SQL — declarative query language	Requires normalization
Mathematically sound (relational algebra)	Less natural for complex relationships
Easy to understand and use

Examples: MySQL, PostgreSQL, Oracle, SQL Server, SQLite.

---

DBMS vs RDBMS

Feature	DBMS	RDBMS
Data model	Hierarchical, Network, Relational, etc.	Relational (tabular) only
Relationship	Via pointers (hierarchical/network)	Via keys (Primary/Foreign)
Normalization	Not required	Required for integrity
Distributed support	Limited	Strong
ACID compliance	Varies	Standard
Query language	Model-specific	SQL (standardized)
Examples	IMS, MongoDB, Redis	MySQL, PostgreSQL, Oracle

Key insight: All RDBMS are DBMS, but NOT all DBMS are RDBMS.

---

DBMS vs RDBMS Comparison Table

Aspect	DBMS	RDBMS
Storage	As files, hierarchical, or other formats	Tables with rows and columns
Keys	May not have keys	Primary Key, Foreign Key mandatory
Integrity	Application-managed	DBMS-enforced (constraints)
Normalization	Not supported	Supported and encouraged
Security	Basic	Granular (user roles, views)
Multi-user	Limited	Full concurrency control
SQL	May not support	Full SQL support
ACID	Partial	Full

---

NoSQL and Modern Models

NoSQL databases are non-relational DBMS that emerged for web-scale applications:

Type	Example	Use Case
Document	MongoDB	JSON-like flexible schemas
Key-Value	Redis	Caching, session storage
Column-Family	Cassandra	Time-series, IoT data
Graph	Neo4j	Social networks, fraud detection

These are DBMS (not RDBMS) because they don’t use the relational model.

---

Interview Deep Dive

---

Key Takeaways

• The Hierarchical Model uses a tree structure — fast but rigid (no M:N).
• The Network Model uses a graph — flexible but complex.
• The Relational Model uses tables with keys — simple, mathematically sound, and standard.
• All RDBMS are DBMS, but not all DBMS are RDBMS.
• The relational model won because of data independence and SQL.
• NoSQL databases are non-relational DBMS optimized for modern web-scale use cases.