Edgar F. Codd proposed the Relational Model in 1970 and later introduced a set of principles known as Codd’s Rules. These rules define the standards a database system should follow to be considered a true Relational Database Management System (RDBMS).

Codd’s Rules act as theoretical guidelines for relational databases and focus on:

  • data consistency

  • integrity

  • independence

  • relational behavior

Although they are popularly called Codd’s 12 Rules, Codd actually numbered them from Rule 0 to Rule 12, making a total of 13 rules.

Modern relational database systems such as:

  • MySQL

  • PostgreSQL

  • Oracle Database

  • Microsoft SQL Server

are heavily inspired by these principles.

Rule 0: Foundation Rule

A database system can be considered relational only if it manages the entire database using relational capabilities.

This means:

  • data must be stored as relations (tables)

  • operations must follow relational concepts

  • users interact through relational methods

If a system mixes non-relational behavior as its core mechanism, it cannot be called a true RDBMS according to Codd.

Rule 1: Information Rule

All information in the database must be represented only as values in tables.

This means:

  • data is stored in rows and columns

  • there are no hidden pointers or hidden storage mechanisms visible to users

  • every piece of information appears as table values

Example:

STUDENT Table

Roll_No | Name | Branch
------------------------
101     | Aman | CSE
102     | Riya | ECE

All data exists only in relational form.

Rule 2: Guaranteed Access Rule

Every individual data value must be accessible using:

  • table name

  • primary key value

  • column name

This guarantees that every data item can be uniquely identified and retrieved.

Example:

  • Table: STUDENT

  • Primary Key: Roll_No = 101

  • Column: Name

This combination should uniquely return:

  • Aman

Rule 3: Systematic Treatment of NULL Values

The DBMS must support NULL values properly and consistently.

NULL represents:

  • missing data

  • unknown data

  • not applicable values

Example:

EMPLOYEE Table

Emp_ID | Name | Phone
----------------------
1      | Aman | NULL

NULL does not mean:

  • zero

  • blank space

  • false

The DBMS should handle NULL uniformly in:

  • comparisons

  • joins

  • queries

  • calculations

Rule 4: Active Online Catalog

Metadata must itself be stored as relational tables.

Metadata includes:

  • table definitions

  • column information

  • constraints

  • indexes

  • user permissions

Users should be able to query metadata using the same relational language.

Example SQL:

SHOW TABLES;

or

DESCRIBE STUDENT;

The system catalog behaves like regular relational data.

Rule 5: Comprehensive Data Sub-Language Rule

The system must support at least one complete relational language capable of handling:

  • DDL (Data Definition Language)

  • DML (Data Manipulation Language)

  • view definitions

  • integrity constraints

  • authorization

  • transaction management

In modern systems, this language is usually SQL.

Example:

CREATE TABLE STUDENT (
    Roll_No INT PRIMARY KEY,
    Name VARCHAR(50)
);

Rule 6: View Updating Rule

All views that are theoretically updatable should be updatable by the DBMS.

A view is a virtual table created from base tables.

Example:

CREATE VIEW CSE_STUDENTS AS
SELECT Roll_No, Name
FROM STUDENT
WHERE Branch='CSE';

If updating the view is logically possible, the DBMS should allow it.

Rule 7: High-Level Insert, Update, and Delete

The DBMS must support set-level operations instead of only record-by-record operations.

This means:

  • multiple rows can be modified together

  • bulk operations should be possible

Example:

UPDATE EMPLOYEE
SET Salary = Salary + 5000
WHERE Dept='IT';

The operation updates many rows at once.

Rule 8: Physical Data Independence

Changes in physical storage should not affect application programs.

Examples of physical changes:

  • changing indexing methods

  • changing file organization

  • moving storage locations

Applications should continue working without modification.

This allows DBAs to optimize storage internally without changing user programs.

Rule 9: Logical Data Independence

Changes in logical structure should not affect existing applications.

Examples:

  • adding new columns

  • creating new tables

  • splitting tables internally

Applications using older structures should continue functioning whenever possible.

Logical independence is harder to achieve than physical independence.

Rule 10: Integrity Independence

Integrity constraints must be stored inside the DBMS catalog rather than hardcoded inside applications.

Examples:

  • PRIMARY KEY constraints

  • FOREIGN KEY constraints

  • UNIQUE constraints

  • CHECK conditions

Example:

CREATE TABLE STUDENT (
    Roll_No INT PRIMARY KEY,
    CGPA FLOAT CHECK (CGPA <= 10)
);

The DBMS itself enforces integrity rules.

Rule 11: Distribution Independence

Users should not need to know whether the database is:

  • centralized

  • distributed

  • spread across multiple servers

The system should behave the same way regardless of data distribution.

This rule supports distributed database systems.

Rule 12: Non-Subversion Rule

If low-level access methods exist, they must not bypass relational integrity rules.

This prevents:

  • unauthorized modifications

  • corruption of constraints

  • invalid direct manipulation

All operations must still respect:

  • keys

  • constraints

  • integrity rules

Even internal access methods should not violate relational principles.

Why Codd’s Rules Are Important

Codd’s Rules are important because they:

  • define characteristics of a true relational system

  • promote data independence

  • improve consistency and integrity

  • provide a theoretical foundation for RDBMS design

They helped shape modern database systems and influenced SQL-based relational technology.

Practical Importance

Although no commercial DBMS fully satisfies every rule perfectly, most modern RDBMS systems follow these principles closely.

Examples:

  • MySQL

  • PostgreSQL

  • Oracle Database

  • Microsoft SQL Server

These systems implement:

  • relational tables

  • SQL

  • constraints

  • transactions

  • views

  • indexing

  • data independence concepts

Academic Importance

Codd’s Rules are extremely important in:

  • university DBMS courses

  • database theory

  • competitive exams

  • interview preparation

They are frequently asked in:

  • B.Tech exams

  • MCA exams

  • GATE

  • UGC NET

  • placement interviews

Summary

Codd’s Rules define the theoretical principles of a true Relational Database Management System. Introduced by Edgar F. Codd, these rules focus on relational storage, integrity, data independence, consistency, and standardized access. They provide the foundation for modern RDBMS systems and remain highly important from both academic and practical database-design perspectives.