The document discusses several database management system (DBMS) models: - Relational, network, hierarchical, object-oriented, and object-relational models are described as the main DBMS models. - Key aspects of each model are covered, including data structure, relationships, querying capabilities, and advantages/disadvantages. - Examples are provided for the relational model in the form of a sample table and for the hierarchical model in terms of its data structure and relationships. - Overall the document provides a high-level overview and comparison of the main DBMS models.

1. DIFFERENT MODELS IN
DBMS
BY
PEPITHASRI S

2. INTRODUCTION:
 DBMS Model is defined as the logical plan and arrangement of a database which
describes how the data info will be stored, retrieved and modified in a database
management system.
 This DBMS Model illustrates the coherent structure of a database server that consists
of the relationships and limitations which helps to regulate how data information can be
preserved and fetched later.
 Database models can be independently designed on the basis of guidelines and ideas of
whichever larger data model the creators approve.
 There are different kinds of DBMS Models which matches to different phases of the
database design procedure.

3. DIFFERENT DBMS MODELS
 Relational Model
 Network Model
 Hierarchical Model
 Object-Oriented Database Model
 Object Relational Model (It syndicates the two which create up its
name)
 Entity-Relationship Model
 Record Based DBMS Model
 Document Database Model

4. Relational Model
 The relational model represents DB in the form of a collection of various relations. This relation
refers to a table of various values. And every row present in the table happens to denote some real-
world entities or relationships.
 It also represents how data is stored in Relational Databases. A relational database consists of a
collection of tables, each of which is assigned a unique name..
 Thus, in the relational model, basically, this data is stored in the form of tables. However, this
data’s physical storage is independent of its logical organisation.
 This model generates one to one, many to many and one to many relationships. The tables can be
normalized within the database by following certain rules where every piece of data is broken into
small or, say, nuclear pieces, which are beneficial.

5. Properties of a Relational Model
• Every row is unique
• All of the values present in a column hold the same data
type
• Values are atomic
• The columns sequence is not significant
• The rows sequence is not significant
• The name of every column is unique

6. Advantages
• Simplicity and Ease of Use: The relational model offers a simple and intuitive way to
organize and represent data. It uses tables with rows and columns, making it easy for
users to understand and work with the data.
• Data Independence: The relational model provides data independence, separating the
logical structure of the data (schema) from its physical storage. This allows for
flexibility in modifying the database schema without affecting the applications or
queries built on top of it.
• Flexibility and Scalability: The relational model offers great flexibility in querying and
manipulating data. It supports powerful query languages, such as SQL (Structured
Query Language), which provide rich functionalities for retrieving, updating, and
aggregating data. Additionally, relational databases can handle large amounts of data
and scale well as data volumes increase.
• Data Integrity and Consistency: The relational model enforces data integrity through
various constraints, such as primary keys, foreign keys, and unique constraints. These
constraints ensure the consistency and accuracy of data, preventing the introduction of
inconsistent or invalid records.

7. Disadvantages
• Complex Joins and Performance: When dealing with complex data relationships,
performing joins between multiple tables can become complex and computationally
expensive. Inefficient query design or lack of appropriate indexes can result in
performance issues.
• Data Redundancy: In some cases, the relational model can lead to data redundancy,
meaning the same data is stored in multiple tables. Redundancy can consume
additional storage space and increase the complexity of maintaining data consistency.
• Limited Flexibility for Unstructured Data: The relational model is primarily
designed for structured data with well-defined schemas. Handling unstructured or
semi-structured data, such as text documents or multimedia files, can be challenging
within the relational model. This has led to the rise of other database models, like
NoSQL and document databases, that better accommodate such data types.
• Impedance Mismatch: The relational model and object-oriented programming
languages often have a mismatch in their data models. Mapping objects to relational
tables (object-relational mapping) can introduce complexities and difficulties in
maintaining consistency between the two models.

8. ID_NO NAME ADDRESS ROLL_NO AGE
C1 RIYA DELHI 15 20
C2 SUNITA GURGAON 16 22
C3 ASHWANI ROHTAK 12 18
C4 PREETI DELHI 17 25
Now, let us consider a relation EMPLOYEE with attributes ID_NO, NAME, ADDRESS, ROLL_NO, and
AGE shown in this table

