An example of a database that has not enforced referential integrity. In this example, there is a foreign key (artist_id) value in the album table that references a non-existent artist — in other words there is a foreign key value with no corresponding primary key value in the referenced table. What happened here was that there was an artist called "Aerosmith", with an artist_id of 4, which was deleted from the artist table. However, the album "Eat the Rich" referred to this artist. With referential integrity enforced, this would not have been possible.

Referential integrity is a property of data stating that all its references are valid. In the context of relational databases, it requires that if a value of one attribute (column) of a relation (table) references a value of another attribute (either in the same or a different relation), then the referenced value must exist.^[1]

For referential integrity to hold in a relational database, any column in a base table that is declared a foreign key can only contain either null values or values from a parent table's primary key or a candidate key.^[2] In other words, when a foreign key value is used it must reference a valid, existing primary key in the parent table. For instance, deleting a record that contains a value referred to by a foreign key in another table would break referential integrity. Some relational database management systems (RDBMS) can enforce referential integrity, normally either by deleting the foreign key rows as well to maintain integrity, or by returning an error and not performing the delete. Which method is used may be determined by a referential integrity constraint defined in a data dictionary.

The adjective 'referential' describes the action that a foreign key performs, 'referring' to a linked column in another table. In simple terms, 'referential integrity' guarantees that the target 'referred' to will be found. A lack of referential integrity in a database can lead relational databases to return incomplete data, usually with no indication of an error.

Formalization

An inclusion dependency over two (possibly identical) predicates ${\displaystyle R}$ and ${\displaystyle S}$ from a schema is written ${\displaystyle R[A_{1},...,A_{n}]\subseteq S[B_{1},...,B_{n}]}$, where the ${\displaystyle A_{i}}$, ${\displaystyle B_{i}}$ are distinct attributes (column names) of ${\displaystyle R}$ and ${\displaystyle S}$. It implies that the tuples of values appearing in columns ${\displaystyle A_{1},...,A_{n}}$ for facts of ${\displaystyle R}$ must also appear as a tuple of values in columns ${\displaystyle B_{1},...,B_{n}}$ for some fact of ${\displaystyle S}$.

Such constraint is a particular form of tuple-generating dependency (TGD) where in both the sides of the rule there is only one relational atom.^[3] In first-order logic it is expressible as ${\displaystyle \forall {\vec {x}},{\vec {y}}.(R({\vec {x}},{\vec {y}})\rightarrow \exists {\vec {z}}.S({\vec {x}},{\vec {z}}))}$, where ${\displaystyle {\vec {x}}}$ is the vector (whose size is ${\displaystyle n}$) of variables shared by ${\displaystyle R}$ and ${\displaystyle S}$, and no variable appears multiple times neither in the TGD's body nor in its head.

Logical implication between inclusion dependencies can be axiomatized by inference rules^[4]: 193 and can be decided by a PSPACE algorithm. The problem can be shown to be PSPACE-complete by reduction from the acceptance problem for a linear bounded automaton.^[4]: 196 However, logical implication between dependencies that can be inclusion dependencies or functional dependencies is undecidable by reduction from the word problem for monoids.^[4]: 199

Declarative referential integrity

Declarative Referential Integrity (DRI) is one of the techniques in the SQL database programming language to ensure data integrity.

See also

• Null pointer dereferencing
• Dangling pointer
• Data integrity
• Domain/key normal form
• Entity integrity
• Functional dependency
• Propagation constraint
• Surrogate key
• Slowly changing dimension

References

External links

• DRI versus Triggers (archived)