Joinalgorithmen

Joinalgorithmen sind mögliche Strategien (Algorithmen) zur Implementierung von Joins.

Die optimale Strategie hängt von Größe und Struktur der am Join beteiligten Relationen, verwendeten oder verwendbaren Indizes, der Größe des Hauptspeichers als auch der Join-Art (Natural Join, θ-Join oder Equi-Join) ab.

Nested Loop Join

Es werden nacheinander alle Tupel aus der Relation ${\mathit {R}}$ ausgewählt und mit jedem Tupel aus der Relation ${\mathit {S}}$ verglichen.

Der Algorithmus eignet sich für jeden Join und ist auf mehrere Relationen erweiterbar.

Pseudocode

Umsetzung von $R\bowtie _{R.a\theta S.b}S$ mit ${\mathit {R}}$ als äußerer Relation und ${\mathit {S}}$ als innerer Relation in Pseudocode:

  foreach r in R do
    foreach s in S do
      if r.a θ s.b do
        ⇒ Ausgabe von (r,s)
      endif
    end foreach
  end foreach

Bewertung

Da alle Tupel im Kreuzprodukt miteinander verknüpft werden, ergibt sich ein Rechenaufwand von ${\mathcal {O}}(|R|\cdot |S|)$ .

Die Anzahl der zu lesenden Blöcke ist im Worst Case $|R|\cdot b_{s}+b_{r}$ , da für jedes Tupel in R alle Blöcke von S erneut geladen werden. Passen beide Relationen in den Speicher, dann müssen für diesen Best Case $b_{s}+b_{r}$ Blöcke gelesen werden. Passt eine der Relationen komplett in den Speicher, so wird sie als innere Relation ausgewählt, ansonsten ist es sinnvoller, die kleinere Relation als äußere Relation zu wählen.

Varianten

Beim Index Nested Loop Join werden vorhandene oder erstellte Indizes abgeglichen. Die Anzahl der Blockzugriffe hängt dann von Größe und Aufbau der Indexstrukturen ab.

Block Nested Loop Join

Im Fall, dass beide Relationen ${\mathit {R}}$ und ${\mathit {S}}$ nicht in den Hauptspeicher passen, verbessert ein blockweiser Vergleich den Nested Loop Join.

Der Algorithmus eignet sich für jeden Join.

Pseudocode

Umsetzung von $R\bowtie _{R.a\theta S.a}S$ in Pseudocode:

  foreach Block_r in R do
    foreach Block_s in S do
      foreach r in Block_r do
        foreach s in Block_s do
          if r.a θ s.a do
            ⇒ Ausgabe von (r,s)
          endif
        end foreach
      end foreach
    end foreach
  end foreach

Bewertung

Wie für den Nested Loop Join ist die Komplexität ${\mathcal {O}}(|R|\cdot |S|)$ .

Die Anzahl der zu lesenden Blöcke ist im Worst Case $b_{r}\cdot b_{s}+b_{r}$ , im Best Case $b_{s}+b_{r}$ .

Varianten

Passen beide Relationen nicht in den Hauptspeicher, so werden aus der äußeren Relation jeweils so viele Blöcke wie möglich in den Hauptspeicher geladen. Dies reduziert die Anzahl der Blockzugriffe auf die innere Relation.

Sort-Merge Join

Beide Relationen werden nach ihren Join-Attributen sortiert. Das Ergebnis kann dann mit einmaligem Scan durch beide sortierte Relationen berechnet werden.

Der Algorithmus eignet sich nur für Natural Join und Equi-Join.

Pseudocode

Umsetzung von $R\bowtie _{R.a=S.a}S$ in Pseudocode:

 p_r := erstes Tupel in R
 p_s := erstes Tupel in S
 while p_r ≠ endof_R and p_s ≠ endof_S do
   // Sammeln aller Tupel mit gleichen Joinattributen aus S
   M_s := Menge mit Inhalt p_s
   foreach t_s in S > p_s
     if t_s.a = p_s.a
       M_s += Menge mit Inhalt t_s
     elseif
       p_s := t_s
       break foreach
     endif
   end foreach
   // suche passendes Anfangstupel in R
   foreach t_r in R > p_r
     p_r = t_r
     if t_r.a ≥ t_s.a
       break foreach
     endif
   end foreach
   // Tupel ausgeben
   foreach t_r in R > p_r
     if t_r.a > t_s.a
       break foreach
     endif
     foreach t_s in M_s
       ⇒ Ausgabe von (t_r,t_s)
     end foreach
     p_r = t_r
   end foreach
 end while

