What is Normalization in DBMS (SQL)? A Comprehensive Guide to 1NF, 2NF, and 3NF Examples

By Cristian G. Guasch • Updated: 07/12/23 • 19 min read

Here’s the deal: Normalization in DBMS (SQL) is a process that helps you keep your data organized and reduces redundancy to a minimum. It’s all about structuring your data in such a way that it adheres to certain rules, known as normal forms. Understanding this process can be a game changer when it comes to managing databases efficiently.

So, what are these so-called normal forms? They’re essentially rules or guidelines for database design. The most common ones are 1NF (First Normal Form), 2NF (Second Normal Form), and 3NF (Third Normal Form). Each of them has its own specific set of criteria which we’ll delve into later.

Let me give you an example: Imagine trying to organize your personal book collection. You wouldn’t want duplicate copies of the same title lying around, would you? That’s where normalization steps in – it helps eliminate redundancy in your ‘book database’ by ensuring that each title appears only once.

Understanding Normalization in DBMS

When it comes to database design, normalization is a technique that’s crucial for reducing data redundancy and eliminating undesirable characteristics such as Insertion, Update and Deletion Anomalies. It works by dividing larger tables into smaller ones and linking them using relationships. The goal of Normalisation in SQL? To get rid of redundant or repetitive data and ensure that everything is stored logically.

Edgar Codd, the brains behind the relational model, introduced us to this theory of data normalization with the First Normal Form (1NF). But he didn’t stop there. He went on to extend his theory with the Second (2NF) and Third Normal Form (3NF). Later on, Raymond F. Boyce joined him to develop what we now know as the Boyce-Codd Normal Form.

Here are some common normal forms you’ll come across in SQL:

  • 1NF (First Normal Form)
  • 2NF (Second Normal Form)
  • 3NF (Third Normal Form)
  • BCNF (Boyce-Codd Normal Form)
  • 4NF (Fourth Normal Form)
  • 5NF (Fifth or Project-Join Normal Form)

The normalization theory doesn’t end there though; there’s even talk about a Sixth normal form! However, most practical applications find their best fit at 3rd normal form.

To really understand Database normalization though, examples can be incredibly useful. Let’s say a video library maintains a database of movies rented out. Without any kind of normalization all information would be lumped together in one table – not ideal!

But when we apply our first rule of normalization – having each table cell contain only a single value and ensuring each record remains unique – things start looking better already.

Before digging deeper though it might be helpful to define what exactly an SQL KEY is: This is simply a value used to identify records in a table uniquely. It could be either single column or combination of multiple columns depending on your needs.

A primary key then takes this concept further by being used specifically for identifying database records uniquely while also having certain attributes like non-nullability, uniqueness, immutability and mandatory nature during insertion of new records.

On occasion you might need more than one column for identification purposes which leads us to composite keys – primary keys composed from multiple columns for unique identification.

Now onto second normal form: To achieve this your database must already be at 1st normal form plus have Single Column Primary Key that does not functionally dependant on any subset of candidate key relation. This typically results into partitioning your former tables into new ones where related information gets bunched together making it easier for referencing through foreign keys which are essentially references back to primary keys from other tables!

Foreign Keys help maintain referential integrity by only allowing values that exist in their referenced parent’s unique key field thus helping avoid anomalies during operations like insertions where they may otherwise cause problems due their non-existing reference points if not well checked.

Transitive functional dependencies finally bring us full circle back towards understanding why these concepts matter so much with an example scenario where changing Full Name may impact Salutation due its dependency – something easily managed when properly normalized!

The Role of SQL in Database Normalization

In the world of database management systems (DBMS), normalization is a key concept to grasp. It’s an essential design technique that aims to minimize data redundancy and eliminate negative characteristics like Insertion, Update, and Deletion Anomalies. Through dividing larger tables into smaller ones and creating relationships between them, normalization ensures logical data storage.

