First normal form - Revision history

imported>Alexanderino: clean up, typo(s) fixed: For example → For example,

2025-11-08T21:14:05Z

clean up, typo(s) fixed: For example → For example,

← Previous revision		Revision as of 21:14, 8 November 2025
Line 1:		Line 1:
	{{short description\|~~Concept in~~ database normalization}}		{{short description\|Level of database normalization}}
	{{citation style\|date=May 2025}}		{{citation style\|date=May 2025}}

	'''First normal form''' ('''1NF''') is the ~~simplest form~~ of [[database normalization]] defined by English computer scientist [[Edgar F. Codd]], the inventor of the [[relational database]]. A [[Relation (database)\|relation]] (or a [[Table (database)\|''table'']], in [[SQL]]) 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]] (the set of values allowed in a given column) has relations as elements.<ref>Codd, E. F. (1972). "Further Normalization of the Data Base Relational Model". p. 27</ref>		'''First normal form''' ('''1NF''') is the most basic level of [[database normalization]] defined by English computer scientist [[Edgar F. Codd]], the inventor of the [[relational database]]. A [[Relation (database)\|relation]] (or a [[Table (database)\|''table'']], in [[SQL]]) 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]] (the set of values allowed in a given column) has relations as elements.<ref>Codd, E. F. (1972). "Further Normalization of the Data Base Relational Model". p. 27</ref>

	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 key]]s.<ref name="Codd 1970">{{Cite journal \|title=A relational model of data for large shared data banks \|journal=Communications of the ACM \|last=Codd \|first=E. F. \|volume=13 \|issue=6 \|pages=377–387 \|author-link=Edgar F. Codd \|year=1970 \|doi=10.1145/362384.362685}}</ref>{{rp\|pages=381}} This process is a necessary step when moving data from a non-relational (or [[NoSQL]]) database, such as one using a [[hierarchical database\|hierarchical]] or [[document-oriented database\|document-oriented]] model, to a relational database.		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 key]]s.<ref name="Codd 1970">{{Cite journal \|title=A relational model of data for large shared data banks \|journal=Communications of the ACM \|last=Codd \|first=E. F. \|volume=13 \|issue=6 \|pages=377–387 \|author-link=Edgar F. Codd \|year=1970 \|doi=10.1145/362384.362685}}</ref>{{rp\|pages=381}} This process is a necessary step when moving data from a non-relational (or [[NoSQL]]) database, such as one using a [[hierarchical database\|hierarchical]] or [[document-oriented database\|document-oriented]] model, to a relational database.

	A database must satisfy 1NF to satisfy further "[[~~Database_normalization~~#~~Normal_forms~~\|normal forms]]", such as [[Second normal form\|2NF]] and [[Third normal form\|3NF]], which enable the reduction of redundancy and anomalies. Other benefits of adopting 1NF include the introduction of increased [[data independence]] and flexibility (including features like [[Many-to-many (data model)\|many-to-many]] relationships) and simplification of the [[relational algebra]] and [[query language]] necessary to describe operations on the database.		A database must satisfy 1NF to satisfy further "[[Database normalization#Normal forms\|normal forms]]", such as [[Second normal form\|2NF]] and [[Third normal form\|3NF]], which enable the reduction of redundancy and anomalies. Other benefits of adopting 1NF include the introduction of increased [[data independence]] and flexibility (including features like [[Many-to-many (data model)\|many-to-many]] relationships) 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.<ref>{{Cite journal \|title=Extending the database relational model to capture more meaning \|journal=ACM Transactions on Database Systems \|last=Codd \|first=E. F. \|volume=4 \|issue=4 \|pages=397–434 \|author-link=Edgar F. Codd \|year=1979 \|doi=10.1145/320107.320109}}</ref>{{rp\|page=439}}		Codd considered 1NF mandatory for relational databases, while the other normal forms were merely guidelines for database design.<ref>{{Cite journal \|title=Extending the database relational model to capture more meaning \|journal=ACM Transactions on Database Systems \|last=Codd \|first=E. F. \|volume=4 \|issue=4 \|pages=397–434 \|author-link=Edgar F. Codd \|year=1979 \|doi=10.1145/320107.320109}}</ref>{{rp\|page=439}}
