Database management systems have evolved through several conceptual models. Choosing the appropriate architecture requires an in-depth understanding of the four primary paradigms: Relational (RDBMS), Object-Oriented, NoSQL, and Hierarchical models.
Relational databases represent the most widely adopted database paradigm. Designed in the 1970s, they store data in structured tables, representing entities and relationships through schema-enforced attributes.
Relational databases store information in discrete tables with fixed rows and columns. Tables are joined together dynamically by shared fields known as foreign keys. They utilize **Structured Query Language (SQL)** as a standardized querying interface for all operations: Creating, Reading, Updating, and Deleting (CRUD) data.
User table containing profile information. When a user makes a purchase, the purchase is recorded in a separate Purchases table. Rather than duplicating user data inside purchases, the tables are dynamically joined together via a foreign key (e.g. User.id = Purchases.userId).Object-Oriented databases align directly with the object-oriented programming (OOP) paradigm, bridging the semantic gap between application code objects and disk storage patterns.
OODBMS models are defined by core OOP concepts: Inheritance, Object-Identity, and Encapsulation (information hiding) with custom methods providing an interface to interact with data.
While traditional entity-relationship models support complex structures to some extent, it is encapsulation and unique object identifiers (OIDs) that distinguish OODBMS from E-R designs. Data is treated strictly as an object; all related bits of information are stored and loaded as one instantly available object package, rather than split across multiple tables.
NoSQL represent a scale-out alternative to the rigid tabular paradigms, offering high velocity write rates, geo-replication, and dynamic schemas.
NoSQL ("not only SQL") databases store data in alternative non-tabular structures, supporting Document, Key-Value, Wide-Column, and Graph formats. They provide highly flexible schemas, allow structures to adjust dynamically, and easily scale horizontally across commodity clusters to handle Big Data volumes.
For a complete deep-dive into NoSQL history, advantages, data models (Key-Value, Columnar, Document, Graph), and limitations, please check out the dedicated lesson module.
Hierarchical databases structure data in strict, nested parent-child trees. They are highly efficient for concrete, one-to-many organizational charts.
The schema of a hierarchical database is structured as a tree organization. It begins at a root "parent" directory of data stored as records that links to various other subdirectory branches, and each subdirectory branch, or child record, may link to various other subdirectory branches. While a parent record can have several child records, each child record is strictly restricted to only one parent record.
Data within records is stored in the form of fields, and each field can only contain one value. Retrieving hierarchical data from a hierarchical database architecture requires traversing the entire tree, starting at the root node.
Because physical disk storage systems are inherently structured hierarchically (e.g. tracks, sectors, clusters), hierarchical models can also be used as physical models. Due to the separation of the tables from physical storage structures, information can easily be added or deleted without affecting the entirety of the database.
Network databases act as a powerful extension of Hierarchical databases, discarding strict single-parent limits to support complex graph network structures.
Network databases are an extension of Hierarchical databases where the child records are given the freedom to associate with multiple parent records. Rather than a tree, they are organised in a Graph structure, allowing them to handle and capture complex relations.
By arranging data records in a graph where records form vertices and associations act as edges, Network databases solve the duplication limits of strict trees.