# Relationale Algebra

In der Theorie der Datenbanken versteht man unter einer relationalen Algebra oder Relationenalgebra eine Menge von Operationen zur Manipulation von Relationen. Sie ermöglicht es, Relationen zu filtern, zu verknüpfen, zu aggregieren oder anderweitig zu modifizieren, um Anfragen an eine Datenbank zu formulieren.
Normalerweise werden Anfragen und Programme nicht direkt in einer relationalen Algebra formuliert, sondern in einer deklarativen Sprache wie SQL, XQuery SPARQL oder auch Datalog. Diese Programme und Anfragen werden üblicherweise zunächst in eine (i. Allg. erweiterte) relationale Algebra übersetzt. Der entstehende Operatorbaum wird dann mit Hilfe relationaler Gesetze transformiert, um eine möglichst effiziente Auswertung der Anfragen zu ermöglichen.

## Geschichte und Bedeutung

Im Jahr 1941 stellte Alfred Tarski in seinem Papier „On the calculus of relations“ erstmals Ideen einer relationalen Algebra vor. Insbesondere führte er die relationalen Operationen „Vereinigung“, „Durchschnitt“ und „Join“ ein, wobei er sich allerdings auf zweistellige Relationen beschränkte.
Am Ende seines Artikels erwähnt er, dass er eigentlich nicht so sehr das Ziel hatte, neue Ergebnisse zu präsentieren, als vielmehr das Interesse an einer bestimmten logischen Theorie zu wecken, die bislang nicht beachtet wurde:
   “The aim of this paper has been, not so much to present new results, as to awaken interest in a certain neglected logical theory, and to formulate some new problems concerning this theory.”
Ende der 1960er Jahre entwickelte Edgar F. Codd am IBM Research Laboratory in San Jose die Grundlagen der heutigen relationalen Algebra. Ob ihn die Arbeit Tarskis dazu inspirierte, ist nicht bekannt. Zu Beginn seines Papiers von 1969 stellt er die Behauptung auf, dass das relationale Modell in vielen Aspekten dem Graphenmodell und dem Netzwerkmodell, die zu dieser Zeit „en vogue“ (französisch für „in Mode“) waren, überlegen sei.
   “The first part of this paper is concerned with an explanation of a relational view of data. This view (or model) of data appears to be superior in several respects to the graph or network model [1, 2] presently in vogue.”
Er bezieht sich damit auf die Tatsache, dass die Dauer der Beantwortung von Anfragen sehr stark vom Aufbau des jeweiligen Netzwerks abhängt. Sofern Daten abgerufen werden sollen, die im Netzwerk benachbart sind, muss der Benutzer nur sehr kurz auf eine Antwort warten. Sind die gewünschten Daten jedoch im Netzwerk stark verstreut, kann die Wartezeit unzumutbar lang werden. Die Datenbankentwickler mussten bei der Erstellung eines Netzwerkmodells von vorneherein sämtliche denkbaren Anfragen berücksichtigen, da nachträgliche Änderungen am Datenmodell nur noch sehr schwer umgesetzt werden konnten. Um dieses Problem zu beheben, hatte Codd die Idee, die Daten nicht mehr in einem Netzwerk zu speichern, sondern in Relationen (Tabellen), die je nach Anfrage unterschiedlich miteinander verknüpft werden können:
   “Future users of large data banks must be protected from having to know how the data is organized in the machine (the internal representation).”
Er wagte folgende geradezu prophetische Prognose, dass Datenbanken künftig viele Relationen in gespeicherter Form enthalten würden:
   “The large, integrated data banks of the future will contain many relations of various degrees in stored form.”
Ende 1970, d. h. im selben Jahr, in dem Codds Arbeit publik wurde, stellen Rudolf Bayer und Ed McCreight den B-Baum vor. Dies ist ein Datenbankindex, der es ermöglicht, Relationen mit einer großen Anzahl von Tupel so auf einer Festplatte zu speichern, dass der lesende Zugriff auf Tupel sowie die Modifikation von Tupeln hocheffizient erfolgen kann.
In den 1970er Jahren begann auf Basis dieser beiden Arbeiten die Erfolgsgeschichte der Relationalen Datenbanken einschließlich der zugehörigen Sprache SQL. An Codds Arbeitsstätte, d. h. am IBM Research Laboratory in San Jose, wurden die Sprache SEQUEL sowie das experimentelle Datenbanksystem System R entwickelt. Später wurde SEQUEL in SQL umbenannt. Zu Beginn der 1980er Jahre gab es für die Anfragesprache SQL die ersten kommerziellen relationalen Datenbanksysteme: Db2 von IBM und Oracle von Relational Software Inc. Heute ist SQL aus der Welt der Datenbanken nicht mehr wegzudenken (siehe beispielsweise Kategorie:Relationales Datenbankmanagementsystem). Aber auch diverse weitere Sprachen, wie zunächst QBE oder QUEL und später Datalog, XQuery oder SPARQL, basieren letztendlich auf der Idee Codds, Relationen zum Speichern von Daten einzusetzen.
Als Anfragesprache für Endbenutzer ist die Relationenalgebra heute ohne Bedeutung, datenbank-intern spielt sie jedoch in allen Hochleistungs-Datenbanken eine wesentliche Rolle. Die Datenbanksprache SQL wird in diesen Systemen durch die Anfragebearbeitung des Datenbanksystems intern auf eine Folge von Operationen der Relationenalgebra und weiterer Operationen (wie z. B. für den Zugriff auf Indexe) übersetzt, die durch den Anfrageoptimierer in eine optimale Ausführungsreihenfolge gebracht werden.