Line 13:		Line 13:
	First normal form was introduced in 1970 by [[Edgar F. Codd]] in his paper "A relational model of data for large shared data banks",{{r\|Codd 1970}} 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.<ref>Codd, E. F. (1971). "Further Normalization of the Data Base Relational Model". ''Data Base Systems. Courant Computer Science Symposium 6'' edited by Rustin, R.</ref>		First normal form was introduced in 1970 by [[Edgar F. Codd]] in his paper "A relational model of data for large shared data banks",{{r\|Codd 1970}} 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.<ref>Codd, E. F. (1971). "Further Normalization of the Data Base Relational Model". ''Data Base Systems. Courant Computer Science Symposium 6'' edited by Rustin, R.</ref>

	The relational model was proposed as an improvement over [[hierarchical]] databases which were prevalent at the time.{{r\|Codd 1970\|p=377}} 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 (known as repeating groups) 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.{{r\|Codd 1970\|p=378}} Thus he suggest eliminating nested records and instead represent relationship through [[foreign key~~\|foreign keys~~]]. This allows richer relationships to be expressed, since a record can now participate in multiple relationships.{{r\|Codd 1970\|p=378}}		The relational model was proposed as an improvement over [[hierarchical]] databases which were prevalent at the time.{{r\|Codd 1970\|p=377}} 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 (known as repeating groups) 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.{{r\|Codd 1970\|p=378}} Thus he suggest eliminating nested records and instead represent relationship through [[foreign key]]s. This allows richer relationships to be expressed, since a record can now participate in multiple relationships.{{r\|Codd 1970\|p=378}}

	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. {{r\|Codd 1970\|p=381}}		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. {{r\|Codd 1970\|p=381}}
Line 25:		Line 25:
	==Examples==		==Examples==
	===Design that violates 1NF===		===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.		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.

	{{Table alignment}}		{{Table alignment}}
