LogoفارسیFA

Database Normalization and Complete Explanation of 7 Normal Forms

Database Normalization is the process of organizing tables in a relational database to reduce data redundancy, eliminate insertion, update, and deletion anomalies, and improve data integrity. It is based on a series of progressive rules called Normal Forms (NF). This article provides a detailed explanation of all 7 layers of normalization — from 1NF to 6NF and DKNF — with practical examples.

Database NormalizationNormal FormsDatabase Design

~4 min read · Updated Apr 15, 2026

Introduction

Database Normalization is one of the fundamental principles of relational database design, introduced by Edgar F. Codd. Its main goal is to reduce data redundancy and eliminate insertion, update, and deletion anomalies. Normalization is achieved by applying progressive rules known as Normal Forms. Each higher form includes the requirements of the previous ones and adds stricter conditions.

In practice, most projects stop at 3NF or BCNF, but understanding all 7 layers is essential for professional database design.

1st Layer: First Normal Form (1NF)

A table must contain atomic (indivisible) values. Each cell should hold only one value, not a list or set.

Requirements:

  • Each column must contain a single value
  • No repeating groups allowed
  • Each row must be unique (usually enforced by a Primary Key)

Non-normalized example:

StudentID | Name | Courses
1         | Ali  | Math, Physics

After 1NF:

StudentID | Name | Course
1         | Ali  | Math
1         | Ali  | Physics

2nd Layer: Second Normal Form (2NF)

A table must be in 1NF and have no partial dependencies. All non-key columns must depend on the entire Primary Key, not just part of it.

Example: A StudentCourse table with a composite key (StudentID, CourseID) where StudentName depends only on StudentID → it must be moved to a separate table.

3rd Layer: Third Normal Form (3NF)

A table must be in 2NF and have no transitive dependencies. No non-key column should depend on another non-key column.

Example: An Employee table with columns EmployeeID, Department, DepartmentLocation → DepartmentLocation depends on Department, not directly on EmployeeID.

4th Layer: Boyce-Codd Normal Form (BCNF)

A stronger version of 3NF. For every functional dependency X → Y, X must be a Super Key.

BCNF covers all functional dependencies more strictly and is sometimes required even when 3NF is technically satisfied.

5th Layer: Fourth Normal Form (4NF)

A table must be in BCNF and have no multi-valued dependencies (independent multivalued facts).

Example: A table storing both EmployeeSkills and EmployeeLanguages as independent facts → these should be split into separate tables.

6th Layer: Fifth Normal Form (5NF) or Project-Join Normal Form (PJ/NF)

A table must be in 4NF and have no join dependencies that are not implied by the candidate keys. The table cannot be decomposed into smaller tables and then rejoined without losing information.

This form is used for very complex cases involving cyclic dependencies.

7th Layer: Sixth Normal Form (6NF) and Domain-Key Normal Form (DKNF)

6NF: The highest level of normalization where each table holds only one type of fact. Tables usually consist of two columns (a key + one attribute). It is particularly useful for temporal data and versioning.

Domain-Key Normal Form (DKNF): A table is in DKNF if all constraints are a logical consequence of domain constraints and key constraints. This form is mostly theoretical and rarely applied in practice.

Advantages and Disadvantages of Normalization

Advantages:

  • Reduces data redundancy
  • Eliminates insertion, update, and deletion anomalies
  • Improves data integrity

Disadvantages:

  • Increases the number of tables and complexity of JOINs
  • May reduce performance in complex queries (sometimes denormalization is needed)

Practical Tips

  • In most real-world projects, 3NF or BCNF is sufficient.
  • For Data Warehouses and analytical systems, denormalization is common.
  • Always balance normalization with performance requirements.

Conclusion

Database Normalization, through the application of 7 Normal Forms, transforms tables into a logical, redundancy-free structure. A deep understanding of these layers helps database designers create efficient, maintainable, and anomaly-free databases. While 1NF to 3NF or BCNF are most commonly used, awareness of higher forms (4NF to 6NF) is essential for handling complex scenarios.

Written & researched by Dr. Shahin Siami

Related Articles

Number-Theoretic Algorithms: GCD, Modular Exponentiation, and RSA

Modern cryptography and countless algorithmic applications rely on a handful of elegant number-theoretic algorithms. This comprehensive guide covers Euclid's algorithm for computing the greatest common divisor, fast modular exponentiation for efficiently computing large powers, and the mathematical foundation of RSA encryption, one of the most widely deployed cryptographic systems in the world.

Continue

Computational Geometry Basics: Orientation, Line Intersection, and Convex Hull

Geometric algorithms solve problems involving points, lines, and shapes, appearing in computer graphics, robotics path planning, and geographic information systems. This comprehensive guide covers the cross-product-based orientation test that underlies nearly every geometric algorithm, segment intersection detection built on that test, and Graham's scan algorithm for computing the convex hull of a set of points.

Continue

String Matching Algorithms: Naive Search, Rabin-Karp, and Beyond

Searching for a pattern within a larger text is one of the most common operations in computing, from text editors to DNA sequence analysis. This comprehensive guide covers the naive string-matching algorithm and its quadratic worst case, then explains the Rabin-Karp algorithm's clever use of hashing to achieve fast average-case performance, including how it handles hash collisions correctly.

Continue

Approximation Algorithms: Getting Provably Close to Optimal for Hard Problems

When a problem is proven NP-complete, an exact efficient solution is unlikely to exist, but that does not mean giving up on the problem entirely. This comprehensive guide explains approximation algorithms, which sacrifice guaranteed optimality for guaranteed efficiency, covering the vertex cover and traveling salesman problems as classic examples with provable approximation ratios.

Continue

NP-Completeness Explained: P, NP, and Why Some Problems Resist Efficient Solutions

Some problems have resisted every attempt at an efficient algorithm for decades, yet no one has proven an efficient solution is impossible. This comprehensive guide explains the classes P and NP, the concept of polynomial-time reductions used to compare problem difficulty, and how proving a problem NP-complete provides strong evidence, though not proof, that no efficient algorithm exists.

Continue

Maximum Flow: Ford-Fulkerson and the Min-Cut Max-Flow Theorem

Maximum flow problems model the largest possible throughput through a network with capacity-limited connections, from water pipes to data networks. This comprehensive guide introduces flow networks, walks through the Ford-Fulkerson method for finding maximum flow using augmenting paths, and explains the elegant min-cut max-flow theorem that connects two seemingly different problems into one.

Continue
Next Article