## Allgemein

Eine relationale Algebra definiert Operationen, die sich auf eine Menge von Relationen anwenden lassen. Damit können Relationen beispielsweise gefiltert, verknüpft oder aggregiert werden. Die Ergebnisse aller Operationen sind ebenfalls Relationen. Aus diesem Grund bezeichnet man die Relationenalgebra als abgeschlossen.
Ihre Bedeutung hat die Relationenalgebra als theoretische Grundlage für Abfragesprachen in relationalen Datenbanken. Hier werden die Operationen der relationalen Algebra in sogenannten Datenbankoperatoren implementiert. Wenn jede Operation der relationalen Algebra in der Abfragesprache durch (mindestens) einen Ausdruck umgesetzt werden kann, heißt sie relational vollständig; der Ausdruck kann hierbei mehrere Datenbankoperatoren verknüpfen. Wenn jede Operation auch durch (genau) einen Datenbankoperator umgesetzt werden kann, heißt sie streng relational vollständig; es darf also immer nur genau ein Datenbankoperator in ein und demselben umsetzenden Ausdruck enthalten sein. Wenn die Bedingung der strengen relationalen Vollständigkeit auch in die andere Richtung gilt, es also zu jedem Datenbankoperator eine entsprechende Operation der relationalen Algebra gibt, dann heißt die Abfragesprache äquivalent zur relationalen Algebra, kurz: relational äquivalent.
Da es für die relationale Algebra (mehrere) minimale Mengen von Operationen gibt, aus denen alle weiteren Operationen zusammengesetzt werden können, reicht es für die (streng) relationale Vollständigkeit aus, die Abfragesprache mit diesen „Basisoperationen“ zu vergleichen. Das folgt daraus, dass die relationale Algebra trivialerweise selbst-äquivalent ist und durch ein minimales System aus Operationen schon vollständig (im Hinblick auf Operationen) beschrieben ist. Ein übliches minimales System aus Operationen besteht aus den sechs Operationen: Projektion, Selektion, Kreuzprodukt, Vereinigung, Differenz und Umbenennung.
Die relationale Algebra wird wegen ihrer theoretischen Klarheit oft als Bewertungsmaßstab für die Mächtigkeit bzw. Ausdruckskraft von Abfragesprachen genutzt, u. a. mittels der gerade beschriebenen Vergleichsbegrifflichkeiten. Allerdings darf man von der größeren Nähe einer Abfragesprache zur relationalen Algebra nicht auf deren größere Mächtigkeit schließen. Abfragesprachen, die relational vollständig oder sogar streng relational vollständig sind, haben oft einen deutlich größeren Funktionsumfang als dies durch die alleinige Umsetzung der Relationen-Algebra-Operationen möglich wäre. Zum Beispiel ist in der relationalen Algebra die Möglichkeit der Bildung der transitiven Hülle einer Relation, was etwa bei rückbezüglichen Relationen interessant ist, nicht gegeben. Von der strengen relationalen Vollständigkeit einer Abfragesprache lässt sich eher auf eine Mindestfunktionalität, von der relationalen Äquivalenz eher auf eine Maximalfunktionalität schließen, während die nichtstrenge relationale Vollständigkeit die wenigsten konkreten Informationen über die Abfragesprache liefert.
Im Gegensatz zu den Kalkülen ist die relationale Algebra sicher, d. h., sie liefert in endlicher Zeit ein endliches Resultat. Eine relationale Algebra ist darüber hinaus ein Beispiel für eine prozedurale Sprache; im Unterschied zu Kalkülen, die meist als deskriptive Sprachen formalisiert sind.

## Operationen
### Mengenoperationen

Um Mengenoperationen auf den Relationen $R$ und $S$ durchführen zu können, müssen beide miteinander kompatibel sein. Die Typkompatibilität zweier Relationen ist gegeben, wenn
* $R$ und $S$ den gleichen Grad (Attributelementanzahl) haben
* der Wertebereich der Attribute von $R$ und $S$ identisch ist
Die Typkompatibilität wird auch Vereinigungsverträglichkeit genannt.

#### Vereinigung

Bei der Vereinigung $R\cup S$ werden alle Tupel der Relation $R$ mit allen Tupeln der Relation $S$ zu einer einzigen Relation vereint. Voraussetzung dafür ist, dass $R$ und $S$ das gleiche Relationenschema haben. Das heißt, sie haben gleiche Attribute und Attributtypen. Duplikate werden bei der Vereinigung gelöscht.
Definition
* $R\cup S:=\lbrace t\mid t\in R\lor t\in S\rbrace$
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
$S$: :
| A | B | C |
| 7 | 8 | 9 |
| 4 | 5 | 6 |
$R\cup S$: :
| A | B | C |
| 7 | 8 | 9 |
| 4 | 5 | 6 |
| 1 | 2 | 3 |
Voraussetzung
* Vereinigungsverträglichkeit von $R$ und $S$