Bewertung

Die Anzahl der Blockzugriffe für die Sortierung von ${\mathit {S}}$ ist im schlechtesten Fall (Worst Case) $b_{s}\cdot \left(2\cdot \log \left({\frac {b_{s}}{b_{free}}}\right)\right)+b_{s}$ , analog für ${\mathit {R}}$ .

Varianten

Falls Indizes existieren, können diese für das Abrufen der sortierten Join-Attribute verwendet werden. Beim Auslesen der Tupel kann die Zufallsverteilung im Worst Case zu $|S|+|R|$ Blockzugriffen führen.

Beim Hybrid Merge-Join wird deshalb eine Relation ${\mathit {S}}$ sortiert. Danach wird diese über den Index mit den Tupeladressen der anderen Relation ${\mathit {R}}$ gemergt. Die Ergebnismenge wird nach den Tupeladressen sortiert und die Tupel aus ${\mathit {R}}$ damit mit möglichst wenigen Blockzugriffen dazugelesen.

Hash-Join (Simple-Hash)

Die erste Relation erzeugt mit den Join-Attributen eine Hashtabelle. Die Join-Attribute der zweiten Relation werden ebenfalls gehasht. Zeigt der Wert auf ein nicht leeres Bucket in der Hashtabelle, wird das Bucket mit dem aktuellen Tupel verglichen.

Die Hashtabelle wird im Allgemeinen für die kleinere Relation angelegt. Der Hash Join ist nur für Equi-Joins geeignet.

Pseudocode

$R\bowtie _{R.a=S.b}S$

Für alle Elemente s aus S wiederhole
    Hashe über den Join Attributen s(b);
    Trage Tupel entsprechend den Werten in Hashtabelle ein
end
Für alle Elemente r aus R wiederhole
    Hashe über den Join Attributen r(a);
    if r auf nicht-leeres Bucket hashed
        if r  $\theta$  s
            speichere r  $\bullet$  s in Ergebnismenge
        end
    end
end

Bewertung

Die durchschnittliche Laufzeit des Hash-Joins beträgt: ${\mathcal {O}}(n+m)$

Varianten

Hash-Partioned-Join

Die Relationen ${\mathit {R}}$ und ${\mathit {S}}$ werden mit einer gleich- und zufällig verteilenden Hashfunktion in $n_{h}$ disjunkte Partitionen $H_{s_{0}}$ bis $H_{s_{n_{h}}}$ (analog für R) zerlegt. Dabei fallen die Tupel der beiden Relationen in die gleichen Buckets, wenn die Wertebereiche ähnlich sind.

Es müssen dadurch nur die Partitionen $H_{s_{i}}$ und $H_{r_{i}}$ verglichen werden, da sie die Tupel mit den gleichen Join-Attributen enthalten. Der Algorithmus eignet sich nur für Natural Join und Equi-Join.

Implementierungen des Hash-Partioned-Join

Parallel-Join

Parallelisierte Algorithmen verteilen die Arbeit an einem Join auf mehrere Prozessoren oder Rechner. Sie werden in Paralleldatenbanken oder in arbeitsverteilenden Frameworks wie MapReduce, Dryad und Hadoop angewandt.

Auf den einzelnen Prozessoren kann ein beliebiger Join-Algorithmus laufen.

Fragment-and-Replicate Join

Eine Erweiterung des Partitioned Join für θ-Joins: die Elemente des Kreuzprodukt der Partitionspaare $H_{r_{i}}$ und $H_{s_{i}}$ wird an jeweils einen Prozessor übergeben. Durch die Replikation steigt der Datentransfer stark an.