First normal form

First normal form is the most basic level of database normalization defined by English computer scientist Edgar F. Codd, the inventor of the relational database. A relation can be said to be in first normal form if each field is atomic, containing a single value rather than a set of values or a nested table. In other words, a relation complies with first normal form if no attribute domain has relations as elements.
Most relational database management systems, including standard SQL, do not support creating or using table-valued columns, which means most relational databases will be in first normal form by necessity. Otherwise, normalization to 1NF involves eliminating nested relations by breaking them up into separate relations associated with each other using foreign keys. This process is a necessary step when moving data from a non-relational database, such as one using a hierarchical or document-oriented model, to a relational database.
A database must satisfy 1NF to satisfy further "normal forms", such as 2NF and 3NF, which enable the reduction of redundancy and anomalies. Other benefits of adopting 1NF include the introduction of increased data independence and flexibility and simplification of the relational algebra and query language necessary to describe operations on the database.
Codd considered 1NF mandatory for relational databases, while the other normal forms were merely guidelines for database design.

Background

First normal form was introduced in 1970 by Edgar F. Codd in his paper "A relational model of data for large shared data banks", although initially it was simply referred to as "normalization" or "normal form". It was renamed to "first normal form" when Codd introduced additional normal forms in his paper "Further Normalization of the Data Base Relational Model" in 1971.
The relational model was proposed as an improvement over hierarchical databases which were prevalent at the time. A key difference lies in how relationships between records are represented. In a hierarchical database, one-to-many relationships are represented through containment: a single record may contain sets of records as attribute values. But Codd argued that hierarchy is not flexible and expressive enough for more complex data models. For example, many-to-many relationships cannot be represented through hierarchy. Thus he suggest eliminating nested records and instead represent relationship through foreign keys. This allows richer relationships to be expressed, since a record can now participate in multiple relationships.
A direct translation of a hierarchical database into relations would represent repeating groups as nested relations. Thus normalization is defined as eliminating nested relations and instead represent the one-to-many relationship through foreign keys.
Codd distinguishes between "atomic" and "compound" data. Atomic data includes basic types such as numbers and strings – broadly speaking, it "cannot be decomposed into smaller pieces by the DBMS ". Compound data is made up of structures such as relations which contain several pieces of atomic data and thus "can be decomposed by the DBMS".
In a relation, each attribute has a set of allowed values known as its domain. Each tuple in the relation contains one value per attribute, and each must be an element in that attribute's domain. Codd distinguishes attributes which have "simple domains" containing only atomic data from attributes with "nonsimple domains" containing at least some forms of compound data. Nonsimple domains introduce a degree of structural complexity which can be difficult to navigate, to query and to update – for instance, it will be time-consuming to operate across several nested relations, which can be found in some non-relational databases.
First normal form therefore requires all attribute domains to be simple domains, such that the data in each field is atomic and no relation has relation-valued attributes. Precisely, Codd states that, in the relational model, "values in the domains on which each relation is defined are required to be atomic with respect to the DBMS." Normalization to 1NF is thus a process of eliminating nonsimple domains from all relations.

Examples

Design that violates 1NF

This table of customers' credit card transactions does not conform to first normal form, as each customer corresponds to a repeating group of transactions. Such a design can be represented in a hierarchical database, but not in an SQL database, since SQL does not support nested tables.

CustomerID Name Transactions - - -

Abraham

The evaluation of any query relating to customers' transactions would broadly involve two stages:

unpacking one or more customers' groups of transactions, allowing the individual transactions in a group to be examined, and
deriving a query result from the results of the first stage.

For example, in order to find out the monetary sum of all transactions that occurred in October 2003 for all customers, the database management system would have to first unpack the Transactions field of each customer, then sum the Amount of each transaction thus obtained where the Date of the transaction falls in October 2003.

Design that complies with 1NF

Codd described how a database like this could be made less structurally complex and more flexible by transforming it into a relational database in first normal form. To normalize the table so it complies with first normal form, attributes with nonsimple domains must be extracted to separate, stand-alone relations. Each extracted relation gains a foreign key referencing the primary key of the relation which initially contained it. This process can be applied recursively to nonsimple domains nested in multiple levels.
In this example, CustomerID is the primary key of the containing relation and will therefore be appended as a foreign key to the new relation:

CustomerID	Name
1	Abraham
2	Isaac
3	Jacob

CustomerID	TransactionID	Date	Amount
1	12890	2003-10-14	−87
1	12904	2003-10-15	−50
2	12898	2003-10-14	−21
3	12907	2003-10-15	−18
3	14920	2003-11-20	−70
3	15003	2003-11-27	−60

In this modified design, the primary key is in the first relation and in the second relation.
Now that a single, "top-level" relation contains all transactions, it will be simpler to run queries on the database. To find the monetary sum of all October transactions, the DMBS would simply find all rows with a Date falling in October and sum the Amount fields. All values are now easily exposed to the DBMS, whereas previously some values were embedded in lower-level structures that had to be handled specially. Accordingly, the normalized design lends itself well to general-purpose query processing, whereas the unnormalized design does not.
It is worth noting that the revised design also meets the additional requirements for second and third normal form.

Rationale

Normalization to 1NF is the major theoretical component of transferring a database to the relational model. Use of a relational database in 1NF brings certain advantages:

It enables data to be stored in regular two-dimensional arrays; supporting nested relations would require more complex data structures.
It allows for the use of a simpler query language, like SQL, since any data item can be identified using only a relation name, attribute name and key; addressing nested data items would require a more complex language with support for hierarchical data paths.
Representing relationships using foreign keys is more flexible and allows for features such as many-to-many relationships, while a hierarchical model can represent only one-to-one or one-to-many relationships.
Since locating data items is not coupled to a parent–child hierarchy, a database in 1NF creates greater data independence and is more resilient to structural changes over time.
From 1NF, further normalization becomes possible, which can reduce data redundancy and anomalies.
Controversy about compound values

There is some discussion about to what extent compound or complex values other than relations are permitted in 1NF. Codd states that relations are the only type of compound data allowed within the relational model, since any additional type of compound data would add complexity without adding power; nevertheless, the model specifically allows "certain special functions" like SUBSTRING to decompose values otherwise considered atomic.
Hugh Darwen and Christopher J. Date have suggested that Codd's concept of an "atomic value" is ambiguous, and that this ambiguity has led to widespread confusion about how 1NF should be understood. In particular, the notion of an atomic value as a "value that cannot be decomposed" is problematic, as it would seem to imply that few, if any, data types are atomic:

A string would seem not to be atomic, as an RDBMS typically provides operators to decompose it into substrings.
A fixed-point number would seem not to be atomic, as an RDBMS typically provides operators to decompose it into integer and fractional components.
An ISBN would seem not to be atomic, as it includes various parts, including the registration group, registrant and publication elements.

Date suggests that "the notion of atomicity has no absolute meaning": a value may be considered atomic for some purposes, but may be considered an assemblage of more basic elements for other purposes. If this position is accepted, 1NF cannot be defined with reference to atomicity. Columns containing any conceivable data type are then acceptable in a 1NF table, although perhaps not always desirable – for example, it may be desirable to separate a CustomerName column into two columns, FirstName and Surname.