#### Schnittmenge (Intersection)

Das Ergebnis der Durchschnittsoperation $R\cap S$ sind all die Tupel, die sich sowohl in $R$ als auch in $S$ finden lassen. Der Mengendurchschnitt lässt sich auch durch die Mengendifferenz ausdrücken: $R\cap S=R\setminus (R\setminus S)$
Definition
* $R\cap S:=\lbrace t\mid t\in R\land t\in S\rbrace$
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
$S$: :
| A | B | C |
| 7 | 8 | 9 |
| 4 | 5 | 6 |
$R\cap S$: :
| A | B | C |
| 4 | 5 | 6 |
Voraussetzung
* Vereinigungsverträglichkeit von $R$ und $S$

#### Differenz

Statt der in der Mengenlehre üblichen Schreibweise für die Differenz zweier Mengen, $M\setminus N$, wird in der relationalen Algebra häufig $M-N$ geschrieben. Es handelt sich hierbei jedoch ausdrücklich nicht um die übliche Subtraktion. Bei der Operation $R-S$ werden aus der Relation $R$ alle Tupel entfernt, die auch in der Relation $S$ vorhanden sind. Die Differenz (ebenso wie die symmetrische Differenz) ist keine monotone Operation, daher ist auch die relationale Algebra im Vergleich zu anderen deklarativen Anfragesprachen (z. B. Datalog) nicht monoton.
Definition
* $R-S:=R\setminus S:=\lbrace t\mid t\in R\land t\notin S\rbrace$
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
$S$: :
| A | B | C |
| 7 | 8 | 9 |
| 4 | 5 | 6 |
$R\setminus S$: :
| A | B | C |
| 1 | 2 | 3 |
Voraussetzung
* Vereinigungsverträglichkeit von $R$ und $S$

#### Symmetrische Differenz

Bei der symmetrischen Differenz $R\bigtriangleup S$ handelt es sich um die Menge aller Tupel, die entweder in $R$ oder in $S$, aber nicht in beiden gleichzeitig enthalten sind.
* $R\bigtriangleup S:=\lbrace t\mid (t\in R\lor t\in S)\land t\notin R\cap S\rbrace$
Die Operation kann aus den Grundoperationen abgeleitet werden:
* $R\bigtriangleup S:=(R\setminus S)\cup (S\setminus R)=(R\cup S)\setminus (S\cap R)$
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
$S$: :
| A | B | C |
| 7 | 8 | 9 |
| 4 | 5 | 6 |
$R\bigtriangleup S$: :
| A | B | C |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
Voraussetzung
* Vereinigungsverträglichkeit von R und S

### Kartesisches Produkt (Kreuzprodukt)

Das kartesische Produkt $R\times S$ ist eine Operation, welche dem kartesischen Produkt aus der Mengenlehre ähnelt.
Das Resultat des kartesischen Produkts ist die Menge aller Kombinationen der Tupel aus $R$ und $S$, d. h., jede Zeile der einen Tabelle wird mit jeder Zeile der anderen Tabelle kombiniert. Wenn alle Merkmale (Spalten) verschieden sind, so umfasst die Resultatstabelle die Summe der Merkmale der Ausgangstabellen. Gleichnamige Merkmale der zwei Tabellen werden durch Voranstellen des Tabellennamens referenziert. Die Anzahl der Tupel (Zeilen) in der Resultatstabelle ist das Ergebnis der Multiplikation der Zeilenanzahlen der Ausgangstabellen.
Definition
Zwei beliebige Relationen $R$ und $S$ sind gegeben. Das kartesische Produkt ist definiert durch
* $R\times S:=\{(a_{1},a_{2},\ldots ,a_{n},b_{1},b_{2},\ldots ,b_{m})\mid (a_{1},a_{2},\ldots ,a_{n})\in R\land (b_{1},b_{2},\ldots ,b_{m})\in S\}$
Beispiel
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| E | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
$R\times S$: :
| A | B | C | D | E | F | G |
| 1 | 2 | 3 | 4 | 1 | 2 | 3 |
| 4 | 5 | 6 | 7 | 1 | 2 | 3 |
| 7 | 8 | 9 | 0 | 1 | 2 | 3 |
| 1 | 2 | 3 | 4 | 7 | 8 | 9 |
| 4 | 5 | 6 | 7 | 7 | 8 | 9 |
| 7 | 8 | 9 | 0 | 7 | 8 | 9 |

### Projektion

