====== Relational Database ======
A **relational database** is a database management system that organizes data using the relational model, a theoretical framework introduced by Edgar F. Codd in 1970 (([[https://dl.acm.org/doi/10.1145/362384.362685|Codd - A Relational Model of Data for Large Shared Data Banks (1970]])). The relational model structures data into **tables** (also called relations), where each table comprises **rows** (tuples) and **columns** (attributes) with explicit **keys** that enforce relationships between tables. This structured approach contrasts with other data models by focusing on how data is [[logically|logically]] organized rather than on performance optimization specifics.

===== Core Structural Components =====
Relational databases are built on several fundamental components that define their architecture and functionality. **Tables** serve as the basic storage unit, with each table representing an entity type such as customers, products, or orders. Each column in a table represents an attribute with a defined data type, while rows contain individual records. **Primary keys** uniquely identify each row within a table, ensuring data integrity and preventing duplicate records. **Foreign keys** establish relationships between tables by referencing primary keys in other tables, creating the relational structure that gives this model its name (([[https://www.postgresql.org/docs/current/ddl-constraints.html|PostgreSQL Documentation - Constraints (2024]])).

The **schema** defines the structure of the database, including table definitions, column data types, constraints, and relationships. This predefined schema enforces data [[consistency|consistency]] and prevents invalid data from being inserted. Unlike schema-less systems, the rigid schema in relational databases ensures that all records conform to the same structure, which provides predictability but requires careful planning during design phases.

===== The Relational Model Versus Transaction Optimization =====
An important conceptual distinction exists between the relational model and transactional database systems. The relational model is fundamentally a //data model//—a theoretical framework for describing how data is organized and related. This contrasts with transaction optimization, which addresses how efficiently a system executes operations. Relational and transactional databases describe different aspects of a system: relational databases are defined by their data model (tables, rows, columns, keys, and schemas), while transactional databases are defined by their optimization function (handling high-volume real-time read/write operations with ACID guarantees) (([[https://www.databricks.com/blog/what-is-a-transactional-database|Databricks - Relational vs Transactional Databases (2026]])). A system can be relational without being transactional, transactional without being relational, or both. A relational database may be optimized for various purposes, including **OLTP** (Online Transactional Processing) for high-frequency small transactions, **OLAP** (Online Analytical Processing) for analytical queries, or hybrid approaches. The relational model itself is database-agnostic; it describes the structural organization independently of performance characteristics (([[https://www.databricks.com/blog/what-is-a-transactional-database|Databricks - What is a Transactional Database (2026]])).

===== Key Features and Advantages =====
Relational databases provide several significant advantages that have made them the dominant database paradigm for decades. **[[acid_compliance|ACID compliance]]** (Atomicity, Consistency, Isolation, Durability) ensures reliable transaction processing and data integrity (([[https://en.wikipedia.org/wiki/ACID|Wikipedia - ACID (2024]])). **Normalization** techniques reduce data redundancy and improve data quality through systematic table structuring. **SQL** (Structured Query Language) serves as a standardized, powerful query language that enables complex data retrieval through declarative syntax rather than imperative programming.

**Data integrity constraints** enforce relationships and rules at the database level, preventing inconsistent states. **Scalability** through **vertical scaling** (adding resources to a single server) and **horizontal scaling** through **sharding** and **replication** allows relational databases to handle growing data volumes. **Backup and recovery mechanisms** provide disaster recovery capabilities essential for mission-critical applications.

===== Limitations and Modern Challenges =====
Despite their strengths, relational databases face challenges in specific modern scenarios. **Rigid schemas** can be inflexible when dealing with unstructured or semi-structured data, such as JSON documents or varying content types. **Join operations** across multiple tables can become computationally expensive with large datasets, potentially causing performance bottlenecks. **Horizontal scalability** across distributed systems introduces complexity, as maintaining ACID guarantees across multiple nodes requires sophisticated distributed consensus mechanisms (([[https://arxiv.org/abs/1509.05393|Corbett et al. - Spanner: Google's Globally-Distributed Database (2012]])).

**Fixed column structures** create inefficiency when only a subset of columns is populated, wasting storage space. For applications requiring extreme write throughput or handling massive volumes of streaming data, traditional relational databases may require specialized optimization techniques or alternative architectures altogether.

===== Contemporary Applications =====
Relational databases remain the foundation of enterprise data infrastructure across industries. **Financial systems** leverage relational databases for transaction processing, ensuring data consistency and regulatory compliance. **ERP** (Enterprise Resource Planning) and **CRM** (Customer Relationship Management) systems depend on relational structures to manage complex business entities and relationships. **E-commerce platforms** use relational databases for inventory management, order processing, and customer data. **Healthcare information systems** rely on relational schemas to maintain patient records while enforcing regulatory requirements like HIPAA.

Modern relational database systems including **[[postgresql|PostgreSQL]]**, **MySQL**, **Oracle Database**, and **Microsoft SQL Server** continue to evolve, incorporating JSON support, distributed transaction capabilities, and advanced indexing strategies to address contemporary requirements while preserving relational model foundations. **MySQL**, as an open-source relational database system, exemplifies this evolution by supporting transactional workloads and providing SQL-based querying capabilities with defined schemas and key-based relationship enforcement (([[https://www.databricks.com/blog/what-is-a-transactional-database|Databricks - What is a Transactional Database (2026]])).


===== See Also =====

  * [[nosql_database|NoSQL Database]]
  * [[sql|SQL]]
  * [[postgresql|PostgreSQL]]
  * [[sql_server|SQL Server]]
  * [[oracle|Oracle]]

===== References =====