# Relational model

The

**relational model**fordatabase management is adatabase model based on first-order predicate logic, first formulated and proposed in 1969 by Edgar Codd. [*"Derivability, Redundancy, and Consistency of Relations Stored in Large Data Banks", E.F. Codd, IBM Research Report, 1969*] [*"A Relational Model of Data for Large Shared Data Banks", in*] [Communications of the ACM , 1970.*White, Colin. "In the Beginning: An RDBMS History". Teradata Magazine Online. September 2004 edition. URL: [*]*http://www.teradata.com/t/page/127057 http://www.teradata.com/t/page/127057*]**Overview**Its core idea is to describe a database as a collection of

predicate s over a finite set of predicate variables, describing constraints on the possible values and combinations of values. The content of the database at any given time is a finitemodel (logic) of the database, i.e. a set of relations, one per predicate variable, such that all predicates are satisfied. A request for information from the database (adatabase query ) is also a predicate.The purpose of the relational model is to provide a

declarative method for specifying data and queries: we directly state what information the database contains and what information we want from it, and let the database management system software take care of describing data structures for storing the data and retrieval procedures for getting queries answered.IBM implemented Codd's ideas with the DB2 database management system; it introduced the

SQL data definition and query language. Other relational database management systems followed, most of them using SQL as well. A "table" in an SQL database schema corresponds to a predicate variable; the contents of a table to a relation; key constraints, other constraints, and SQL queries correspond to predicates. However, it must be noted that SQL databases, including DB2, deviate from the relational model in many details; Codd fiercely argued against deviations that compromise the original principles.Fact|date=March 2008**Alternatives to the relational model**Other models are the

hierarchical model andnetwork model . Somesystem s using these older architectures are still in use today indata center s with high data volume needs or where existing systems are so complex and abstract it would be cost prohibitive to migrate to systems employing the relational model; also of note are newer object-oriented databases, even though many of them are DBMS-construction kits, rather than properDBMS s.

A recent development is the Object-Relation type-Object model, which is based on the assumption that any fact can be expressed in the form of one or more binary relationships. The model is used inObject Role Modeling (ORM),RDF /Notation 3 (N3) and inGellish English .The relational model was the first formal database model. After it was defined, informal models were made to describe hierarchical databases (the hierarchical model) and network databases (the network model). Hierarchical and network databases existed "before" relational databases, but were only described as models "after" the relational model was defined, in order to establish a basis for comparison.

**Implementation**There have been several attempts to produce a true implementation of the relational database model as originally defined by Codd and explained by Date, Darwen and others, but none have been popular successes so far. Rel is one of the more recent attempts to do this.

**History**The relational model was invented by E.F. (Ted) Codd as a general model of data, and subsequently maintained and developed by Chris Date and

Hugh Darwen among others. InThe Third Manifesto (first published in 1995) Date and Darwen show how the relational model can accommodate certain desiredobject-oriented features.**Controversies**Codd himself, some years after publication of his 1970 model, proposed a three-valued logic (True, False, Missing or NULL) version of it in order to deal with missing information, and in his "The Relational Model for Database Management Version 2" (1990) he went a step further with a four-valued logic (True, False, Missing but Applicable, Missing but Inapplicable) version. But these have never been implemented, presumably because of attending complexity. SQL's

NULL construct was intended to be part of a three-valued logic system, but fell short of that due to logical errors in the standard and in its implementations. See the section "SQL standard", above.**The model**The fundamental assumption of the relational model is that all

data is represented as mathematical "n"-ary**relations**, an "n"-ary relation being asubset of theCartesian product of "n" domains. In the mathematical model,reasoning about such data is done in two-valuedpredicate logic , meaning there are two possibleevaluation s for eachproposition : either "true" or "false" (and in particular no third value such as "unknown", or "not applicable", either of which are often associated with the concept of NULL). Some think two-valuedlogic is an important part of the relational model, where others think a system that uses a form ofthree-valued logic can still be considered relational. Fact|date=November 2007Who|date=March 2008Data are operated upon by means of a

relational calculus orrelational algebra , these being equivalent inexpressive power .The relational model of data permits the database designer to create a consistent, logical representation of

information . Consistency is achieved by including declared**"constraints**" in the database design, which is usually referred to as the logical schema. The theory includes a process ofdatabase normalization whereby a design with certain desirable properties can be selected from a set of logically equivalent alternatives. Theaccess plan s and other implementation and operation details are handled by theDBMS engine, and are not reflected in the logical model. This contrasts with common practice for SQL DBMSs in whichperformance tuning often requires changes to the logical model.The basic relational building block is the domain or

data type , usually abbreviated nowadays to**"type**". A "tuple " is an unorderedset of**"attribute values**". Anattribute is an ordered pair of**"attribute name**" and**"type name**". An attribute value is a specific valid value for the type of the attribute. This can be either a scalar value or a more complex type.A relation consists of a

**"heading**" and a**"body**". A heading is a set of attributes. A body (of an "n"-ary relation) is a set of "n"-tuples. The heading of the relation is also the heading of each of its tuples.A relation is defined as a

set of "n"-tuples. In both mathematics and the relational database model, a set is an "unordered" collection of items, although some DBMSs impose an order to their data. In mathematics, atuple has an order, and allows for duplication. E.F. Codd originally defined tuples using this mathematical definition. [*cite journal|last=Codd|first=E.F.|year=1970|title=A Relational Model of Data for Large Shared Data Banks|url=http://www.acm.org/classics/nov95/toc.html|journal=*] Later, it was one of E.F. Codd's great insights that using attribute names instead of an ordering would be so much more convenient (in general) in a computer language based on relations Fact|date=February 2007. This insight is still being used today. Though the concept has changed, the name "tuple" has not. An immediate and important consequence of this distinguishing feature is that in the relational model theCommunications of the ACM |volume=13|issue=6|pages=377–387|doi=10.1145/362384.362685Cartesian product becomes commutative.A table is an accepted visual representation of a relation; a tuple is similar to the concept of "row", but note that in the database language

SQL the columns and the rows of a table are ordered.A "

relvar " is a named variable of some specific relation type, to which at all times some relation of that type is assigned, though the relation may contain zero tuples.The basic principle of the relational model is the

Information Principle : allinformation is represented bydata values in relations. In accordance with this Principle, arelational database is a set of relvars and the result of every query is presented as a relation.The consistency of a relational database is enforced, not by rules built into the applications that use it, but rather by "constraints", declared as part of the logical schema and enforced by the

DBMS for all applications. In general, constraints are expressed using relational comparison operators, of which just one, "is subset of" (⊆), is theoretically sufficient. In practice, several useful shorthands are expected to be available, of which the most important arecandidate key (really,superkey ) andforeign key constraints.**Interpretation**To fully appreciate the relational model of data it is essential to understand the intended "interpretation" of a relation.

The body of a relation is sometimes called its extension. This is because it is to be interpreted as a representation of the extension of some predicate, this being the set of true

proposition s that can be formed by replacing eachfree variable in that predicate by a name (a term that designates something).There is a one-to-one correspondence between the free variables of the predicate and the attribute names of the relation heading. Each tuple of the relation body provides attribute values to instantiate the predicate by substituting each of its free variables. The result is a proposition that is deemed, on account of the appearance of the tuple in the relation body, to be true. Contrariwise, every tuple whose heading conforms to that of the relation but which does not appear in the body is deemed to be false. This assumption is known as the

closed world assumption .For a formal exposition of these ideas, see the section

**Set Theory Formulation**, below.**Application to databases**A

**type**as used in a typical relational database might be the set of integers, the set of character strings, the set of dates, or the two boolean values "true" and "false", and so on. The corresponding**type names**for these types might be the strings "int", "char", "date", "boolean", etc. It is important to understand, though, that relational theory does not dictate what types are to be supported; indeed, nowadays provisions are expected to be available for "user-defined" types in addition to the "built-in" ones provided by the system.**Attribute**is the term used in the theory for what is commonly referred to as a**column**. Similarly,**table**is commonly used in place of the theoretical term**relation**(though in SQL the term is by no means synonymous with relation). A table data structure is specified as a list of column definitions, each of which specifies a unique column name and the type of the values that are permitted for that column. An**attribute value**is the entry in a specific column and row, such as "John Doe" or "35".A

**tuple**is basically the same thing as a**row**, except in an SQL DBMS, where the column values in a row are ordered. (Tuples are not ordered; instead, each attribute value is identified solely by the**attribute name**and never by its ordinal position within the tuple.) An attribute name might be "name" or "age".A

**relation**is a**table**structure definition (a set of column definitions) along with the data appearing in that structure. The structure definition is the**heading**and the data appearing in it is the**body**, a set of rows. A database**relvar**(relation variable) is commonly known as a**base table**. The heading of its assigned value at any time is as specified in the table declaration and its body is that most recently assigned to it by invoking some**update operator**(typically, INSERT, UPDATE, or DELETE). The heading and body of the table resulting from evaluation of some query are determined by the definitions of the operators used in the expression of that query. (Note that in SQL the heading is not always a set of column definitions as described above, because it is possible for a column to have no name and also for two or more columns to have the same name. Also, the body is not always a set of rows because in SQL it is possible for the same row to appear more than once in the same body.)**SQL and the relational model**SQL , initially pushed as the standard language forrelational database s, deviates from the relational model in several places. The current ISO SQL standard doesn't mention the relational model or use relational terms or concepts. However, it is possible to create a database conforming to the relational model using SQL if one does not use certain SQL features.The following deviations from the relational model have been noted in

SQL . Note that few database servers implement the entire SQL standard and in particular do not allow some of these deviations. Whereas NULL is nearly ubiquitous, for example, allowing duplicate column names within a table or anonymous columns is uncommon.;Duplicate rows:The same row can appear more than once in an SQL table. The same tuple cannot appear more than once in a relation.;Anonymous columns:A column in an SQL table can be unnamed and thus unable to be referenced in expressions. The relational model requires every attribute to be named and referenceable.;Duplicate column names:Two or more columns of the same SQL table can have the same name and therefore cannot be referenced, on account of the obvious ambiguity. The relational model requires every attribute to be referenceable.;Column order significance:The order of columns in an SQL table is defined and significant, one consequence being that SQL's implementations of Cartesian product and union are both noncommutative. The relational model requires there to be no significance to any ordering of the attributes of a relation.;Views without CHECK OPTION:Updates to a view defined without CHECK OPTION can be accepted but the resulting update to the database does not necessarily have the expressed effect on its target. For example, an invocation of INSERT can be accepted but the inserted rows might not all appear in the view, or an invocation of UPDATE can result in rows disappearing from the view. The relational model requires updates to a view to have the same effect as if the view were a base relvar.;Columnless tables unrecognized:SQL requires every table to have at least one column, but there are two relations of degree zero (of cardinality one and zero) and they are needed to represent extensions of predicates that contain no free variables.;NULL:This special mark can appear instead of a value wherever a value can appear in SQL, in particular in place of a column value in some row. The deviation from the relational model arises from the fact that the implementation of this "ad hoc" concept in SQL involves the use of three-valued logic, under which the comparison of NULL with itself does not yield "true" but instead yields the third truth value, "unknown"; similarly the comparison NULL with something other than itself does not yield "false" but instead yields "unknown". It is because of this behaviour in comparisons that NULL is described as a mark rather than a value. The relational model depends on the

law of excluded middle under which anything that is not true is false and anything that is not false is true; it also requires every tuple in a relation body to have a value for every attribute of that relation. This particular deviation is disputed by some if only because E.F. Codd himself eventually advocated the use of special marks and a 4-valued logic, but this was based on his observation that there are two distinct reasons why one might want to use a special mark in place of a value, which led opponents of the use of such logics to discover more distinct reasons and at least as many as 19 have been noted, which would require a 21-valued logic. SQL itself uses NULL for several purposes other than to represent "value unknown". For example, the sum of the empty set is NULL, meaning zero, the average of the empty set is NULL, meaning undefined, and NULL appearing in the result of a LEFT JOIN can mean "no value because there is no matching row in the right-hand operand".;Concepts:SQL uses concepts "table", "column", "row" instead of "relvar", "attribute", "tuple". These are not merely differences in terminology. For example, a "table" may contain duplicate rows, whereas the same tuple cannot appear more than once in a relation.**Example database**An idealized, very simple example of a description of some relvars and their attributes:

*Customer(

, Tax ID, Name, Address, City, State, Zip, Phone)__Customer ID__

*Order(,__Order No____Customer ID__,__Invoice No__, Date Placed, Date Promised, Terms, Status)

*Order Line(,__Order No__,__Order Line No____Product Code__, Qty)

*Invoice(,__Invoice No____Customer ID__,__Order No__, Date, Status)

*Invoice Line(,__Invoice No__,__Line No____Product Code__, Qty Shipped)

*Product(, Product Description)__Product Code__In this

design we have sixrelvars : Customer, Order, Order Line, Invoice, Invoice Line and Product. The bold, underlined attributes are "candidate key s". The non-bold, underlined attributes are "foreign key s".Usually one

candidate key is arbitrarily chosen to be called theprimary key and used inpreference over the other candidate keys, which are then calledalternate key s.A "candidate key" is a unique

identifier enforcing that notuple will be duplicated; this would make the relation into something else, namely a bag, by violating the basic definition of aset . Both foreign keys and superkeys (which includes candidate keys) can be composite, that is, can be composed of several attributes. Below is a tabular depiction of a relation of our example Customer relvar; a relation can be thought of as a value that can be attributed to a relvar.**Example: customer relation**Customer ID Tax ID Name Address [More fields....]

=1234567890 555-5512222 Munmun 323 Broadway ...2223344556 555-5523232 SS4 Vegeta 1200 Main Street ...3334445563 555-5533323 Ekta 871 1st Street ...4232342432 555-5325523 E. F. Codd 123 It Way ...

If we attempted to "insert" a new customer with the ID "1234567890", this would violate the design of the relvar since

is a "primary key" and we already have a customer "1234567890". The__Customer ID__DBMS must reject atransaction such as this that would render thedatabase inconsistent by aviolation of anintegrity constraint ."

Foreign key s" areintegrity constraint s enforcing that the value of theattribute set is drawn from a "candidate key " in another relation. For example in the Order relation the attributeis a foreign key. A "__Customer ID__join " is the operation that draws oninformation from several relations at once. By joining relvars from the example above we could "query" the database for all of the Customers, Orders, and Invoices. If we only wanted the tuples for a specific customer, we would specify this using arestriction condition .If we wanted to retrieve all of the Orders for Customer "1234567890", we could

query the database to return every row in the Order table with"1234567890" and join the Order table to the Order Line table based on__Customer ID__.__Order No__There is a flaw in our

database design above. The Invoice relvar contains an Order Noattribute . So, each tuple in the Invoice relvar will have one Order No, which implies that there is precisely one Order for each Invoice. But inreality an invoice can be created against many orders, or indeed for no particular order. Additionally the Order relvar contains an Invoice No attribute, implying that each Order has a corresponding Invoice. But again this is not always true in the real world. An order is sometimes paid through several invoices, and sometimes paid without an invoice. In other words there can be many Invoices per Order and many Orders per Invoice. This is a**many-to-many**relationship between Order and Invoice (also called a "non-specific relationship"). To represent this relationship in the database a new relvar should be introduced whoserole is to specify thecorrespondence between Orders and Invoices:OrderInvoice(

,__Order No__)__Invoice No__Now, the Order relvar has a "

one-to-many " relationship to the OrderInvoice table, as does the Invoice relvar. If we want to retrieve every Invoice for a particular Order, we can query for all orders wherein the Order relation equals the__Order No__in OrderInvoice, and where__Order No__in OrderInvoice equals the__Invoice No__in Invoice.__Invoice No__**et-theoretic formulation**Basic notions in the relational model are "relation names" and "attribute names". We will represent these as strings such as "Person" and "name" and we will usually use the variables $r,\; s,\; t,\; ldots$ and $a,\; b,\; c$ to range over them. Another basic notion is the set of "atomic values" that contains values such as numbers and strings.

Our first definition concerns the notion of "tuple", which formalizes the notion of row or record in a table:

;

Tuple : A tuple is apartial function from attribute names to atomic values.; Header: A header is a finite set of attribute names.

; Projection: The projection of a tuple $t$ on a finite

set of attributes $A$ is $t\; [A]\; =\; \{\; (a,\; v)\; :\; (a,\; v)\; in\; t,\; a\; in\; A\; \}$.The next definition defines "relation" which formalizes the contents of a table as it is defined in the relational model.

; Relation: A relation is a tuple $(H,\; B)$ with $H$, the header, and $B$, the body, a set of tuples that all have the domain $H$.

Such a relation closely corresponds to what is usually called the extension of a predicate in

first-order logic except that here we identify the places in the predicate with attribute names. Usually in the relational model a database schema is said to consist of a set of relation names, the headers that are associated with these names and the constraints that should hold for every instance of the database schema.; Relation universe: A relation universe $U$ over a header $H$ is a non-empty set of relations with header $H$.

; Relation schema: A relation schema $(H,\; C)$ consists of a header $H$ and a predicate $C(R)$ that is defined for all relations $R$ with header $H$. A relation satisfies a relation schema $(H,\; C)$ if it has header $H$ and satisfies $C$.

**Key constraints and functional dependencies**One of the simplest and most important types of relation constraints is the "key constraint". It tells us that in every instance of a certain relational schema the tuples can be identified by their values for certain attributes.

; Superkey: A superkey is written as a finite set of attribute names.: A superkey $K$ holds in a relation $(H,\; B)$ if::* $K\; subseteq\; H$ and :* there exist no two distinct tuples $t\_1,\; t\_2\; in\; B$ such that $t\_1\; [K]\; =\; t\_2\; [K]$.: A superkey holds in a relation universe $U$ if it holds in all relations in $U$.:

**Theorem:**A superkey $K$ holds in a relation universe $U$ over $H$ if and only if $K\; subseteq\; H$ and $K\; ightarrow\; H$ holds in $U$.;

Candidate key : A superkey $K$ holds as a candidate key for a relation universe $U$ if it holds as a superkey for $U$ and there is noproper subset of $K$ that also holds as a superkey for $U$.;

Functional dependency : A functional dependency (FD for short) is written as $X\; ightarrow\; Y$ for $X,\; Y$ finite sets of attribute names.: A functional dependency $X\; ightarrow\; Y$ holds in a relation $(H,\; B)$ if::* $X,\; Y\; subseteq\; H$ and :* $forall$ tuples $t\_1,\; t\_2\; in\; B$, $t\_1\; [X]\; =\; t\_2\; [X]\; ~Rightarrow~t\_1\; [Y]\; =\; t\_2\; [Y]$: A functional dependency $X\; ightarrow\; Y$ holds in a relation universe $U$ if it holds in all relations in $U$.; Trivial functional dependency: A functional dependency is trivial under a header $H$ if it holds in all relation universes over $H$.:

**Theorem:**An FD $X\; ightarrow\; Y$ is trivial under a header $H$ if and only if $Y\; subseteq\; X\; subseteq\; H$.; Closure:

Armstrong's axioms : The closure of a set of FDs $S$ under a header $H$, written as $S^+$, is the smallest superset of $S$ such that::* $Y\; subseteq\; X\; subseteq\; H~Rightarrow~X\; ightarrow\; Y\; in\; S^+$ (reflexivity):* $X\; ightarrow\; Y\; in\; S^+\; land\; Y\; ightarrow\; Z\; in\; S^+~Rightarrow~X\; ightarrow\; Z\; in\; S^+$ (transitivity) and:* $X\; ightarrow\; Y\; in\; S^+\; land\; Z\; subseteq\; H~Rightarrow~(X\; cup\; Z)\; ightarrow\; (Y\; cup\; Z)\; in\; S^+$ (augmentation):**Theorem:**Armstrong's axioms are sound and complete; given a header $H$ and a set $S$ of FDs that only contain subsets of $H$, $X\; ightarrow\; Y\; in\; S^+$ if and only if $X\; ightarrow\; Y$ holds in all relation universes over $H$ in which all FDs in $S$ hold.; Completion: The completion of a finite set of attributes $X$ under a finite set of FDs $S$, written as $X^+$, is the smallest superset of $X$ such that::* $Y\; ightarrow\; Z\; in\; S\; land\; Y\; subseteq\; X^+~Rightarrow~Z\; subseteq\; X$: The completion of an attribute set can be used to compute if a certain dependency is in the closure of a set of FDs.:

**Theorem:**Given a set $S$ of FDs, $X\; ightarrow\; Y\; in\; S^+$ if and only if $Y\; subseteq\; X^+$.; Irreducible cover: An irreducible cover of a set $S$ of FDs is a set $T$ of FDs such that::* $S^+\; =\; T^+$:* there exists no $U\; subset\; T$ such that $S^+\; =\; U^+$:* $X\; ightarrow\; Y\; in\; T~Rightarrow\; Y$ is a singleton set and:* $X\; ightarrow\; Y\; in\; T\; land\; Z\; subset\; X~Rightarrow~Z\; ightarrow\; Y\; otin\; S^+$.

**Algorithm to derive candidate keys from functional dependencies****INPUT:**a set "S" of FDs that contain only subsets of a header "H"**OUTPUT:**the set "C" of superkeys that hold as candidate keys in all relation universes over "H" in which all FDs in "S" hold**begin**"C" := ∅; // found candidate keys "Q" := { "H" }; // superkeys that contain candidate keys**while**"Q" <> ∅**do**let "K" be some element from "Q"; "Q" := "Q" - { "K" }; "minimal" :=**true**;**for each**"X->Y"**in**"S"**do**"K' ":= ("K" - "Y") ∪ "X"; // derive new superkey**if**"K' "⊂ "K"**then**"minimal" :=**false**; "Q" := "Q" ∪ { "K' "};**end if****end for****if**"minimal"**and**there is not a subset of "K" in "C"**then**remove all supersets of "K" from "C"; "C" := "C" ∪ { "K" };**end if****end while****end****ee also***

Domain relational calculus

*Life cycle of a relational database

*List of relational database management systems

*Query language

**Database query language

**Information retrieval query language

* Relation

*Relational database

*Relational database management system

*The Third Manifesto (TTM )

* TransRelational model

*Tuple-versioning **References****Further reading*** Date, C. J., Darwen, H. (2000). "Foundation for Future Database Systems: The Third Manifesto", 2nd edition,

Addison-Wesley Professional. ISBN 0-201-70928-7.

* Date, C. J. (2003). "Introduction to Database Systems". 8th edition, Addison-Wesley. ISBN 0-321-19784-4.**External links*** [

*http://www.thethirdmanifesto.com/ The Third Manifesto (TTM)*]

* [*http://dmoz.org/Computers/Software/Databases/Relational/ DMoz category*]

* [*http://c2.com/cgi/wiki?RelationalModel Relational Model*]

* [*http://blogs.sun.com/bblfish/entry/why_binary_relations_beat_tuples binary relations and tuples compared with respect to the semantic web*]

*Wikimedia Foundation.
2010.*

### Look at other dictionaries:

**Relational Model/Tasmania**— (RM/T) was published by E.F. Codd in 1979 and is the name given to a number of extensions to his original relational model (RM) published in 1970. The overall goal of the RM/T was to define some fundamental semantic units, at atomic and molecular … Wikipedia**Probabilistic relational model**— A Probabilistic relational model (PRM) is the counterpart of a Bayesian network in statistical relational learning. External links* [http://forum.stanford.edu/research/project.php?id=164 A description of PRMs] … Wikipedia**Relational calculus**— consist of two calculi, the tuple relational calculus and the domain relational calculus, that are part of the relational model for databases and provide a declarative way to specify database queries. This in contrast to the relational algebra… … Wikipedia**Relational**— may refer to: *Relational (mathematics) *Relational aggression *Relational algebra *Relational art *Relational database *Relational calculus *Relational operator *Relational model *Relational theory *Relational philosophy *Relational… … Wikipedia**Relational database**— A visual diagram showing the relationship between the two tables, as indicated by the arrow A relational database matches data by using common characteristics found within the data set. The resulting groups of data uses the relational model (a… … Wikipedia**Relational database management system**— A Relational database management system (RDBMS) is a database management system (DBMS) that is based on the relational model as introduced by E. F. Codd. Most popular commercial and open source databases currently in use are based on the… … Wikipedia**Relational algebra**— Not to be confused with Relation algebra. Relational algebra, an offshoot of first order logic (and of algebra of sets), deals with a set of finitary relations (see also relation (database)) that is closed under certain operators. These operators … Wikipedia**Relational Database Management System**— Eine relationale Datenbank dient zur elektronischen Datenverwaltung in Computersystemen und beruht auf dem relationalen Datenbankmodell. Dieses wurde 1970 von Edgar F. Codd erstmals vorgeschlagen und ist bis heute, trotz einiger Kritikpunkte, ein … Deutsch Wikipedia**Relational Database Management Systems**— Eine relationale Datenbank dient zur elektronischen Datenverwaltung in Computersystemen und beruht auf dem relationalen Datenbankmodell. Dieses wurde 1970 von Edgar F. Codd erstmals vorgeschlagen und ist bis heute, trotz einiger Kritikpunkte, ein … Deutsch Wikipedia**Relational theory**— …: This article is about relational theory in physics and philosophy. There is a separate article about the relational model (database) and Relational Philosophy as a category of Philosophical anthropology In physics and philosophy, a relational… … Wikipedia