Die Projektion entspricht der Projektionsabbildung aus der Mengenlehre und kann auch Attributbeschränkung genannt werden. Sie extrahiert einzelne Attribute aus der ursprünglichen Attributmenge und ist somit als eine Art Selektion auf Spaltenebene zu verstehen, das heißt, die Projektion blendet Spalten aus. Wenn $\beta$ die Attributliste ist, schreibt man $\pi _{\beta }(R)$ oder in der linearen Schreibweise $R[\beta ]$. $\beta$ heißt auch Projektionsliste. Duplikate in der Ergebnisrelation werden eliminiert.
Definition
Sei $R$ eine Relation über $\lbrace A_{1},\ldots ,A_{k}\rbrace$ und $\beta \subseteq \lbrace A_{1},\ldots ,A_{k}\rbrace$.
* $\pi _{\beta }(R):=\lbrace t_{\beta }\mid t\in R\rbrace$
Die $t_{\beta }:=(\beta )$, das heißt, die Tupel erhalten nur die Attribute aus der Attributliste $\beta$.
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 1 | 3 | 8 |
$R[A,B]:$ :
| A | B |
| 1 | 2 |
| 4 | 5 |
| 1 | 3 |
$R[A]:$ :
* A
* 1
* 4
Voraussetzung
* Die angegebenen Spalten müssen in $R$ enthalten sein.

### Selektion

Bei der Selektion kann man mit einem Vergleichsausdruck (Prädikat) festlegen, welche Tupel in die Ergebnismenge aufgenommen werden sollen. Es werden also Tupel („Zeilen“) ausgeblendet. Man schreibt $\sigma _{\mathrm {Ausdruck} }(R)$ oder in der linearen Schreibweise $R[\mathrm {Ausdruck} ]$. Ausdruck heißt dann Selektionsbedingung.
Definition
Sei $R$ eine Relation.
* $\sigma _{\mathrm {Ausdruck} }(R):=\{t\mid t\in R\land t\;{\text{erfüllt Ausdruck}}\}$
Ausdruck bezeichnet dabei eine Formel. Diese kann bestehen aus:
* Konstantenselektionen Attribut $\theta$ Konstante, wobei $\theta$ ein üblicher (passender) Vergleichsoperator ist.
* Attributselektionen Attribut $\theta$ Attribut
* Eine Verknüpfung einer Formel mit logischen Prädikaten $\land ,\lor ,\neg$ (Klammerung wie üblich).
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 4 |
| 4 | 6 | 7 |
| 1 | 6 | 7 |
| 8 | 6 | 1 |
$R[A=1]$: :
| A | B | C |
| 1 | 2 | 4 |
| 1 | 6 | 7 |
$R[C>6]$: :
| A | B | C |
| 4 | 6 | 7 |
| 1 | 6 | 7 |
Voraussetzung
* Jedes Element der angegebenen Spalte muss über den Bedingungsoperator mit dem Vergleichswert vergleichbar sein.

### Join

Ein Join (zu deutsch Verbund) bezeichnet die beiden hintereinander ausgeführten Operationen kartesisches Produkt und Selektion. Die Selektionsbedingung ist dabei üblicherweise ein Vergleich von Attributen $A\theta B$, wobei $\theta$ ein passender Vergleichsoperator ist. Man bezeichnet den allgemeinen Verbund daher auch als $\theta$-Verbund (Theta-Verbund). Ein Spezialfall des allgemeinen Verbundes ist der Equi-Join (siehe unten).
Definition
Für zwei Relationen $R(A_{1},\ldots ,A_{n})$ und $S(B_{1},\ldots ,B_{m})$ ist das Ergebnis des allgemeinen Verbundes mit einer Formel Ausdruck als Selektionsbedingung
* $R{\underset {\mathrm {Ausdruck} }{\bowtie }}S:=\lbrace r\cup s\mid r\in R\land s\in S\land \mathrm {Ausdruck} \rbrace$
Die Ableitung ist:
* $R{\underset {\mathrm {Ausdruck} }{\bowtie }}S:=\sigma _{\mathrm {Ausdruck} }(R\times S)$
Beispiel
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| E | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
$R\times S$: :
| A | B | C | D | E | F | G |
| 1 | 2 | 3 | 4 | 1 | 2 | 3 |
| 4 | 5 | 6 | 7 | 1 | 2 | 3 |
| 7 | 8 | 9 | 0 | 1 | 2 | 3 |
| 1 | 2 | 3 | 4 | 7 | 8 | 9 |
| 4 | 5 | 6 | 7 | 7 | 8 | 9 |
| 7 | 8 | 9 | 0 | 7 | 8 | 9 |
$R{\underset {R{.}A\neq S{.}E}{\bowtie }}S;{\textsf {JOIN}}(R,R{.}A\bowtie S{.}E,S):$ :
| A | B | C | D | E | F | G |
| 4 | 5 | 6 | 7 | 1 | 2 | 3 |
| 7 | 8 | 9 | 0 | 1 | 2 | 3 |
| 1 | 2 | 3 | 4 | 7 | 8 | 9 |
| 4 | 5 | 6 | 7 | 7 | 8 | 9 |
Joinverfälschung
Bei der Joinverfälschung wird als erstes die Tabelle gesplittet, bis auf eine Spalte $A_{j}$. Die 2 Tabellen werden dann gejoint über die gemeinsame Spalte $A_{j}$.
Sei $L_{1}\cup L_{2}=\{A_{1},\ldots ,A_{n}\}$ und $L_{1}\cap L_{2}=A_{j}$, dann gilt:
* $R\subseteq \Pi _{L_{1}}(R)\bowtie _{A_{j}}\Pi _{L_{2}}(R)$
Beispiel
${\begin{aligned}L_{1}&=\lbrace A,B\rbrace \\L_{2}&=\lbrace B,C\rbrace \\L_{1}\cap L_{2}&=B\end{aligned}}$
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 2 | 1 | 2 |
| 2 | 2 | 1 |
$R\subseteq \Pi _{L_{1}}(R)\bowtie _{B}\Pi _{L_{2}}(R):$ :
| A | B | C |
| 1 | 2 | 3 |
| 1 | 2 | 1 |
| 2 | 1 | 2 |
| 2 | 2 | 3 |
| 2 | 2 | 1 |