9. Network Model
• The network model is a database model that organizes data in a network-like
structure, allowing records to have multiple parent-child relationships. It was
developed as an extension of the hierarchical model to address its limitations.
• In the network model, data is represented as collections of records, and the
relationships between records are established using set relationships called sets.
• A set consists of a parent record type, a member record type, and a set type. The
set type defines the nature of the relationship, such as one-to-one, one-to-many,
or many-to-many.

10. key features of the network model:
• Records: Data is stored in records, which are similar to the concept of rows in the
relational model. Each record contains fields or attributes that hold specific data values.
• Sets: Sets are used to define relationships between records. A set allows a member record
to be linked to one or more parent records. This capability enables complex relationships
and allows records to have multiple paths to access related data.
• Parent-Child Relationships: In the network model, records are organized in parent-
child relationships. A parent record can have multiple child records, and a child record
can have multiple parent records.
• Access Paths: The network model provides multiple access paths to navigate through the
data. Each set in the network model is associated with a specific access path, allowing
efficient retrieval of related records.
• Data Integrity: The network model supports data integrity through the use of
constraints, such as mandatory relationships, cardinality constraints, and referential
integrity.

11. Advantages
• Flexibility in Data Relationships: The network model offers greater flexibility in
representing complex data relationships compared to the hierarchical model. It
allows for many-to-many relationships between records, enabling more diverse and
intricate connections between data elements.
• Efficient Data Access: The network model provides efficient data access by
allowing direct access to related records without the need for navigating through the
entire hierarchical structure. It utilizes set-based operations and pointers, which can
result in faster data retrieval.
• Data Integrity: Similar to the hierarchical model, the network model enforces data
integrity through referential integrity constraints. It ensures that each record has
valid connections to other related records, maintaining data consistency.
• Data Sharing and Integration: The network model supports data sharing and
integration between different applications or database systems. Records in the
network model can have multiple owners or users, enabling shared access to data
and facilitating collaboration.

12. Disadvantages
• Complexity and Learning Curve: The network model has a higher level of complexity
compared to the hierarchical and relational models. Understanding and designing a network
database can be challenging, requiring a deeper understanding of data relationships and
navigating through the network structure.
• Lack of Structural Independence: Unlike the relational model, the network model lacks
structural independence. Modifying the database schema often requires changes to the entire
network structure, which can be cumbersome and may impact existing applications and
data.
• Limited Scalability: The network model can face limitations in terms of scalability,
especially when dealing with large and evolving data structures. Adding or modifying data
relationships may require significant restructuring of the entire network, making it less
flexible and less suitable for rapidly changing data requirements.
• Data Redundancy and Complexity: The network model can suffer from data redundancy
when multiple relationships are defined between records. This redundancy can result in
increased storage requirements and complexity in maintaining data consistency and
integrity.

13. Hierarchical Model
In this model, data records are arranged into a tree-like organization,
where every record includes only a root or a parent.
The sibling records are arranged in specific in a distinct order which
is then implemented as the physical order for storing the database.
For explaining several real-world relationships, this type of model is
useful.
In the ’60s and ’70s, this model was normally implemented by
IBM’s Information Management Systems. However, due to few
functioning disorganizations, they are infrequently seen currently.

14. 1. Data Structure: Data is organized in a hierarchical structure, resembling a tree.
Each record is connected to one or more parent records and may have multiple child
records. The relationships are represented as one-to-many relationships, where each
parent can have multiple children, but each child has only one parent.
2. Parent-Child Relationships: The hierarchical model uses parent-child
relationships to represent the organization and structure of data. A parent record is
called a segment, and a child record is called a subordinate segment. The segments are
connected through pointers or links.
3. Access Paths: The hierarchical model provides predefined access paths that allow
efficient navigation through the data structure. The access paths follow the hierarchical
relationships, enabling easy traversal from parent records to child records.
Features of the Hierarchical Model model

15. 4. Data Integrity: The hierarchical model enforces data integrity through
hierarchical relationships. It ensures that each child record must have a valid
parent record and maintains referential integrity within the structure.
5. Rigidity: The hierarchical model has a rigid and inflexible structure since it
relies on predefined parent-child relationships. Any changes to the structure
require modifying the database schema and potentially impacting existing
data and applications.
6. Querying: Querying in the hierarchical model typically involves traversing
the hierarchy using predefined access paths.
Query languages specific to the hierarchical model, such as IMS DL/I (Data
Language/I), were used to retrieve data based on the hierarchical structure