Line 135:		Line 135:
	Date suggests that "the notion of atomicity ''has no absolute meaning''":<ref name="Date 2007">{{cite book \|last=Date\| first=C. J. \|author-link=Christopher J. Date \|chapter=Chapter 8: What First Normal Form Really Means \|date=2007 \|title=Date on Database: Writings 2000–2006 \|publisher=Apress \|isbn=978-1-4842-2029-0}}</ref>{{rp\|page=112}}<ref>{{cite book \|last=Date \|first=C. J. \|author-link=Christopher J. Date \|url=https://books.google.com/books?id=BCjkCgAAQBAJ&pg=PA50 \|title=SQL and Relational Theory: How to Write Accurate SQL Code \|date=6 November 2015 \|publisher=O'Reilly Media \|isbn=978-1-4919-4115-7 \|pages=50– \|access-date=31 October 2018}}</ref>{{Pages needed\|date=May 2025}} 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 (from strings and numeric types to arrays and tables) are then acceptable in a 1NF table,{{Citation needed\|date=May 2025}} although perhaps not always desirable – for example, it may be desirable to separate a CustomerName column into two columns, FirstName and Surname.		Date suggests that "the notion of atomicity ''has no absolute meaning''":<ref name="Date 2007">{{cite book \|last=Date\| first=C. J. \|author-link=Christopher J. Date \|chapter=Chapter 8: What First Normal Form Really Means \|date=2007 \|title=Date on Database: Writings 2000–2006 \|publisher=Apress \|isbn=978-1-4842-2029-0}}</ref>{{rp\|page=112}}<ref>{{cite book \|last=Date \|first=C. J. \|author-link=Christopher J. Date \|url=https://books.google.com/books?id=BCjkCgAAQBAJ&pg=PA50 \|title=SQL and Relational Theory: How to Write Accurate SQL Code \|date=6 November 2015 \|publisher=O'Reilly Media \|isbn=978-1-4919-4115-7 \|pages=50– \|access-date=31 October 2018}}</ref>{{Pages needed\|date=May 2025}} 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 (from strings and numeric types to arrays and tables) are then acceptable in a 1NF table,{{Citation needed\|date=May 2025}} although perhaps not always desirable – for example, it may be desirable to separate a CustomerName column into two columns, FirstName and Surname.

	==~~Cristopher~~ J. Date's definition of 1NF==		==Christopher J. Date's definition of 1NF==
	{{Importance section\|date=May 2025}}		{{Importance section\|date=May 2025}}
	According to [[Christopher J. Date]]'s definition, a table is in first normal form if and only if it is "[[isomorphism\|isomorphic]] to some relation", which means, specifically, that it satisfies the following five conditions:{{r\|Date 2007}}{{rp\|pages=127–128}}		According to [[Christopher J. Date]]'s definition, a table is in first normal form if and only if it is "[[isomorphism\|isomorphic]] to some relation", which means, specifically, that it satisfies the following five conditions:{{r\|Date 2007}}{{rp\|pages=127–128}}

80.62.116.26 at 10:21, 14 June 2025

2025-06-14T10:21:06Z

← Previous revision		Revision as of 10:21, 14 June 2025
Line 1:		Line 1:
	{{short description\|Concept in database normalization}}		{{short description\|Concept in database normalization}}
	~~{{multiple issues\|~~
	~~{{more sources\|date=November 2024}}~~
	{{citation style\|date=May 2025}}		{{citation style\|date=May 2025}}
	}}

	'''First normal form''' ('''1NF''') is the simplest form of [[database normalization]] defined by English computer scientist [[Edgar F. Codd]], the inventor of the [[relational database]]. A [[Relation (database)\|relation]] (or a [[Table (database)\|''table'']], in [[SQL]]) 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]] (the set of values allowed in a given column) has relations as elements.<ref>Codd, E. F. (1972). "Further Normalization of the Data Base Relational Model". p. 27</ref>		'''First normal form''' ('''1NF''') is the simplest form of [[database normalization]] defined by English computer scientist [[Edgar F. Codd]], the inventor of the [[relational database]]. A [[Relation (database)\|relation]] (or a [[Table (database)\|''table'']], in [[SQL]]) 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]] (the set of values allowed in a given column) has relations as elements.<ref>Codd, E. F. (1972). "Further Normalization of the Data Base Relational Model". p. 27</ref>
Line 15:		Line 12:
	== Background ==		== 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",{{r\|Codd 1970}} 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.<ref>Codd, E. F. (1971). "Further Normalization of the Data Base Relational Model". ''Data Base Systems. Courant Computer Science Symposium 6'' edited by Rustin, R.</ref>		First normal form was introduced in 1970 by [[Edgar F. Codd]] in his paper "A relational model of data for large shared data banks",{{r\|Codd 1970}} 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.<ref>Codd, E. F. (1971). "Further Normalization of the Data Base Relational Model". ''Data Base Systems. Courant Computer Science Symposium 6'' edited by Rustin, R.</ref>

			The relational model was proposed as an improvement over [[hierarchical]] databases which were prevalent at the time.{{r\|Codd 1970\|p=377}} 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 (known as repeating groups) 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.{{r\|Codd 1970\|p=378}} Thus he suggest eliminating nested records and instead represent relationship through [[foreign key\|foreign keys]]. This allows richer relationships to be expressed, since a record can now participate in multiple relationships.{{r\|Codd 1970\|p=378}}

			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. {{r\|Codd 1970\|p=381}}

	Codd distinguishes between "atomic" and "compound" data. Atomic (or "nondecomposable") data includes basic types such as numbers and [[String (computer science)\|strings]] – broadly speaking, it "''cannot'' be decomposed into smaller pieces by the [[DBMS]] (excluding certain special functions)". Compound data is made up of structures such as [[Relation (database)\|relations]] (or ''[[Table (database)\|tables]]'', in [[SQL]]) which contain several pieces of atomic data and thus "''can'' be decomposed by the DBMS".<ref name="Codd 1990">{{Cite book \|last=Codd \|first=E. F. \|title=The relational model for database management: version 2 \|publisher=[[Addison-Wesley]] \|isbn=978-0-201-14192-4 \|publication-date=1 January 1990}}</ref>{{rp\|page=6}}		Codd distinguishes between "atomic" and "compound" data. Atomic (or "nondecomposable") data includes basic types such as numbers and [[String (computer science)\|strings]] – broadly speaking, it "''cannot'' be decomposed into smaller pieces by the [[DBMS]] (excluding certain special functions)". Compound data is made up of structures such as [[Relation (database)\|relations]] (or ''[[Table (database)\|tables]]'', in [[SQL]]) which contain several pieces of atomic data and thus "''can'' be decomposed by the DBMS".<ref name="Codd 1990">{{Cite book \|last=Codd \|first=E. F. \|title=The relational model for database management: version 2 \|publisher=[[Addison-Wesley]] \|isbn=978-0-201-14192-4 \|publication-date=1 January 1990}}</ref>{{rp\|page=6}}