#### Equi-Join

Beim Equi-Join (auch Gleichverbund) wird als erstes das kartesische Produkt gebildet. Dann erfolgt die Selektion mit der Bedingung, dass der Inhalt bestimmter Spalten identisch sein muss. Der Equi-Join ist ein allgemeiner Verbund mit einer Formel der Form $A=B$.
Definition
Für die Relationen $R,S$ und dazugehörige Attribute $A$ (ist Attribut von $R$) und $B$ (ist Attribut von $S$) ist der Equi-Join
* $R\bowtie _{A=B}S:=\lbrace (r,s)\mid r\in R\land s\in S\land r_{[A]}=s_{[B]}\rbrace$
Beispiel
Hier:
* $R\bowtie _{A=E}S:=\lbrace r\cup s\mid r\in R\land s\in S\land r_{[A]}=s_{[E]}\rbrace$
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| E | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
$R\times S$: :
| A | B | C | D | E | F | G |
| 1 | 2 | 3 | 4 | 1 | 2 | 3 |
| 4 | 5 | 6 | 7 | 1 | 2 | 3 |
| 7 | 8 | 9 | 0 | 1 | 2 | 3 |
| 1 | 2 | 3 | 4 | 7 | 8 | 9 |
| 4 | 5 | 6 | 7 | 7 | 8 | 9 |
| 7 | 8 | 9 | 0 | 7 | 8 | 9 |
${\mathsf {JOIN}}(R,R{.}A=S{.}E,S)$: :
| A | B | C | D | E | F | G |
| 1 | 2 | 3 | 4 | 1 | 2 | 3 |
| 7 | 8 | 9 | 0 | 7 | 8 | 9 |

#### Natural Join

Der natürliche Verbund (en.: Natural Join) setzt sich zusammen aus dem Equi-Join und einer zusätzlichen Ausblendung der duplizierten Spalten (Projektion). Der Join erfolgt über die Attribute (Spalten), die in beiden Relationen die gleiche Bezeichnung haben. Gibt es keine gemeinsamen Attribute, so ist das Ergebnis des natürlichen Verbundes das kartesische Produkt. Der natürliche Verbund ist kommutativ und assoziativ, das heißt, es gilt $R\bowtie S=S\bowtie R$ sowie $(R\bowtie S)\bowtie T=R\bowtie (S\bowtie T)$, was eine Rolle bei der Optimierung von Anfragen spielt. Die Anzahl der Attribute der Ergebnisrelation ist die Summe der Anzahlen der beiden Ausgangsrelationen abzüglich der Anzahl der Verbundattribute.
Definition
Für zwei Relationen $R(A_{1},\ldots ,A_{k},B_{1},\ldots ,B_{n})$ und $S(B_{1},\ldots ,B_{n},C_{1},\ldots ,C_{l})$ ist das Ergebnis des natürlichen Verbundes
* $R\bowtie S:=\left\lbrace r\cup s_{[C_{1},\ldots ,C_{l}]}\mid r\in R\land s\in S\land r_{[B_{1},\ldots ,B_{n}]}=s_{[B_{1},\ldots ,B_{n}]}\right\rbrace$
Beispiel
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| A | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
${\mathsf {NATURAL\;JOIN}}(R,S):$ :
| A | B | C | D | F | G |
| 1 | 2 | 3 | 4 | 2 | 3 |
| 7 | 8 | 9 | 0 | 8 | 9 |

#### Semi Join

Der Semi Join berechnet den Anteil eines Natural Joins, welcher nach einer Reduktion auf die linke Relation übrig bleibt.
Definition
Für zwei Relationen $R(A_{1},\ldots ,A_{k},B_{1},\ldots ,B_{n})$ und $S(B_{1},\ldots ,B_{n},C_{1},\ldots ,C_{l})$ ist das Ergebnis des halben natürlichen Verbundes
* $R\ltimes S:=\left\lbrace r\mid r\in R\land s\in S\land r_{[B_{1},\ldots ,B_{n}]}=s_{[B_{1},\ldots ,B_{n}]}\right\rbrace$
Beispiel
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| A | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
${\mathsf {SEMIJOIN}}(R,R{.}A=S{.}A,S):$ :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 7 | 8 | 9 | 0 |

#### Outer Join

