NETWORK DATA MODELLING

Network Data Modelling is a pre-relational database approach that organizes data using owner–member sets, allowing records to participate in multiple parent and child relationships. Unlike the strict tree structure of hierarchical modelling, the network model forms a flexible graph-like structure where records can have many-to-many connections.

The goal of the network model was to overcome the limitations of hierarchical databases. In hierarchical systems, each child could have only one parent, making many-to-many relationships difficult or impossible to represent naturally. The network model removed this restriction by allowing records to be linked through multiple set relationships.

Historically, this model gained prominence in the 1960s through the CODASYL Data Base Task Group and systems such as IDMS. It became widely used in banking, insurance, and government systems before the relational model emerged.

In the loan approval domain, a network structure might represent:

• Customer → LoanApplication (one-to-many)
• LoanApplication → LoanOfficer (many-to-many)
• LoanApplication → Branch (one-to-many)
• LoanApplication → Repayment (one-to-many)

Here, a LoanApplication can be reviewed by multiple LoanOfficers, and each LoanOfficer can handle multiple LoanApplications. This flexibility was a major improvement over hierarchical trees.

However, the model requires navigational querying. Developers must explicitly define how to traverse from one record to another. For example, retrieving “all officers linked to loans of a specific customer across branches” requires procedural traversal logic. Unlike relational SQL, which declares what result is needed, the network model forces the application to specify how to reach it.

It is important to note that normalization theory does not apply to the network model. Like hierarchical modelling, it predates the relational model and does not rely on functional dependencies or relational algebra.

The strengths of network modelling include support for many-to-many relationships and more flexible cross-linking than hierarchical systems. It can be efficient for fixed navigational queries where access paths are well understood.

Its weaknesses are equally significant. It requires procedural navigation, making ad-hoc analysis difficult. Schema changes can ripple into application logic. The model lacks the mathematical foundation and abstraction provided by relational databases.

Today, traditional network databases are obsolete for new system design. However, the conceptual idea of interconnected records lives on in modern graph databases. In that sense, the network model can be viewed as an early ancestor of graph-based modelling.

Network Data Modelling represents a critical evolutionary step between hierarchical and relational systems. It introduced flexible relationships but lacked the declarative simplicity and theoretical rigor that later defined modern database architecture.

Network Data Modelling vs. Ontologies

At a visual level, Network Data Modelling and Ontology Modelling can appear very similar. Both allow entities to connect to multiple other entities. Both produce graph-like diagrams rather than tree structures. However, the similarity is structural only. Their purpose, behavior, and conceptual foundations are entirely different.

The distinction becomes clear when we examine their core ideas, querying style, semantics, and flexibility.

Core Idea

The Network Model, popular in the 1960s and 1970s (e.g., CODASYL/IDMS), was a storage technique. Relationships were implemented as physical pointers between records using owner–member sets. The model focused on how data was stored and how applications navigated through it.

An Ontology, typically expressed in standards such as OWL or RDF, is a knowledge representation model. It defines concepts, properties, hierarchies, and logical rules. The focus is not storage, but meaning and reasoning.

The network model organizes data records. An ontology organizes knowledge.

Querying

In the Network Model, queries are navigational and procedural. The developer must explicitly specify the traversal path. For example: Customer → Loan → Officer

The application dictates how to move from one record to another.

In ontology-based systems, queries are declarative and semantic. A user may ask:

“Which officers approved loans for high-risk customers?”

The system uses logical reasoning across defined classes, properties, and rules to infer results. The query does not describe a traversal path; it describes a semantic intention.

The difference is critical: the network model navigates links, while ontologies reason over meaning.

Semantics

The Network Model contains no inherent semantic understanding. It connects records through pointers, but the system does not “know” what a Customer or Loan represents. It merely stores and traverses links.

Ontologies encode meaning. They define relationships such as:

• Loan is_a FinancialAgreement
• Officer approves Loan

They may also define constraints, inheritance hierarchies, and logical implications. Machines can infer new facts from these definitions. For example, if HighRiskLoan is defined as a type of Loan with certain characteristics, a reasoning engine can automatically classify instances accordingly.

The network model connects data. Ontologies interpret data.

Flexibility

Network relationships are hard-coded. Changing relationship structures typically requires schema redesign and application reprogramming. The structure is tightly coupled to procedural logic.

Ontologies are extensible. New concepts and relationships can be added without breaking existing structures. Because they operate at a semantic layer, they allow knowledge to evolve more fluidly.

Why They Feel the Same

Both models allow entities to connect to multiple other entities. Both produce graph-like diagrams rather than trees. This visual similarity often leads to confusion.

The difference can be summarized simply:

• Network = data navigation.
• Ontology = knowledge and meaning.

The Network Model was a storage structure built around pointers and traversal logic. Ontologies are semantic frameworks designed for shared understanding and reasoning.

Understanding this distinction prevents a common misconception: although both appear graph-like, the network model is an early database storage mechanism, while ontologies are modern knowledge representation systems used in AI, semantic integration, and intelligent applications.

They share a shape, but not a purpose.