Database Models in DBMS -

Introduction

A database model defines how data is structured, stored, and managed in a database. Different database models are used based on application needs, scalability, and performance requirements.

There are several types of database models, including:

Hierarchical Model
Network Model
Relational Model (Most Common)
Object-Oriented Model
Document-Oriented Model (NoSQL)
Key-Value Model (NoSQL)
Columnar Model (NoSQL)
Graph Model (NoSQL)

1. Hierarchical Database Model

🔹 Structure: Organizes data in a tree-like hierarchy (parent-child relationship).
🔹 How it Works:

Each parent node can have multiple child nodes.
A child node cannot have multiple parents (one-to-many relationship).
Navigation is done using pointers.
🔹 Example:
A file system where folders (parents) contain subfolders or files (children).
IBM Information Management System (IMS).

💡 Limitations:
❌ Complex queries are difficult due to rigid structure.
❌ Duplication of data leads to inefficiency.

2. Network Database Model

🔹 Structure: Extends the hierarchical model by allowing many-to-many relationships.
🔹 How it Works:

Uses graphs of records where each record can have multiple parents and children.
Relationships are implemented with pointers or links.
🔹 Example:
Integrated Data Store (IDS), used in early telecom databases.

💡 Advantages:
✅ Supports complex relationships between data.
✅ More flexible than hierarchical models.

💡 Limitations:
❌ Requires complex pointers, making updates difficult.
❌ Not widely used in modern databases.

3. Relational Database Model (RDBMS) – Most Common

🔹 Structure: Data is stored in tables (rows & columns) with relationships between them.
🔹 How it Works:

Tables have primary keys to uniquely identify records.
Uses foreign keys to establish relationships between tables.
Accessed using Structured Query Language (SQL).
🔹 Examples:
MySQL, PostgreSQL, Oracle, Microsoft SQL Server.
E-commerce websites storing customer orders.

💡 Advantages:
✅ Data integrity through ACID properties.
✅ Easy to retrieve and manage data using SQL.
✅ Widely used in business applications.

💡 Limitations:
❌ Can become slow when handling huge datasets.
❌ Scaling requires expensive hardware (vertical scaling).

4. Object-Oriented Database Model (OODBMS)

🔹 Structure: Stores data as objects, similar to Object-Oriented Programming (OOP).
🔹 How it Works:

Each object has attributes (data) and methods (functions).
Supports inheritance, encapsulation, and polymorphism.
🔹 Example:
ObjectDB, db4o – Used in CAD systems, multimedia applications.

💡 Advantages:
✅ Efficient for complex data types like images and videos.
✅ Works well with OOP languages like Java, C++.

💡 Limitations:
❌ Not optimized for simple queries.
❌ Less popular than relational databases.

5. Document-Oriented Database Model (NoSQL)

🔹 Structure: Stores data as JSON, BSON, or XML documents instead of tables.
🔹 How it Works:

Each document contains key-value pairs, arrays, and nested data.
No strict schema – flexible for unstructured data.
🔹 Examples:
MongoDB, CouchDB – Used in social media and content management.

💡 Advantages:
✅ Highly scalable (horizontal scaling).
✅ Ideal for big data and real-time applications.

💡 Limitations:
❌ Not ACID-compliant by default.
❌ Complex queries are harder than in SQL databases.

6. Key-Value Database Model (NoSQL)

🔹 Structure: Stores data as key-value pairs.
🔹 How it Works:

Each record consists of a unique key and its associated value.
Values can be simple data types or complex objects.
🔹 Examples:
Redis, Amazon DynamoDB – Used in caching, session storage.

💡 Advantages:
✅ Ultra-fast retrieval using keys.
✅ Best for caching, real-time applications.

💡 Limitations:
❌ Not ideal for complex queries.
❌ Data relationships are difficult to manage.

7. Column-Oriented Database Model (NoSQL)

🔹 Structure: Stores data in columns instead of rows.
🔹 How it Works:

Each column family stores related data together for fast access.
Designed for big data analytics.
🔹 Examples:
Apache Cassandra, HBase – Used in analytics, data warehouses.

💡 Advantages:
✅ Faster for read-heavy workloads.
✅ Highly scalable.

💡 Limitations:
❌ Not ideal for transactional applications.
❌ More complex to design than relational databases.

8. Graph Database Model (NoSQL)

🔹 Structure: Stores data as nodes and edges, representing relationships.
🔹 How it Works:

Nodes represent entities (e.g., people, places).
Edges represent relationships (e.g., “friend of”, “likes”).
🔹 Examples:
Neo4j, ArangoDB – Used in social networks, fraud detection.

💡 Advantages:
✅ Efficient for relationship-based queries.
✅ Ideal for recommendation engines, fraud detection.

💡 Limitations:
❌ Not optimized for simple transactions.
❌ Limited adoption compared to SQL databases.

Comparison Table: Database Models

Model	Structure	Best For	Examples
Hierarchical	Tree-like (parent-child)	File systems, legacy apps	IBM IMS
Network	Graph-like (many-to-many)	Telecom, complex relationships	IDS
Relational (RDBMS)	Tables (rows & columns)	Business apps, finance	MySQL, PostgreSQL
Object-Oriented	Objects (OOP-based)	Multimedia, CAD	ObjectDB
Document-Oriented (NoSQL)	JSON-like documents	Web apps, content management	MongoDB
Key-Value (NoSQL)	Key-value pairs	Caching, real-time data	Redis, DynamoDB
Columnar (NoSQL)	Column families	Big data analytics	Cassandra, HBase
Graph (NoSQL)	Nodes & edges	Social media, fraud detection	Neo4j

Conclusion

Choosing the right database model depends on your application’s needs.

Use RDBMS for structured data and transactional systems.
Use NoSQL for scalability, big data, and real-time applications.
Use Graph databases for highly connected data.