This theory was initially proposed by Edgar Codd, the inventor of the relational model. He introduced the First Normal Form (1NF) and later expanded this theory with the Second (2NF) and Third Normal Form (3NF). His work was later supplemented by Raymond F. Boyce to develop the Boyce-Codd Normal Form.

Here’s a brief list of normal forms:

  • 1NF
  • 2NF
  • 3NF
  • BCNF
  • 4NF
  • 5NF
  • 6NF

It’s important to note that discussions on further development of Data Normalization in MySQL server continue even today, with debates surrounding even the Sixth Normal Form! However, for most practical applications, normalization achieves its best form at 3rd NF.

To illustrate these concepts better let’s use an example: A video library manages a database for rented movies. Without any normalization in place, all information would be stored in one table as shown below:

Movie TitleGenreRented By
InceptionSci-FiJohn Doe

Now let’s move into First Normal Forms rules:

  • Each table cell should contain a single value.
  • Each record needs to be unique.

The same table following these rules would look like this:

Movie IDMovie Title

And another separate table for rentals might look like this:

Rental IDRenter Name
R01John Doe

A KEY in SQL is used to identify records uniquely within a table. An SQL KEY can be either a single column or combination of multiple columns used to uniquely identify rows or tuples in the table.

Primary keys have several attributes:

  • They cannot be NULL.
  • Their values must be unique.
  • The primary key values should rarely change.
  • A new record insertion requires assigning it a primary key value.

On occasion we need both Full Name and Address to uniquely identify a record which is where Composite Keys come into play; they are composed of multiple columns used for unique identification.

The Second Normal Form builds upon its predecessor but adds additional rules such as requiring Single Column Primary Key that does not functionally depend on any subset of candidate key relation.

Foreign keys reference primary keys from other tables connecting your tables together offering referential integrity. Unlike primary keys though they do not have to be unique nor do they reject null values!

Lastly there are transitive functional dependencies – when changing non-key column may cause changes in other non-key columns making it an important factor while considering higher levels of normalization!

Breaking Down the First Normal Form (1NF)

Let’s dive into the first normal form (1NF). It’s a level of database normalization where each table cell should contain a singular value, and every record must be unique.

Here’s an example of how I’d transform a non-normalized table into 1NF:

Non-Normalized Table:

Movie IDMovies Rented
1Titanic, Inception
2Shawshank Redemption
3The Godfather, Fight Club

Now let’s apply the rules of 1NF:

Normalized Table (in 1NF):

Movie IDMovies Rented
2Shawshank Redemption
3The Godfather
Fight Club

In this normalized example, you can see that each cell contains only one movie title. This eliminates any potential confusion and makes it clear which movies were rented out under each movie ID.

Remember though, in order to achieve this structure, we need to understand certain key concepts in SQL – namely Keys and Primary Keys.

A Key in SQL is used to uniquely identify records within a table. These keys can either be single columns or combinations of multiple ones. Basically, they’re your go-to tool for identifying duplicate information and establishing relationships between different tables.

On the other hand, there’s the Primary Key – a specific type of key that identifies each record in your database uniquely. A few important attributes to note about primary keys are:

  • They cannot be NULL.
  • Their values must be unique.
  • They rarely change.
  • A value must always be provided when adding new records.

Lastly, if you find yourself needing to use multiple columns for identification purposes – say due to two people having identical names but living in different locations – then what you’ll need is a Composite Key. This simply means your primary key will consist of more than one column.

So there we have it! That’s our deep-dive into the first normal form (1NF) – from understanding its rules right down to applying them with practical examples!

Practical Example: Applying 1NF in SQL

Let’s dive deep into the practical application of First Normal Form (1NF) in SQL. You’ve got to remember, normalization is all about reducing data redundancy and getting rid of those nasty anomalies that can pop up when you’re inserting, updating, or deleting data.