Line 115:		Line 116:
	It is worth noting that the revised design also meets the additional requirements for [[second normal form\|second]] and [[third normal form]].		It is worth noting that the revised design also meets the additional requirements for [[second normal form\|second]] and [[third normal form]].

	== Rationale ~~and drawbacks~~ ==		== Rationale ==
	~~{{Multiple issues\|section=yes\|~~
	~~{{Confusing section\|date=May 2025}}~~
	~~{{Importance section\|date=May 2025}}~~
	}}

	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:		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:
Line 128:		Line 125:
	* 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.{{Clarify\|date=May 2025}}		* 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.{{Clarify\|date=May 2025}}
	* From 1NF, further normalization becomes possible (for example to [[Second normal form\|2NF]] or [[Third normal form\|3NF]]), which can reduce data redundancy and anomalies.		* From 1NF, further normalization becomes possible (for example to [[Second normal form\|2NF]] or [[Third normal form\|3NF]]), which can reduce data redundancy and anomalies.

	~~The use of 1NF also comes with certain drawbacks:~~
	* Performance worsens for certain operations. In a hierarchical model, nested records are physically stored after the parent record, which means a whole subtree can be retrieved in a single read operation. In 1NF, this will require a join operation per record type, which can be costly, especially for complex trees. For this reason, [[document-oriented database]]s eschew 1NF.
	* [[Object-oriented language]]s represent runtime state as trees or [[directed graph]]s of objects connected by [[Pointer (computer programming)\|pointers]] or references. This does not map cleanly to a 1NF relational database, creating a gap sometimes called the [[object–relational impedance mismatch]], which [[object–relational mapping]] (ORM) libraries try to bridge.
	* 1NF has been interpreted as not allowing complex data types for values. This is open to interpretation though, and [[Christopher J. Date]] has argued that values can be arbitrarily complex objects.{{citation-needed\|date=June 2023}}

	== Controversy about compound values ==		== Controversy about compound values ==

imported>MiscellanyNovice: Rewrote 'Background' and performed cleanup on tables, citations, etc.

2025-05-13T18:49:36Z

Rewrote 'Background' and performed cleanup on tables, citations, etc.

New page

{{short description|Concept in database normalization}}
{{multiple issues|
{{more sources|date=November 2024}}
{{citation style|date=May 2025}}
}}

'''First normal form''' ('''1NF''') is the simplest form of [[database normalization]] defined by English computer scientist [[Edgar F. Codd]], the inventor of the [[relational database]]. A [[Relation (database)|relation]] (or a [[Table (database)|''table'']], in [[SQL]]) 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]] (the set of values allowed in a given column) has relations as elements.<ref>Codd, E. F. (1972). "Further Normalization of the Data Base Relational Model". p. 27</ref>

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 key]]s.<ref name="Codd 1970">{{Cite journal |title=A relational model of data for large shared data banks |journal=Communications of the ACM |last=Codd |first=E. F. |volume=13 |issue=6 |pages=377–387 |author-link=Edgar F. Codd |year=1970 |doi=10.1145/362384.362685}}</ref>{{rp|pages=381}} This process is a necessary step when moving data from a non-relational (or [[NoSQL]]) database, such as one using a [[hierarchical database|hierarchical]] or [[document-oriented database|document-oriented]] model, to a relational database.

