Join-Algorithmus

aus Wikipedia, der freien Enzyklopädie
(Weitergeleitet von Joinalgorithmen)
Zur Navigation springen Zur Suche springen

Ein Join-Algorithmus ist eine Strategie (Algorithmus) zur Implementierung von Joins in relationalen Datenbanken.

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

[Bearbeiten | Quelltext bearbeiten]

Es werden nacheinander alle Tupel aus der Relation ausgewählt und mit jedem Tupel aus der Relation verglichen.

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

Umsetzung von mit als äußerer Relation und als innerer Relation mithilfe zweier geschachtelter Schleifen (nested loops) 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

Da alle Tupel im Kreuzprodukt miteinander verknüpft werden, ergibt sich ein Rechenaufwand von .

Die Anzahl der zu lesenden Blöcke ist im Worst Case , 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 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.

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

[Bearbeiten | Quelltext bearbeiten]

Im Fall, dass beide Relationen und nicht in den Hauptspeicher passen, verbessert ein blockweiser Vergleich den Nested Loop Join.

Der Algorithmus eignet sich für jeden Join.

Umsetzung von 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

Wie für den Nested Loop Join ist die Komplexität .

Die Anzahl der zu lesenden Blöcke ist im Worst Case , im Best Case .

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

[Bearbeiten | Quelltext bearbeiten]

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.

Umsetzung von in Pseudocode:

 pr := erstes Tupel in R
 ps := erstes Tupel in S
 while pr ≠ endofR and ps ≠ endofS do
   // Sammeln aller Tupel mit gleichen Joinattributen aus S
   Ms := Menge mit Inhalt ps
   foreach ts in S > ps
     if ts.a = ps.a
       Ms += Menge mit Inhalt ts
     elseif
       ps := ts
       break foreach
     endif
   end foreach
   // suche passendes Anfangstupel in R
   foreach tr in R > pr
     pr = tr
     if tr.a ≥ ts.a
       break foreach
     endif
   end foreach
   // Tupel ausgeben
   foreach tr in R > pr
     if tr.a > ts.a
       break foreach
     endif
     foreach ts in Ms
       ⇒ Ausgabe von (tr,ts)
     end foreach
     pr = tr
   end foreach
 end while

Die Anzahl der Blockzugriffe für die Sortierung von ist im schlechtesten Fall (Worst Case) , analog für .

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 Blockzugriffen führen.

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

Hash-Join (Simple-Hash)

[Bearbeiten | Quelltext bearbeiten]

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.

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  s
            speichere r  s in Ergebnismenge
        end
    end
end

Die durchschnittliche Laufzeit des Hash-Joins beträgt:

Hash-Partioned-Join

[Bearbeiten | Quelltext bearbeiten]

Die Relationen und werden mit einer gleich- und zufällig verteilenden Hashfunktion in disjunkte Partitionen bis (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 und 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

[Bearbeiten | Quelltext bearbeiten]

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

[Bearbeiten | Quelltext bearbeiten]

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