To get us started, let’s imagine we’re running a video library. Without any normalization, all our information – movie titles, customer details, rental dates – would be jumbled together in one table. Here’s what it might look like:

Customer NameMovies Rented
RobertThe Godfather
RobertThe Dark Knight

Notice something? Our friend Robert appears twice because he’s rented two different movies. That’s redundant data right there!

But don’t worry – here comes 1NF to save the day! Remember its rules:

  • Each table cell should contain a single value.
  • Each record needs to be unique.

By applying these rules, we end up with something like this:

IDCustomer Name

And another table for the rentals:

Rental IDMovieRenter ID
R1The Godfather1
R3The Dark Knight1

Look at that! No more redundancy!

Now you might ask, “What are those IDs about?”

Well here’s the thing – they’re called keys, and they play a crucial role in database management systems (DBMS). In SQL terms, an ID or KEY is used to uniquely identify records within tables. For example ‘Renter ID’ in our Rentals Table is referring back to ‘ID’ in our Customers Table – this connection between tables is known as foreign key relationship.

Applying such keys helps us ensure consistency while also establishing relationships across multiple tables within the DBMS. So there you have it – a practical example of how applying the principles of First Normal Form (or as I prefer to call it, “the super-hero of database organization”) can transform your raw data into well-structured and efficient databases.

Deep Dive into Second Normal Form (2NF)

There’s a lot to unpack when you’re diving into the world of database normalization, especially when it comes to understanding the second normal form (2NF). This form is all about ensuring that your database schema is designed with efficiency and reliability in mind. It’s essential to have a firm grasp on the first normal form (1NF) before delving deeper into 2NF, as it sets the stage for what follows.

Every table in your database should be in 1NF at least. That means each cell contains only one value and each record must be unique. For example, if we were creating a table for customers’ orders, we wouldn’t cram multiple items purchased into one cell – instead, we’d create separate rows for each item.

Once you’ve got that down pat, it’s time to enter the realm of 2NF. Here are two key rules:

  • Rule 1: Be in 1NF.
  • Rule 2: Single Column Primary Key that does not functionally depend on any subset of candidate key relation.

You might wonder what this jargon means exactly? I’ll break it down for you! The primary key is how we uniquely identify records within our tables – think customer ID or order number. In our earlier example where Robert Phil lives at different addresses, both Full Name and Address combined serve as a composite primary key because they together can uniquely identify records.

The second rule revolves around an important concept called functional dependency which basically means some column depends entirely on another. So in 2NF, no non-key column (columns not part of primary key) should depend on just part of multi-column primary key – this aids us to eliminate redundancy from our tables.

To achieve this state of normalized bliss known as Second Normal Form, let’s say we split our initial monstrous table from earlier example into two more manageable ones: Customer details and Order details. Now there are no partial dependencies anymore; everything ties back nicely using Membership_ID, which serves both as a primary key for Customer Details and foreign key for Order details thus linking them together!

But hey! don’t stop here at Second Normal Form; remember there’s always room for improvement when it comes to data management! Next up lies Third Normal Form with its own set of exciting rules waiting to further refine your data structuring skills!

Real-World Scenario: Implementing 2NF using SQL

Ever wondered how to implement the Second Normal Form (2NF) in a real-world scenario? Well, let’s dive right in. For simplicity’s sake, imagine we have a company database that hasn’t been normalized yet. It contains a single table named ‘Employee_Projects’ with the following columns:

E01John DoeP005App Dev
E02Jane SmithP007Web Design

At first glance, you might think this design is perfectly fine. However, as I’ve learned over time, it’s far from ideal. This is because the Employee_Name and Project_Name fields are dependent on both Employee_ID and Project_ID. In other words, these dependencies violate the 2NF rule.

So how do we resolve this issue? By splitting our single table into two separate tables:

  1. An ‘Employees’ table:
    • Employee_ID (Primary Key)
    • Employee_Name
  2. A ‘Projects’ table:
    • Project_ID (Primary Key)
    • Project_Name