A database must satisfy 1NF to satisfy further "[[Database_normalization#Normal_forms|normal forms]]", such as [[Second normal form|2NF]] and [[Third normal form|3NF]], which enable the reduction of redundancy and anomalies. Other benefits of adopting 1NF include the introduction of increased [[data independence]] and flexibility (including features like [[Many-to-many (data model)|many-to-many]] relationships) 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.<ref>{{Cite journal |title=Extending the database relational model to capture more meaning |journal=ACM Transactions on Database Systems |last=Codd |first=E. F. |volume=4 |issue=4 |pages=397–434 |author-link=Edgar F. Codd |year=1979 |doi=10.1145/320107.320109}}</ref>{{rp|page=439}}

== 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",{{r|Codd 1970}} 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.<ref>Codd, E. F. (1971). "Further Normalization of the Data Base Relational Model". ''Data Base Systems. Courant Computer Science Symposium 6'' edited by Rustin, R.</ref>

Codd distinguishes between "atomic" and "compound" data. Atomic (or "nondecomposable") data includes basic types such as numbers and [[String (computer science)|strings]] – broadly speaking, it "''cannot'' be decomposed into smaller pieces by the [[DBMS]] (excluding certain special functions)". Compound data is made up of structures such as [[Relation (database)|relations]] (or ''[[Table (database)|tables]]'', in [[SQL]]) which contain several pieces of atomic data and thus "''can'' be decomposed by the DBMS".<ref name="Codd 1990">{{Cite book |last=Codd |first=E. F. |title=The relational model for database management: version 2 |publisher=[[Addison-Wesley]] |isbn=978-0-201-14192-4 |publication-date=1 January 1990}}</ref>{{rp|page=6}}

In a relation, each attribute (or [[Column (database)|''column'']]) has a set of allowed values known as its [[Attribute domain|domain]] (e.g., a "Price" attribute's domain may be the set of non-negative numbers with up to 2 fractional digits). Each tuple (or [[Row (database)|''row'']]) 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.{{r|Codd 1970}}{{rp|pages=380}} 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 table|nested relations]] (that is, tables containing further tables), which can be found in some [[non-relational database]]s.

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."<ref name="Codd 1990" />{{rp|page=6}} 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.

{{Table alignment}}
{| class="wikitable col1right"
|+ Customer
! CustomerID !! Name !! Transactions
|-
| 1 || Abraham
||
{{Table alignment}}
{| class="wikitable col1right col3right"
! TransactionID !! Date !! Amount
|-
| 12890 || 2003-10-14 || −87
|-
| 12904 || 2003-10-15 || −50
|}
|-
| 2 || Isaac
||
{{Table alignment}}
{| class="wikitable col1right col3right"
! TransactionID !! Date !! Amount
|-
| 12898 || 2003-10-14 || −21
|}
|-
| 3 || Jacob
||
{{Table alignment}}
{| class="wikitable col1right col3right"
! TransactionID !! Date !! Amount
|-
| 12907 || 2003-10-15 || −18
|-
| 14920 || 2003-11-20 || −70
|-
| 15003 || 2003-11-27 || −60
|}
|}

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]] (DMBS) 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 (i.e., domains containing tables within tables within tables, and so on).{{r|Codd 1970}}{{rp|pages=380–381}}

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:

{{Col-float}}
{{Col-float-break|style=margin-right: 20px;}}
{{Table alignment}}
{| class="wikitable col1right"
|+ Customer
! CustomerID !! Name
|-
| 1 || Abraham
|-
| 2 || Isaac
|-
| 3 || Jacob
|}
{{Col-float-break}}
{{Table alignment}}
{| class="wikitable col1right col2right col4right"
|+ Transaction
! 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
|}
{{Col-float-end}}