16. Advantages
• Simplicity: The hierarchical model is relatively simple to understand and
implement. It follows a straightforward parent-child relationship structure, which
makes it easy to visualize and navigate the data.
• Efficient Data Retrieval: The hierarchical model provides efficient data
retrieval when accessing data in a top-down manner. Traversing the hierarchical
structure using predefined access paths allows for quick and direct access to
related records.
• Data Integrity: The hierarchical model enforces data integrity through
hierarchical relationships. Each child record must have a valid parent record,
ensuring the consistency and integrity of the data.
• Performance: The hierarchical model can offer excellent performance for
certain types of data access patterns. It is particularly efficient when the access
patterns align with the hierarchical structure, such as when retrieving all child
records of a specific parent.

17. Disadvantages
Lack of Flexibility: The hierarchical model has limited flexibility and is less adaptable to
changes in the data structure. Any modifications to the structure, such as adding or
rearranging records, require altering the database schema and potentially impacting existing
data and applications.
Complex Relationships: The hierarchical model struggles with representing complex
relationships that do not fit neatly into a strict parent-child hierarchy. Many-to-many
relationships or non-hierarchical relationships are challenging to represent effectively within
the hierarchical model.
Data Redundancy: In the hierarchical model, data redundancy can occur when multiple
child records need to refer to the same parent record. This redundancy can lead to data
inconsistency and increased storage requirements.

18. The Object-Oriented (OO) Model
• The hierarchical model is a database model that organizes data in a tree-like
structure with parent-child relationships. It was one of the earliest database
models, primarily used in early mainframe database systems like IBM's
Information Management System (IMS).
In the hierarchical model:
• Data Structure: Data is organized in a hierarchical structure, resembling a tree.
Each record is connected to one or more parent records and may have multiple
child records. The relationships are represented as one-to-many relationships,
where each parent can have multiple children, but each child has only one parent.
• Parent-Child Relationships: The hierarchical model uses parent-child
relationships to represent the organization and structure of data. A parent record is
called a segment, and a child record is called a subordinate segment. The segments
are connected through pointers or links.

19. • Access Paths: The hierarchical model provides predefined access paths that allow
efficient navigation through the data structure. The access paths follow the
hierarchical relationships, enabling easy traversal from parent records to child
records.
• Data Integrity: The hierarchical model enforces data integrity through
hierarchical relationships. It ensures that each child record must have a valid
parent record and maintains referential integrity within the structure.
• Rigidity: The hierarchical model has a rigid and inflexible structure since it relies
on predefined parent-child relationships. Any changes to the structure require
modifying the database schema and potentially impacting existing data and
applications.
• Querying: Querying in the hierarchical model typically involves traversing the
hierarchy using predefined access paths. Query languages specific to the
hierarchical model, such as IMS DL/I (Data Language/I), were used to retrieve
data based on the hierarchical structure

20. Advantages
• Modularity and Code Reusability: The OO model promotes modularity by
encapsulating data and behavior within objects. This modularity allows for code
reusability, as objects and classes can be easily reused in different parts of an
application or in different applications altogether.
• Data Abstraction and Encapsulation: The OO model provides data abstraction,
allowing complex data structures to be represented as objects with well-defined
interfaces. Encapsulation ensures that the internal details of objects are hidden,
protecting the integrity of data and providing a clear separation between the
implementation and usage of objects.
• Inheritance and Polymorphism: The OO model supports inheritance, allowing
classes to inherit attributes and methods from parent classes. Inheritance promotes
code reuse, enhances modularity, and enables the creation of hierarchical
relationships. Polymorphism, another feature of the OO model, allows objects of
different classes to be treated uniformly through common interfaces, enabling
flexible and extensible designs.

21. Disadvantages
• Performance Overhead: The object-oriented model can introduce performance
overhead compared to more low-level or procedural approaches. The abstraction
and encapsulation layers add an extra level of indirection, which can impact
performance-critical applications.
• Complexity: Object-oriented programming can sometimes lead to complex code
structures, especially when the system becomes large or when the relationships
between objects become intricate. Maintaining a clear and understandable design
becomes crucial to avoid confusion and maintain code quality.
• Learning Curve: Understanding and effectively applying the principles of the OO
model can have a steeper learning curve compared to procedural programming.
Object-oriented concepts, such as inheritance, polymorphism, and design patterns,
require additional knowledge and experience to be used effectively.

23. THANK YOU