The result will look something like this:

Employees Table

E01John Doe
E02Jane Smith

Projects Table

| Project_ID | Project_Name |
|- |- |
|P005 |App Dev |

In SQL terms, we would create these tables using commands such as:

   Employee_Id CHAR(3) PRIMARY KEY,
   Employee_name VARCHAR(30)

   Project_Id CHAR(3) PRIMARY KEY,
   Project_name VARCHAR(30)

Lastly, we need to link these two tables together so that we can still track which employee is working on which project. We do this by creating an associative or linking table named ‘Employee_Project_Links’, containing just the primary keys of our two new tables:

Employe_Project_Links Table


Now each employee can be linked to multiple projects and vice versa without any data redundancy or dependency issues—just like magic!

What I’ve just described here is exactly what implementing Second Normal Form (2NF) means in practical terms: reducing redundancy and improving efficiency by ensuring each non-primary key attribute is fully functionally dependent on the primary key.

Just remember: while normalization helps enhance database structure and eliminate redundancies, it may not always be necessary or beneficial for every situation depending on your specific needs.

Exploring the Third Normal Form (3NF)

Let’s dive into the realm of Third Normal Form (3NF). Codd introduced this concept as a progression from Second Normal Form (2NF), further strengthening data integrity and structure. But what exactly does 3NF entail?

Under 3NF guidelines, a table is in third normal form when it meets two conditions:

  • It’s already in second normal form.
  • There are no transitive functional dependencies.

Don’t fret if that second term sounds daunting! A ‘transitive functional dependency’ occurs when changes to a non-key column might cause any other non-key columns to change. For instance, modifying an employee’s job position could alter their salary – these two factors are transitively dependent.

In context of our movie rental example, consider this: changing the ‘Movie_Rented’ column may impact ‘Rent_Per_Day’. This represents a transitive dependency and according to 3NF rules, we need to eliminate such dependencies for optimal database structure.

To achieve Third Normal Form, follow these simple steps:

  1. Make sure your tables are in Second Normal Form.
  2. Identify any transitive dependencies between columns.
  3. Create new tables for each set of related attributes that exhibit transitive dependency.
  4. Use Foreign Keys to connect related tables.

Putting these principles into practice with our movie rental database would look something like this:

1Robert PhilNew York
2Robert PhilSan Francisco

Table: Member_Details

M1The Godfather

Table: Movie_Details

By splitting up the original table into multiple ones revolving around specific entities – members and movies in this case – we’ve successfully eliminated all potential transitive dependencies.

Hopefully you now have a clearer understanding of how Third Normal Form works within SQL databases. Remember, normalization isn’t just about following rules – it’s about making your database easier to update, query and maintain over time!

Illustrative Example: Executing 3NF with SQL Commands

Let’s put theory into practice and execute the Third Normal Form (3NF) using some SQL commands. The concept of normalization can be a bit abstract, so I find it helpful to work through an example to solidify understanding.

Consider a table in our database where we are storing information about books. Let’s say this table includes columns for Book_ID, Book_Title, Author_Name, and Author_Birthdate.

In its initial state, this table may look something like:

1Moby DickHerman Melville1819-08-01
2White JacketHerman Melville1819-08-01
3The Great GatsbyF. Scott Fitzgerald1896-09-24

Here, we’ve got data redundancy – author birthdates are repeated for each book by the same author. This is where normalization comes into play!

To start transforming this table into third normal form (3NF), I’ll split it into two tables: one for information on books and another for authors’ details.

The Books Table would be:

| Book_ID | Book_Title |
|- |- |
|1|Moby Dick|

And the Authors Table would be:

| Author_Name | Birth_Date |
|- |-

Now, let’s recollect what we know about keys in SQL. A primary key uniquely identifies records in a table while a foreign key helps connect other tables.