Im Gegensatz zum Equi-Join werden beim Outer-Join auch die Tupel der linken (left outer join) bzw. der rechten (right outer join) Tabelle in die Ergebnisrelation mit aufgenommen, die keinen Join-Partner finden. Die nicht vorhandenen Attribute der Join-Relation werden mit Nullwerten aufgefüllt.
Die Kombination aus Left- und Right-Outer-Join wird Outer-Join oder Full-Outer-Join genannt. Dabei werden alle Tupel in die Ergebnisrelation aufgenommen und jene Attribute eines Tupels mit Nullwerten aufgefüllt, die keinen Join-Partner in der jeweils anderen Relation gefunden haben.
Der Outer-Join kann mit oder ohne (natural outer join) Join-Bedingung verwendet werden.
Beispiel
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| A | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
${\mathsf {LEFT\;OUTER\;JOIN}}(R,R{.}A=S{.}A,S):$ :
| A | B | C | D | F | G |
| 1 | 2 | 3 | 4 | 2 | 3 |
| 4 | 5 | 6 | 7 | NULL | NULL |
| 7 | 8 | 9 | 0 | 8 | 9 |

#### Anti Join

Der Anti Join als Gegenstück zum Semi Join berechnet nur die Tupel, für die kein Join-Partner existiert (in SQL: not exists).
Definition
Für zwei Relationen $R(A_{1},\ldots ,A_{k},B_{1},\ldots ,B_{n})$ und $S(B_{1},\ldots ,B_{n},C_{1},\ldots ,C_{l})$ ist das Ergebnis des Anti Joins
* R ▷ S $:=\left\lbrace r\mid r\in R\land \nexists s\in S:r_{[B_{1},\ldots ,B_{n}]}=s_{[B_{1},\ldots ,B_{n}]}\right\rbrace$
Beispiel
$R$: :
| A | B | C | D |
| 1 | 2 | 3 | 4 |
| 4 | 5 | 6 | 7 |
| 7 | 8 | 9 | 0 |
$S$: :
| A | F | G |
| 1 | 2 | 3 |
| 7 | 8 | 9 |
${\mathsf {ANTIJOIN}}(R,R{.}A=S{.}A,S):$ :
| A | B | C | D |
| 4 | 5 | 6 | 7 |

### Umbenennung

Durch diese Operation können Attribute und Relationen umbenannt werden. Diese Operation ist wichtig, um
* Joins von unterschiedlichen benannten Relationen zu ermöglichen,
* kartesische Produkte zu ermöglichen, wo es gleiche Attributnamen gibt, insbesondere auch mit der gleichen Relation
* Mengenoperationen zwischen Relationen mit unterschiedlichen Attributen zu ermöglichen.
Die Schreibweise ist $\rho _{[\mathrm {neu} \leftarrow \mathrm {alt} ]}(R)$, linear $R[\mathrm {alt} \rightarrow \mathrm {neu} ]$.
Definition
Wir konstruieren eine neue Tupelmenge $t'$ aus der alten:
$\rho _{[\mathrm {neu} \leftarrow \mathrm {alt} ]}(R):=\lbrace t'\mid t'(R-\mathrm {alt} )=t(R-\mathrm {alt} )\land t'(\mathrm {neu} )=t(\mathrm {alt} )\rbrace$
Beispiel
$R$: :
| A | B | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
$R[B\rightarrow X]:$ :
| A | X | C |
| 1 | 2 | 3 |
| 4 | 5 | 6 |

### Division