In this modified design, the primary key is {CustomerID} in the first relation and {CustomerID, TransactionID} 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 normal form|second]] and [[third normal form]].

== Rationale and drawbacks ==
{{Multiple issues|section=yes|
{{Confusing section|date=May 2025}}
{{Importance section|date=May 2025}}
}}

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 array]]s; supporting nested relations would require more complex data structures.{{r|Codd 1970}}{{rp|page=381}}
* 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 (data model)|many-to-many]] relationships, while a hierarchical model can represent only [[One-to-one (data model)|one-to-one]] or [[One-to-many (data model)|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.{{Clarify|date=May 2025}}
* From 1NF, further normalization becomes possible (for example to [[Second normal form|2NF]] or [[Third normal form|3NF]]), which can reduce data redundancy and anomalies.

The use of 1NF also comes with certain drawbacks:
* Performance worsens for certain operations. In a hierarchical model, nested records are physically stored after the parent record, which means a whole subtree can be retrieved in a single read operation. In 1NF, this will require a join operation per record type, which can be costly, especially for complex trees. For this reason, [[document-oriented database]]s eschew 1NF.
* [[Object-oriented language]]s represent runtime state as trees or [[directed graph]]s of objects connected by [[Pointer (computer programming)|pointers]] or references. This does not map cleanly to a 1NF relational database, creating a gap sometimes called the [[object–relational impedance mismatch]], which [[object–relational mapping]] (ORM) libraries try to bridge.
* 1NF has been interpreted as not allowing complex data types for values. This is open to interpretation though, and [[Christopher J. Date]] has argued that values can be arbitrarily complex objects.{{citation-needed|date=June 2023}}

== Controversy about compound values ==
There is some discussion about to what extent compound or complex values other than relations (such as [[Array (data structure)|arrays]] or [[XML]] data) are permitted in 1NF.{{Citation needed|date=May 2025}} Codd states that relations are the only type of compound data allowed within the relational model (if not in attribute domains), since any additional type of compound data would add complexity without adding power; nevertheless, the model specifically allows "certain special functions" like <code>SUBSTRING</code> to decompose values otherwise considered atomic.{{r|Codd 1990}}{{rp|page=6,340}}

[[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.<ref>Darwen, Hugh. "Relation-Valued Attributes; or, Will the Real First Normal Form Please Stand Up?", in C. J. Date and Hugh Darwen, ''Relational Database Writings 1989-1991'' (Addison-Wesley, 1992).</ref><ref>{{cite book |last=Date |first=C. J. |author-link=Christopher J. Date |chapter=Chapter 8: What First Normal Form Really Means |date=2007 |title=Date on Database: Writings 2000–2006 |publisher=Apress |isbn=978-1-4842-2029-0 |page=108 |quote='[F]or many years,' writes Date, 'I was as confused as anyone else. What's worse, I did my best (worst?) to spread that confusion through my writings, seminars, and other presentations.'}}</ref> 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 (computer science)|string]] would seem not to be atomic, as an RDBMS typically provides operators to decompose it into [[substring]]s.
*A [[Fixed-point arithmetic|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''":<ref name="Date 2007">{{cite book |last=Date| first=C. J. |author-link=Christopher J. Date |chapter=Chapter 8: What First Normal Form Really Means |date=2007 |title=Date on Database: Writings 2000–2006 |publisher=Apress |isbn=978-1-4842-2029-0}}</ref>{{rp|page=112}}<ref>{{cite book |last=Date |first=C. J. |author-link=Christopher J. Date |url=https://books.google.com/books?id=BCjkCgAAQBAJ&pg=PA50 |title=SQL and Relational Theory: How to Write Accurate SQL Code |date=6 November 2015 |publisher=O'Reilly Media |isbn=978-1-4919-4115-7 |pages=50– |access-date=31 October 2018}}</ref>{{Pages needed|date=May 2025}} 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 (from strings and numeric types to arrays and tables) are then acceptable in a 1NF table,{{Citation needed|date=May 2025}} although perhaps not always desirable – for example, it may be desirable to separate a CustomerName column into two columns, FirstName and Surname.

==Cristopher J. Date's definition of 1NF==
{{Importance section|date=May 2025}}
According to [[Christopher J. Date]]'s definition, a table is in first normal form if and only if it is "[[isomorphism|isomorphic]] to some relation", which means, specifically, that it satisfies the following five conditions:{{r|Date 2007}}{{rp|pages=127–128}}

# There is no specific top-to-bottom ordering of the rows.
# There is no specific left-to-right ordering of the columns.
# There are no duplicate rows.
# Every field (or intersection of a row and a column) contains exactly one value from the applicable domain and nothing else.
# All columns are regular (i.e., rows have no hidden components such as row IDs, object IDs, or hidden timestamps).

Violation of any of these conditions would mean that the table is not strictly relational, and therefore that it is not in first normal form.

This definition of 1NF permits relation-valued attributes (tables within tables), which Date argues are useful in rare cases.{{r|Date 2007}}{{rp|pages=121–126}} Examples of tables (or [[view (database)|views]]) that would not meet this definition of first normal form are:

*A table that lacks a [[unique key]] [[constraint (database)|constraint]]. Such a table would be able to accommodate duplicate rows, in violation of condition 3.
*A view whose definition mandates that results be returned in a particular order, so that the row-ordering is an intrinsic and meaningful aspect of the view, in violation of condition 1. The [[tuple]]s in true relations are not ordered with respect to each other (such views cannot be created using [[SQL]] that conforms to the [[SQL:2003]] standard).
*A table with at least one [[Null (SQL)|nullable]] attribute. A nullable attribute would be in violation of condition 4, which requires every column to contain exactly one value from its column's domain. This aspect of condition 4 is controversial; it marks an important departure from Codd's later vision of the [[relational model]],<ref>{{cite book |last=Date |first=C. J. |author-link=Christopher J. Date |year=2009 |title=SQL and Relational Theory |publisher=O'Reilly |chapter=Appendix A.2 |quote=Codd first defined the relational model in 1969 and didn't introduce nulls until 1979}}</ref> which made explicit provision for nulls.<ref>{{cite magazine |last=Date |first=C. J. |author-link=Christopher J. Date |date=14 October 1985 |title=Is Your DBMS Really Relational? |magazine=Computerworld |quote=Null values ... [must be] supported in a fully relational DBMS for representing missing information and inapplicable information in a systematic way, independent of data type.}} (the third of Codd's 12 rules)</ref>

==See also==
*[[Attribute–value system]]
*[[Second normal form]] (2NF)
*[[Third normal form]] (3NF)
*[[Boyce–Codd normal form]] (BCNF or 3.5NF)
*[[Fourth normal form]] (4NF)
*[[Fifth normal form]] (5NF)
*[[Sixth normal form]] (6NF)

==References==
{{Reflist|30em}}

==Further reading==
{{Refbegin}}
* Date, C. J., & Lorentzos, N., & Darwen, H. (2002). ''[https://archive.today/20121209052842/http://www.elsevier.com/wps/product/cws_home/680662 Temporal Data & the Relational Model]'' (1st ed.). Morgan Kaufmann. {{ISBN|1-55860-855-9}}.
* Date, C. J. (1999), ''[https://web.archive.org/web/20050404010227/http://www.aw-bc.com/catalog/academic/product/0,1144,0321197844,00.html An Introduction to Database Systems]'' (8th ed.). Addison-Wesley Longman. {{ISBN|0-321-19784-4}}.
* Kent, W. (1983) ''[http://www.bkent.net/Doc/simple5.htm A Simple Guide to Five Normal Forms in Relational Database Theory]'', ''Communications of the ACM'', vol. 26, p. 120–125.
{{Refend}}

{{Database normalization}}

[[Category:Database normalization|1NF]]

[[de:Normalisierung (Datenbank)#Erste Normalform (1NF)]]
[[pl:Postać normalna (bazy danych)]]