So for our new set-up, I’ll assign Book_ID as the primary key of the Books Table and create an extra column called ‘Author_ID’ in both tables that will serve as a foreign key linking them together.

This leaves us with two tables that adhere to 3NF principles, eliminating data redundancy while ensuring all non-prime attributes depend directly on their primary keys!

Remember folks, good database design makes managing your data much more efficient. It may take a little extra time at setup but it’s definitely worth it!

Comparing 1NF, 2NF, and 3NF: Key Differences and Similarities

To fully grasp the concept of normalization in DBMS (SQL), it’s vital to understand the key differences and similarities between the First Normal Form (1NF), Second Normal Form (2NF), and Third Normal Form (3NF). These forms represent progressive levels of organization in a database system aimed at reducing data redundancy.

First Normal Form (1NF) focuses on dividing database tables into logical units called entities. Each entity should contain atomic values only, with no repeating groups or arrays. Simply put, each cell should have a single value, and each record should be unique.

However, Second Normal Form (2NF) takes things a step further by ensuring every non-key column is fully functionally dependent on the primary key. In simpler terms, there’s no partial dependency allowed. It means that if you have composite primary keys, then every other column in your table must depend on that entire composite key for its existence.

Finally, we reach Third Normal Form (3NF) where transitive functional dependencies are not allowed. This rule ensures that non-key columns are independent of each other – meaning changing one won’t indirectly change another.

Let me show you how these rules apply:

1NFAtomic values; No repeating groups
2NFFull functional dependency
3FNNo transitive functional dependency

For instance, let’s say we have a video library database with information stored without any normalization as shown below:

  • Movies Rented
  • Rental Date
  • Member Name
  • Address

Applying 1NF, we break down ‘Movies Rented’ into single values eliminating multiple values in one cell:

  • Movie Rented
  • Rental Date
  • Member Name
  • Address

Then proceeding to 2NF, assuming ‘Member Name’ + ‘Address’ is our composite primary key; all other columns relate entirely to this primary key:


  • Member Name
  • Address


  • Movie Rented
  • Rental Date
  • Member Name + Address (Composite Primary Key)

Lastly for 3FN, since changing ‘Member name’ might indirectly affect ‘Movie rented’, these two fields need separation resulting into three tables like so:

-Member Name

-Movie Rented
-Rental Date

-Member Name (Foreign Key)
-Movie Rented (Foreign Key)

This clear distinction between 1NF, 2ND and 3RD normal form helps us understand how data integrity can be maintained through normalization in DBMS systems.

Wrapping Up: The Importance of Normalization in DBMS

It’s been a long journey into the depths of database normalization, but we’re finally at the end. Looking back, it’s clear that normalization isn’t just some dry academic concept – it’s a critical part of designing efficient and reliable databases.

Normalization is all about strategic data organization. By eliminating redundancy and anomalies, it ensures our databases are sleek and streamlined. It curbs unnecessary memory usage by reducing repetitive data storage. Plus, it saves us from the dreaded Update Anomalies which can lead to inconsistencies in our dataset.

Moreover, let’s not forget how normalized tables can simplify our SQL queries. Without them, we’d be dealing with monstrous tables filled with redundant data – not ideal for anyone who values their time and sanity!

However, remember that no good thing should be taken to an extreme – including normalization. While 1NF through 3NF are generally beneficial for most databases, going further might not always be necessary or even desirable depending on your specific use case.

In conclusion, understanding database normalization is essential for any aspiring DBA or anyone involved in handling data-heavy tasks such as Data Analysts or Data Scientists. So if by now you’ve grasped the essence of what I’ve shared about this complex subject – congratulations! You’re well on your way to mastering one of the key skills in database management.


  • Normalization reduces redundancy
  • It eliminates potential anomalies during data operations
  • Simplifies SQL queries
  • Mustn’t be overdone

Keep these points close to heart as you navigate through your journey into becoming an expert SQL developer!

Related articles