Definition
Da die Division eine abgeleitete Operation ist, definieren wir sie mit Hilfe der anderen Operationen der Relationenalgebra. Seien $R,S$ Relationen und $\beta$ die zu $R$ sowie $\gamma$ die zu $S$ dazugehörigen Attributmengen mit $\gamma \subsetneq \beta$. $R':=\beta \setminus \gamma$.
Die Division ist dann definiert durch:
$R\div S:=\pi _{R'}(R)-\pi _{R'}((\pi _{R'}(R)\times S)-R)$
Anschaulich gesprochen enthält $R\div S$ also diejenigen Attribute aus $R'$, welche in jeder Kombination mit den Attributen aus $S$ in $R$ vorkommen.
Beispiel
Gegeben ist eine Relation $R$, die Väter und Mütter, deren Kinder und das Alter dieser Kinder enthält. Zusätzlich dazu ist eine Relation $S$ gegeben, die einige Kinder und deren Alter enthält: Maria (4) und Sabine (2). Dividiert man $R$ durch $S$, so erhält man als Ergebnis eine Relation, die nur noch diejenigen Ehepaare enthält, die sowohl eine Tochter Maria mit Alter 4 als auch eine Tochter Sabine mit Alter 2 haben:
$R$: :
| Vater | Mutter | Kind | Alter |
| Franz | Helga | Harald | 5 |
| Franz | Helga | Maria | 4 |
| Franz | Ursula | Sabine | 2 |
| Moritz | Melanie | Gertrud | 7 |
| Moritz | Melanie | Maria | 4 |
| Moritz | Melanie | Sabine | 2 |
| Peter | Christina | Robert | 9 |
$S$: :
| Kind | Alter |
| Maria | 4 |
| Sabine | 2 |
$R\div S$: :
| Vater | Mutter |
| Moritz | Melanie |
Die Division wird dann eingesetzt, wenn die Frage „für alle“ enthält. Für unser Beispiel lautet die Frage also: „Wähle alle Eltern aus (Vater, Mutter), die ein Kind mit dem Namen Maria und dem Alter 4 und ein Kind mit dem Namen Sabine und dem Alter 2 (die Relation $S$) haben.“

## Minimalität und Vollständigkeit

Eine minimale Menge von Operationen, das heißt, eine Menge von Operationen, die mindestens notwendig ist, um alle Ausdrücke der relationalen Algebra bilden zu können, umfasst
* Projektion
* Selektion
* Kartesisches Produkt
* Vereinigung
* Differenz
* Umbenennung
Alle anderen Operationen (zum Beispiel Joins) lassen sich durch diese Grundoperationen nachbilden.
Jede andere Menge von Operationen ist relational vollständig, wenn sie die gleiche Mächtigkeit wie die oben genannten Operationen haben.

## Erweiterungen der relationalen Algebra

Um andere Abfragesprachen, speziell SQL, vollständig in die relationale Algebra abbilden zu können, ist die relationale Algebra nicht mächtig genug. Es gibt z. B. keine Möglichkeit, die SQL-Operatoren GROUP BY/HAVING, Aggregatfunktionen und Nullwerte in die relationale Algebra zu übersetzen. Wir betrachten hier einige Erweiterungen (die teilweise ähnliches bewirken), die eine vollständige Abbildung in die relationale Algebra, und damit eine vollständige theoretische Betrachtung dieser Abfragesprachen, ermöglichen.

### Nullwerte

SQL ermöglicht die Verwendung von NULL-Werten, die mit dem speziellen Prädikat IS NULL abgefragt werden können. Dies ist insbesondere wichtig bei der Bildung von äußeren Verbunden, die eine Relation erzeugen, die alle Werte der einen Relation enthalten, sowie alle Werte der anderen, für die die Verbundbedingung wahr ist, sonst eben NULL-Werte. Dies kann mit der relationalen Algebra so nicht abgebildet werden.
Eine Möglichkeit ist die Definition von Nullwerten wie in SQL mit einer dreiwertigen Logik, das heißt, die booleschen Operatoren werden mittels Wahrheitstabellen so erweitert, dass festgelegt ist, wie zu verfahren ist, wenn ein Operand NULL ist.
Erweiterte Wahrheitstabelle für AND :
| ∧ | true | false | NULL |
| true | true | false | NULL |
| false | false | false | false |
| NULL | NULL | false | NULL |
Selektionsbedingungen oder Verbunde, die auf Nullwerte angewendet werden, ergeben NULL. Eine Schwierigkeit damit (d. h. mit der SQL-artigen Behandlung von Nullwerten) besteht darin, dass die Ergebnisse von Abfragen mit Unterabfragen, die NULL ergeben, nicht notwendigerweise der Intention des Benutzers entsprechen. Diese Art der Nullwertbehandlung ist auch nicht orthogonal, d. h. das Verhalten auf der einen Ebene (boolesche Operatoren, 3-wertige Logik) entspricht nicht dem auf einer anderen (Verbunde, 3-wertige Logik wird auf 2-wertige abgebildet).
Eine andere Möglichkeit ist die Unterscheidung zweier verschiedener Arten von Nullwerten, die jeweils „beliebig“ oder „nicht definiert“ bedeuten.

### Gruppierungsoperator und Aggregatfunktionen

Die Gruppierung wendet Funktionen auf gleiche Attribute in einer Relation an. Der Operator γ erhält eine Liste von Funktionen und eine Attributliste. Die Funktionen werden dann auf Tupel angewendet für die die Attribute der Attributliste gleich sind. Die Ausgabe ist eine neue Relation bestehend aus der Attributliste und einem neuen Attribut, das die Ergebnisse der Funktionsliste enthält.
Die Funktionen sind dann die üblichen Aggregatfunktionen count, sum, max, avg ….
Definition
Seien R eine Relation und A = {A$_1$, …, A$_n$} Attribute aus R. F(X) sei eine Funktionsliste f$_1$(x$_1$), …, f$_n$(x$_n$). Die Gruppierung ist dann
$\gamma _{F(X);A}(R):=\bigcup _{t\in R}\gamma _{F(X);\emptyset }(\sigma _{A=t.A}(R))$
Für eine leere Attributmenge (also γ$_{F(X);}$(…)) wird ein zusätzliches Attribut erzeugt, das den Wert der Funktionsanwendung über die gesamte Relation enthält. Dies wird ausgenutzt, um die Relation mit der Selektion in Teilrelationen mit gleichen Attributen zu zerlegen, die dann mit der Funktionsanwendung wieder zusammengesetzt werden.
Weiter gilt, dass eine Gruppierung mit einer leeren Funktionsliste keinen Effekt hat.

### Multimengensemantik

SQL liefert als Ergebnis von Anfragen eine Multimenge zurück, also eine Menge, die Elemente mehrfach enthalten kann. Dies wurde aus Performance-Gründen so gehandhabt, um den zusätzlichen Schritt der Duplikatentfernung zu sparen. Es können also streng genommen nur Anfragen in die relationale Algebra übersetzt werden, die mit DISTINCT angegeben sind.
Für die relationale Algebra kann man dann zusätzlich eine Funktion bag-to-set spezifizieren, die die Duplikate aus einer Multimenge entfernt und somit eine Menge erzeugt, und die Basisoperationen dann einfach als Multimenge $\{\{t\mid \ldots \}\}$ spezifizieren. Vorsicht muss man aber bei der Definition abgeleiteter Operationen walten lassen.

### NF²

Eine Erweiterung des relationalen Datenbankmodells ist das NF²-Modell. Der Name steht für Non-first-normal-form (NFNF), was andeuten soll, dass die Bedingung atomarer Attributwerte der 1. Normalform aufgebrochen wird. Folglich werden Mengen von Attributen und Mengen von Mengen erlaubt, was dazu führt, dass ein Attribut einer Relation wieder eine Relation sein kann. Die Domäne (Wertebereich) eines kombinierten Attributs ist das Kreuzprodukt der beteiligten Attributdomänen.
NF² erweitert die relationale Algebra dahingehend, dass neben den üblichen (entsprechend angepassten) Operationen der relationalen Algebra zwei Operationen hinzugenommen werden, die eine Relation schachteln (Nestung ν) und entschachteln (Entnestung μ). Die Nestung fasst eine Menge von Attributen in eine Unterrelation zusammen, die einen neuen Attributnamen erhält. Die Entnestung hebt Schachtelungen auf. Diese Operationen dienen dazu NF² Relationen in die 1. Normalform zu transformieren und umgekehrt. Die Operationen sind im Allgemeinen nicht bijektiv.
NF² benötigt aus obigen Gründen keine Fremdschlüssel.

### eNF$^2$

eNF$^2$ steht für „erweiterte NF$^2$-Relationen“ und ist eine (erhebliche) Verallgemeinerung des NF$^2$-Relationenmodells. Es wurde entwickelt, da in vielen technisch-wissenschaftlichen Anwendungen, wie Geoinformationssystemen, CAM, CAD und Robotik, Datenstrukturen auftreten, die selbst mit NF$^2$- Relationen nicht mehr adäquat repräsentiert werden können. Hierzu gehören insbesondere listenartige Datenobjekte, wie z. B. Messreihen und Polygone. Listenstrukturen können dabei auch geschachtelt auftreten, wie z. B. bei Matrizen im zwei- oder mehrdimensionalen Raum. Eine weitere Eigenschaft des eNF$^2$-Relationenmodells der dafür konzipierten SQL-artigen Anfragesprache HDBL (steht für „Heidelberg Database Language“) ist, dass jedes Anfrageergebnis wieder ein legales eNF$^2$-Datenobjekt zurückliefert, das auch in einer eNF$^2$-Datenbank gespeichert oder innerhalb eines geschachtelten HDBL-Ausdrucks auftreten kann.
Im eNF$^2$-Relationenmodell und in HDBL können deshalb alle atomaren und konstruierten Datentypen (Tupel, Menge, Liste) sowohl auf der obersten Ebene als auch als Subtypen auftreten.
Das eNF$^2$-Datenmodell bietet damit im Wesentlichen alle Datenstrukturen, die man auch in gängigen Programmiersprachen, wie z. B. C, C++ und Java, zur Verfügung hat. Es bietet daher auch eine gute Basis für die Ergänzung eines solchen eNF$^2$-DBMS durch die Implementierung benutzerdefinierter Datentypen und Funktionen, die insbesondere für technisch-wissenschaftliche Anwendungen sehr wertvoll sind.

## Beispiele

Als Relationenschemata für die Beispiele nehmen wir die klassische Beispieldatenbank bestehend aus den Schemata Kunde, Lieferant und Ware. Die Schemata seien:
* KUNDE (Kundennr, Name, Wohnort, Kontostand)
* LIEFERANT (Lieferantennr, Name, Ort, Telefon)
* WARE (Warennr, Bezeichnung, Lieferantennr, Preis)
Grundoperationen der relationalen Algebra werden dann so benutzt:
* Die Preise aller Waren:
* π$_{Bezeichnung,Preis}$(WARE)
* Alle Lieferanten aus Bremen:
* σ$_{Ort='Bremen'}$(LIEFERANT)
* Kunden mit negativem Kontostand:
* σ$_{Kontostand<0}$(KUNDE)
* Ort von LIEFERANT umbenennen (zum Beispiel um Mengenoperationen durchführen zu können):
* ρ$_{Wohnort←Ort}$(LIEFERANT)
Da die Ergebnisse der relationalen Algebra wieder Relationen sind (die RA ist orthogonal), können die Operationen wieder auf die Ergebnisse von Operationen angewendet werden. Dies erlaubt komplexe Abfragen. Für eine einfachere Schreibweise nehmen wir an, dass das Kreuzprodukt eine implizite Umbenennung der Attribute vornimmt, so dass die neuen Attributnamen mit dem Relationennamen qualifiziert sind, d. h. aus Lieferantennr aus der Relation WARE wird WARE.Lieferantennr:
* Die Telefonnummern aller Lieferanten, die Gemüse in Bremen liefern:
* π$_{Telefon}$(σ$_{Bezeichnung='Gemüse'∧Ort='Bremen'∧LIEFERANT.Lieferantennr=WARE.Lieferantennr}$(LIEFERANT × WARE))
* Alle Orte, die wenigstens einen Lieferanten und wenigstens einen Kunden enthalten
* π$_{Ort}$(ρ$_{Ort←Wohnort}$(KUNDE)) ∩ π$_{Ort}$(LIEFERANT)