Title

layout: true
<slide-template title="Vorlesung Cloud- und Web-Technologien (CS3140)" subtitle="Operatoren der Relationalen Algebra in MapReduce"></slide-template>

---

class: title-slide, center, middle

<title-slide title="Cloud- und Web-Technologien" modulenumber="(CS3140)" subtitle="Operatoren der Relationalen Algebra in MapReduce"></title-slide>

---

# Chronologische Übersicht über die Themen
<webinfo-overview-new current="7"></webinfo-overview-new>

---

# .darkblue[Relationale Algebra]

- Grundlage von SQL
- Jede Anfragesprache sollte mindestens die Mächtigkeit der Relationalen Algebra haben<br/>=> Relationale Vollständigkeit
- Aber: Relationale Algebra nicht Turing-vollständig
  - Keine Möglichkeit zur Berechnung der transitiven Hülle
  - Fehlen von Rekursion
  - ...<br/>Durch diese Einschränkung besser optimierbar!

---

# Kriterien für Anfragesprachen 1/3

- Ad-Hoc-Formulierung
  - Einfache Formulierung der Anfrage
  - Ohne ein ganzes Programm formulieren zu müssen

- Deskriptivität/Deklarativität
  - Deklarativ: „Was?“ und nicht „Wie?“

- Optimierbarkeit
  - Anfrage kann auf wenige Basisoperationen abgebildet werden, für die es Optimierungsregeln gibt

---

# Kriterien für Anfragesprachen 2/3

.condensed[
- Mengenorientiert
  - Operationen auf Mengen von Daten 
- Abgeschlossenheit
  - Ergebnis ist wieder eine Relation und kann als Eingabe für nächste Anfrage dienen<br/>($\rightarrow$ Verschachtelbare Ausdrücke)
- Adäquatheit
  - Unterstützung aller Konstrukte des darunterliegenden Datenmodells
- Orthogonalität
  - Sprachkonstrukte sind in ähnlichen Situationen auch ähnlich anwendbar
]

---

# Kriterien für Anfragesprachen 3/3

- Effizienz
  - Effiziente Ausführbarkeit jeder Operation
  - Relationales Modell: $\leq O(n^2)$, $n$ Anzahl Tupel der Eingangsrelation

- Sicherheit
  - Syntaktisch korrekte Anfragen liefern endliche Ergebnisse und terminieren (keine Endlosschleife und keine unendlichen Ergebnisse)

- Vollständigkeit
  - Sprache muss mindestens so mächtig wie eine Standardsprache sein (z.B. relationale Algebra)

---

# Relationale Algebra - Operatoren

.more-condensed[
<table class="tablepadding">
<tr>
<td class="topalign">

Minimale Menge von Operatoren<br/>.small-font[(es existieren auch andere minimale Mengen)
<table class="result tablesmallpadding margin-bottom">
<tr>
<th>Operator</th>
<th>Symbol</th>
</tr>
<tr>
<td>Projektion</td>
<td>$\pi$</td>
</tr>
<tr>
<td>Selektion</td>
<td>$\sigma$</td>
</tr>
<tr>
<td>Kreuzprodukt</td>
<td>$\times$</td>
</tr>
<tr>
<td>Vereinigung</td>
<td>$\cup$</td>
</tr>
<tr>
<td>Differenz</td>
<td>$-$</td>
</tr>
<tr>
<td>Umbenennung</td>
<td>$\rho$</td>
</tr>
</table>
]
Weitere Operatoren
.small-font[
<table class="result tablesmallpadding">
<tr>
<th>Operator</th>
<th class="padding-left padding-right">Symbol</th>
</tr>
<tr>
<td>Durchschnitt</td>
<td>$\cap$</td>
</tr>
<tr>
<td>Division/Quotient</td>
<td>$\div$</td>
</tr>
<tr>
<td>Join</td>
<td>$\bowtie$</td>
</tr>
</table>
]
</td>
<td class="topalign">
Erweiterte Relationale Algebra
.small-font[
(Außer Semi-Join ($\rtimes$/$\ltimes$) und<br/>$MIN$/$MAX$ nicht durch Operatoren<br/>der minimalen Menge darstellbar)
<table class="result tablesmallpadding">
<tr>
<th>Operator</th>
<th>Symbol</th>
</tr>
<tr>
<td>Semi Join</td>
<td>$\rtimes$, $\ltimes$</td>
</tr>
<tr>
<td>Äußere Joins</td>
<td>⟗, ⟕, ⟖</td>
</tr>
<tr>
<td>Duplikateliminierung</td>
<td>$\delta$</td>
</tr>
<tr>
<td>Aggregation</td>
<td>$SUM$, $AVG$,<br/>$MIN$, $MAX$,<br/>$COUNT$, ...</td>
</tr>
<tr>
<td>Gruppierung</td>
<td>$\gamma$</td>
</tr>
<tr>
<td>Sortierung</td>
<td>$\tau$</td>
</tr>
<tr>
<td>Erweiterte Projektion</td>
<td>$\pi$</td>
</tr>
<tr>
<td>Äußere Vereinigung</td>
<td>⨄</td>
</tr>
</table>
</td>
</table>
]
]

---

# Mengen versus Multimengen

.more-condensed[
- Menge
  - Jedes Element ist höchstens einmal enthalten
  - Reihenfolge spielt keine Rolle
  - SQL mit Duplikateliminierung (DISTINCT) 
- Multimenge
  - Jedes Element kann mehrfach vorkommen
  - Reihenfolge spielt keine Rolle
  - SQL ohne Duplikateliminierung (ohne DISTINCT)
  - Meist effizienter, da aufwändige Duplikateliminierung entfällt <br/>(falls gewünscht Duplikateliminierung evtl. nur einmal abschließend)
- Operatoren der Relationalen Algebra
  - Traditionell Mengensemantik
  - Zusätzlich Vorstellung der Multimengensemantik
]

---

# Selektion $\sigma_C$ 1/2

.more-more-condensed[
- $\sigma_C(R) := ${$ t | t \in R \wedge C(t) $} mit
  - $R$ Relation
  - $C$ Selektionsbedingung:
       - $l \Theta r$ mit $l$ und $r$ Konstanten oder Attribute aus $R$,<br/>$\Theta \in ${$ =, \neq, <, \leq, >, \geq $} bei geordneten Wertebereichen,<br/>sonst $\Theta \in ${$ =, \neq $}
	   - $C_1 \wedge C_2$, $C_1 \vee C_2$, $\neg C_1$ mit $C_1$, $C_2$ Selektionsbedingungen
	   - $true$, $false$
]

---

# Selektion $\sigma_C$ 2/2

.more-more-condensed[
<table class="tablepadding outline">
<tr>
<td class="bold darkblue">Eingangsrelation $R$</td>
<td class="padding-bottom padding-top bold darkblue">$R_E := \sigma$ <span class="subscript small-font">$Preis \geq 500 \wedge Lieferzeit\leq 3$</span> $(Teil)$</td>
</tr>
<tr>
<td class="small-font topalign">$Teil$
<table class="result textcenter">
<tr>
<th><span class="underline">PID</span></th>
<th>Bez.</th>
<th>Liefer-<br/>zeit</th>
<th>Preis</th>
</tr>
<tr>
<td>22</td>
<td>PC1</td>
<td>5</td>
<td>1000</td>
</tr>
<tr>
<td>23</td>
<td>PC2</td>
<td>3</td>
<td>520</td>
</tr>
<tr>
<td>24</td>
<td>PC3</td>
<td>1</td>
<td>100</td>
</tr>
</table>

</td>
<td class="small-font topalign">$R_E$

<table class="result margin-bottom textcenter">
<tr>
<th><span class="underline">PID</span></th>
<th>Bez.</th>
<th>Liefer-<br/>zeit</th>
<th>Preis</th>
</tr>
<tr>
<td>23</td>
<td>PC2</td>
<td>3</td>
<td>520</td>
</tr>
</table>
<span class="bold darkblue">Mengensemantik:</span> Duplikate können nicht entstehen, da Eingangsrelation keine Duplikate enthalten kann<br/>
<span class="bold darkblue">Multimengensemantik:</span> Evtl. vorhandene Duplikate bleiben bestehen

</td>
</tr>
</table>

- MapReduce
  - Map
      - $\forall t \in R$ mit $C(t) = true:$ Emit $(t, t)$ as key/value-pair
]

---

# Duplikateliminierung $\delta$

.condensed[
- Wandelt Multimenge in Menge um
  - SQL: Mengensemantik bei DISTINCT meist durch genau eine finale Duplikateliminierung realisiert

- $\delta(R):=${ $t|t\in R$ } mit
  - $R$ Relation
  
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $(t, t)$ as key/value-pair
	  - gut mit anderen Operatoren (wie Projektion $\pi$ oder Selektion $\sigma$) mit nur einer Map-Phase kombinierbar
  - Reduce
      - for each fetched $(t, [t, ..., t])$: Emit $(t, t)$ as key/value-pair
]

---

# Projektion $\pi$ 1/2

.condensed[
- $\pi_{A_1,...,A_k}(R):=${$(t[A_1],...,t[A_k])|t\in R$} mit
  - $R$ Relation
  - $A_1, ..., A_k$ Attribute aus $R$

<table class="tablepadding small-font">
<tr>
<td rowspan="2" class="bold darkblue topalign">Eingangsrelation $R$</td>
<td colspan="2" class="bold darkblue topalign">
$R_E := \pi_{PID, KID}(Bestellung)$
</td>
</tr>
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table class="result textcenter">
<tr>
<th><span class="underline">BestID</span></th>
<th>Datum</th>
<th>PID<br/>$\rightarrow$ Teil</th>
<th>KID<br/>$\rightarrow$ Kunde</th>
</tr>
<tr>
<td>1</td>
<td>2.1.18</td>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>2</td>
<td>3.1.18</td>
<td>12</td>
<td>15</td>
</tr>
<tr>
<td>3</td>
<td>4.1.18</td>
<td>10</td>
<td>14</td>
</tr>
</table>

</td>
<td class="topalign">

<table class="result textcenter">
<tr>
<th>PID<br/>$\rightarrow$ Teil</th>
<th>KID<br/>$\rightarrow$ Kunde</th>
</tr>
<tr>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>12</td>
<td>15</td>
</tr>
</table>

</td>
<td class="topalign">

<table class="result textcenter">
<tr>
<th>PID<br/>$\rightarrow$ Teil</th>
<th>KID<br/>$\rightarrow$ Kunde</th>
</tr>
<tr>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>12</td>
<td>15</td>
</tr>
<tr>
<td>10</td>
<td>14</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Projektion $\pi$ 2/2

.condensed[
- $\pi_{A_1,...,A_k}(R):=${$(t[A_1],...,t[A_k])|t\in R$} mit
  - $R$ Relation
  - $A_1, ..., A_k$ Attribute aus $R$
  
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $((t[A_1],...,t[A_k]), (t[A_1],...,t[A_k]))$ as key/value-pair
  - Reduce
      - Bei Mengensemantik Reduce-Schritt der Duplikateliminierung
	  - Bei Multimengensemantik entfällt Reduce-Schritt
]

---

# Vereinigung $\cup$ 1/2

.condensed[
- $R \cup S = ${$ t | t \in R \vee t \in S$}

<table class="small-font tablepadding">
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table class="result tablepadding textcenter">
<tr>
<th></th>
<th>$R$</th>
<th>$S$</th>
<th>$R \cup S$</th>
</tr>
<tr>
<td rowspan="4">Tupel<br/>in</td>
<td>✔</td>
<td></td>
<td>✔</td>
</tr>
<tr>
<td></td>
<td>✔</td>
<td>✔</td>
</tr>
<tr>
<td>✔</td>
<td>✔</td>
<td>✔</td>
</tr>
<tr>
<td> </td>
<td></td>
<td></td>
</tr>
</table>

</td>
<td class="topalign">

<table class="result tablepadding textcenter">
<tr>
<th></th>
<th>$R$</th>
<th>$S$</th>
<th>$R \cup S$</th>
</tr>
<tr>
<td>Tupel<br/>in</td>
<td>n-mal</td>
<td>m-mal</td>
<td>(n+m)-mal</td>
</tr>
</table>

</td>
</tr>
<tr>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>
<td class="topalign">$R \cup S$

</td>
</tr>
</table>

</td>
<td class="topalign">

<td class="topalign">$R \cup S$

</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Vereinigung $\cup$ 2/2

.condensed[
- $R \cup S = ${$ t | t \in R \vee t \in S$}
- Hadoop MapReduce unterstützt in der Map-Phase das Lesen von mehreren Eingaben gleichzeitig
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $(t, t)$ as key/value-pair
      - $\forall t \in S:$ Emit $(t, t)$ as key/value-pair
  - Reduce
      - Bei Mengensemantik Reduce-Schritt der Duplikateliminierung
	  - Bei Multimengensemantik entfällt Reduce-Schritt
]

---

# Durchschnitt $\cap$ 1/2

.more-more-condensed[
- $R \cap S = ${$ t | t \in R \wedge t \in S$}

<table class="small-font tablepadding">
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table class="result tablepadding textcenter">
<tr>
<th></th>
<th>$R$</th>
<th>$S$</th>
<th>$R \cap S$</th>
</tr>
<tr>
<td rowspan="4">Tupel<br/>in</td>
<td>✔</td>
<td></td>
<td></td>
</tr>
<tr>
<td></td>
<td>✔</td>
<td></td>
</tr>
<tr>
<td>✔</td>
<td>✔</td>
<td>✔</td>
</tr>
<tr>
<td> </td>
<td></td>
<td></td>
</tr>
</table>

</td>
<td class="topalign">

<table class="result tablepadding textcenter">
<tr>
<th></th>
<th>$R$</th>
<th>$S$</th>
<th>$R \cap S$</th>
</tr>
<tr>
<td>Tupel<br/>in</td>
<td>n-mal</td>
<td>m-mal</td>
<td>min(n, m)-mal</td>
</tr>
</table>

</td>
</tr>
<tr>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>
<td class="topalign">$R \cap S$

</td>
</tr>
</table>

</td>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>

<td class="topalign">$R \cap S$

</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Durchschnitt $\cap$ 2/2

.more-more-condensed[
- $R \cap S = ${$ t | t \in R \wedge t \in S$}
- Hadoop MapReduce unterstützt in der Map-Phase das Lesen von mehreren Eingaben gleichzeitig
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $(t, "R")$ as key/value-pair
      - $\forall t \in S:$ Emit $(t, "S")$ as key/value-pair
  - Reduce
      - Mengensemantik:
           - for each fetched $(t, [a_1, ..., a_n])$ mit $ \exists i,j \in ${$1, ..., n$}:$ a_i="R" \wedge a_j="S":$ Emit $(t, t)$ as key/value-pair
      - Multimengensemantik:
           - for each fetched $(t, A)$ mit $A:=[a_1, ..., a_n]$:<br/>$r:=|${$a|a \in A \wedge a="R"$}$| \wedge s:=|${$a|a \in A \wedge a="S"$}$|$: $min(r,s)$-times Emit $(t, t)$ as key/value-pair
]

---

# Differenz $-$ 1/2

.more-more-condensed[
- $R - S = ${$ t | t \in R \wedge t \not\in S$}

<table class="small-font tablepadding">
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table class="result tablepadding textcenter">
<tr>
<th></th>
<th>$R$</th>
<th>$S$</th>
<th>$R - S$</th>
</tr>
<tr>
<td rowspan="4">Tupel<br/>in</td>
<td>✔</td>
<td></td>
<td>✔</td>
</tr>
<tr>
<td></td>
<td>✔</td>
<td></td>
</tr>
<tr>
<td>✔</td>
<td>✔</td>
<td></td>
</tr>
<tr>
<td> </td>
<td></td>
<td></td>
</tr>
</table>

</td>
<td class="topalign">

<table class="result tablepadding textcenter margin-bottom">
<tr>
<th></th>
<th>$R$</th>
<th>$S$</th>
<th>$R - S$</th>
</tr>
<tr>
<td>Tupel<br/>in</td>
<td>n-mal</td>
<td>m-mal</td>
<td>max(0, n-m)-mal</td>
</tr>
</table>
"Jedes Tupel $t$ in $S$ eliminiert ein $t$ in $R$"
</td>
</tr>
<tr>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>
<td class="topalign">$R - S$

<table class="result">
<tr>
<th>A</th>
<th>B</th>
</tr>
<tr>
<td>1</td>
<td>2</td>
</tr>
</table>
<br/>
$S - R$

</td>
</tr>
</table>

</td>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>

<td class="topalign">$R - S$

<br/>
$S - R$

</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Differenz $-$ 2/2

.more-more-condensed[
- $R - S = ${$ t | t \in R \wedge t \not\in S$}
- Hadoop MapReduce unterstützt in der Map-Phase das Lesen von mehreren Eingaben gleichzeitig
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $(t, "R")$ as key/value-pair
      - $\forall t \in S:$ Emit $(t, "S")$ as key/value-pair
  - Reduce
      - Mengensemantik:
           - for each fetched $(t, [a_1, ..., a_n])$ mit $ \exists i \in ${$1, ..., n$}:$ a_i="R" \wedge$<br/>$\nexists j \in ${$1, ..., n$}$: a_j="S":$ Emit $(t, t)$ as key/value-pair
      - Multimengensemantik ("Jedes Tupel $t$ in $S$ eliminiert ein $t$ in $R$"):
           - for each fetched $(t, A)$ mit $A:=[a_1, ..., a_n]$:<br/>$r:=|${$a|a \in A \wedge a="R"$}$| \wedge s:=|${$a|a \in A \wedge a="S"$}$|$: $max(r-s,0)$-times Emit $(t, t)$ as key/value-pair
]

---

# Kartesisches Produkt $\times$

.more-more-condensed[
<table>
<tr>
<td>

<table class="small-font result tablepadding margin-right">
<tr>
<th>$h(r)$ \ $h(s)$</th>
<th>$0$</th>
<th>$1$</th>
<th>...</th>
<th>$n-1$</th>
</tr>
<tr>
<th>$0$</th>
<td></td>
<th>$1$</th>
<td></td>
<td></td>
</tr>
<tr>
<th>$1$</th>
<th>$n$</th>
<th>$n+1$</th>
<th>...</th>
<th>$2\times n-1$</th>
</tr>
<tr>
<th>...</th>
<td></td>
<th>...</th>
<td></td>
<td></td>
</tr>
<tr>
<th>$n-1$</th>
<td></td>
<th>$(n-1)\times n+1$</th>
<td></td>
<td></td>
</tr>
</table>

</td>
<td width="37%">
.small-font22[Verteilungsschema für<br/>$r\in R$ mit $h(r)=1$ (Zeile 1)<br/>bzw. für $s\in S$ mit $h(s)=1$ (Spalte 1)]
</td>
</tr>
</table>
- MapReduce
  - Map
      - $\forall t \in R:\forall i \in ${$0,...,n-1$}: Emit $(h(t)\times n+i, (t,"R"))$
      - $\forall t \in S:\forall i \in ${$0,...,n-1$}: Emit $(h(t)+i\times n, (t,"S"))$
  - Reduce
      - Multi-/Mengensemantik:
           - for each fetched $(t, [a_1, ..., a_n])$<br/>mit $ \exists i,j \in ${$1, ..., n$}:$ a_i=(r,"R") \wedge a_j=(s,"S"):$<br/>Emit $(r \circ s, r \circ s)$ as key/value-pair
]

---

# Equi-Join $\bowtie$ 1/2

<table class="small-font tablepadding">
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>
<td class="topalign">$R \bowtie_{R.B=S.B} S$

</td>
</tr>
</table>

</td>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>

<td class="topalign">$R \bowtie_{R.B=S.B} S$

</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Equi-Join $\bowtie$ 2/2

.more-more-condensed[
- $R \bowtie_C S = \sigma_C(R \times S)$ mit $C$ ist Joinbedingung von der Form:
  - $r = s$ mit $r$ Attribut aus $R$ und $s$ Attribut aus $S$
  - $C_1 \wedge C_2$ mit $C_1$ und $C_2$ Joinbedingungen 
- MapReduce
  - Map ($C := r_1=s_1 \wedge ... \wedge r_n=s_n$)
      - $\forall t \in R:$ Emit $((t[r_1], ..., t[r_n]), ("R",t[1],...,t[|t|]))$ as key/value-pair
      - $\forall t \in S:$ Emit $((t[s_1], ..., t[s_n]), ("S",t[1],...,t[|t|]))$ as key/value-pair
  - Reduce
      - for each fetched $(j, A): \forall ("R", r[1],...,r[n])\in A:$<br/>$\forall ("S", s[1],...,s[m])\in A: t:=(r[1],...,r[n], s[1],...,s[m]):$<br/>Emit $(t, t)$ as key/value-pair
]

---

# Semi-Join $\ltimes$ 1/2

<table class="small-font tablepadding">
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>
<td class="topalign">$R \ltimes_{R.B=S.B} S$

</td>
</tr>
</table>

</td>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>

<td class="topalign">$R \ltimes_{R.B=S.B} S$

</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Semi-Join $\ltimes$ 2/2

.more-more-condensed[
- $R \ltimes_C S =\pi$<span class="small-font subscript">Attribute aus $R$</span>$(R \bowtie_C S)$ mit $C$ ist Joinbedingung von der Form:
  - $r = s$ mit $r$ Attribut aus $R$ und $s$ Attribut aus $S$
  - $C_1 \wedge C_2$ mit $C_1$ und $C_2$ Joinbedingungen 
- MapReduce
  - Map ($C := r_1=s_1 \wedge ... \wedge r_n=s_n$)
      - $\forall t \in R:$ Emit $((t[r_1], ..., t[r_n]), ("R",t[1],...,t[|t|]))$ as key/value-pair
      - $\forall t \in S:$ Emit $((t[s_1], ..., t[s_n]), ("S",t[1],...,t[|t|]))$ as key/value-pair
  - Reduce
      - for each fetched $(j, A): \forall ("R", r[1],...,r[n])\in A:$<br/>$\forall ("S", s[1],...,s[m])\in A:$ <span class="darkred bold">$t:=(r[1],...,r[n])$</span>:<br/>Emit $(t, t)$ as key/value-pair
      - Bei Mengensemantik nur $1 \times$ Versenden von $(t, t)$
]

---

# Äußere Joins ⟗, ⟕, ⟖ - 1/2

.more-more-condensed[
- „Ergebnis des Joins plus die Tupel aus einer Eingangsrelation ohne Joinpartner“
- $R$ ⟕ $S = (R - ( R \ltimes S )) $⨄$ (R \bowtie S)$
- $R$ ⟖ $S = (R \bowtie S) $⨄$ (S - ( S \ltimes R ))$
- $R$ ⟗ $S = (R - ( R \ltimes S )) $⨄$ (R \bowtie S) $⨄$ (S - ( S \ltimes R ))$

<table class="small-font tablepadding">
<tr>
<td class="bold darkblue">Mengensemantik</td>
<td class="bold darkblue">Multimengensemantik</td>
</tr>
<tr>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>
<td class="topalign">$R$ ⟗ $S$

</td>
</tr>
</table>

</td>
<td class="topalign">

<table>
<tr>
<td class="topalign">Bsp.:</td>
<td class="topalign">$R$

</td>
<td class="topalign">$S$

</td>

<td class="topalign">$R$ ⟗ $S$

</td>
</tr>
</table>

</td>
</tr>
</table>
]

---

# Äußere Joins ⟗, ⟕, ⟖ - 2/2

.more-more-condensed[
- MapReduce
  - Map ($C := r_1=s_1 \wedge ... \wedge r_n=s_n$)
      - $\forall t \in R:$ Emit $((t[r_1], ..., t[r_n]), ("R",t[1],...,t[|t|]))$ as key/value-pair
      - $\forall t \in S:$ Emit $((t[s_1], ..., t[s_n]), ("S",t[1],...,t[|t|]))$ as key/value-pair
  - Reduce
      - for each fetched $(j, A): \forall ("R", r[1],...,r[n])\in A:$<br/>$\forall ("S", s[1],...,s[m])\in A: t:=(r[1],...,r[n],s[1],...,s[m]):$<br/>Emit $(t, t)$ as key/value-pair
      - Voller (⟗) und Linker (⟕) äußerer Join: for each fetched $(j, A):$<br/>$\nexists ("S", s[1],...,s[m])\in A \wedge \forall ("R", r[1],...,r[n])\in A:$<br/>$t:=(r[1],...,r[n]):$ Emit $(t, t)$ as key/value-pair
      - Voller (⟗) und Rechter (⟖) äußerer Join: for each fetched $(j, A):$<br/>$\nexists ("R", r[1],...,r[n])\in A \wedge \forall ("S", s[1],...,s[m])\in A:$<br/>$t:=(s[1],...,s[m]):$ Emit $(t, t)$ as key/value-pair
]

---

# Gruppierung $\gamma$ 1/3

.more-more-condensed[
- Partitionierung der Tupel einer Relation (in „Gruppen“) gemäß ihrer Werte in einem oder mehreren Attributen
  - Hauptzweck: Aggregation auf den jeweiligen Gruppen
- $\gamma_{(F_1, ..., F_n)}(R)$, wobei $F_i$ von folgender Form ist:
  - ein Attribut von $R$ 
  - ein Ausdruck $X \rightarrow Y$, wobei $Y$ ein neuer Attributname ist, und $X$ von folgender Form:
      - ein Attribut von $R$
      - eine Aggregationsfunktion ($SUM$, $COUNT$, $AVG$, $MIN$, $MAX$, …) 
      - eine (verschachtelbare) Berechnungsvorschrift (arithmetische Formel, String-Operation, Klammern, …)
  - Ist kein $F_i$ angegeben, so ist ganz $R$ die (einzige) Gruppe
]

---

# Gruppierung $\gamma$ 2/3

.more-more-condensed[
- $\gamma_{(A_1, …, A_k, F_1, …, F_n)}(R)$, wobei $A_i$ Attribute aus $R$ sind und $F_i$ Zuweisungen von Ausdrücken der Form $X \rightarrow Y$ sind

Bestellung
<table class="result textcenter small-font margin-bottom tablepadding">
<tr>
<th><span class="underline">BestID</span></th>
<th>Datum</th>
<th>PID<br/>$\rightarrow$ Teil</th>
<th>KID<br/>$\rightarrow$ Kunde</th>
</tr>
<tr>
<td>1</td>
<td>2.1.18</td>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>2</td>
<td>3.1.18</td>
<td>12</td>
<td>15</td>
</tr>
<tr>
<td>3</td>
<td>4.1.18</td>
<td>10</td>
<td>14</td>
</tr>
</table>

$\gamma_{KID,COUNT(PID)\rightarrow NR, MAX(Datum)\rightarrow MaxDatum}(Bestellung)$
<table class="result textcenter small-font margin-bottom tablepadding">
<tr>
<th>KID</th>
<th>Nr</th>
<th>MaxDatum</th>
</tr>
<tr>
<td>14</td>
<td>2</td>
<td>4.1.18</td>
</tr>
<tr>
<td>15</td>
<td>1</td>
<td>3.1.18</td>
</tr>
</table>
]

---

# Gruppierung $\gamma$ 3/3

.more-more-condensed[
- $\gamma_{(A_1, …, A_k, F_1, …, F_n)}(R)$, wobei $A_i$ Attribute aus $R$ sind und $F_i$ Zuweisungen von Ausdrücken der Form $X \rightarrow Y$ sind
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $((t[A_1], …, t[A_k]), t)$ as key/value-pair
  - Reduce
      - for each fetched $((t[A_1], …, t[A_k]), [t_1, …, t_m]):$<br/>$t':=(t[A_1], …, t[A_k], F_1(t_1, …, t_m), …, F_n(t_1, …, t_m)):$<br/>Emit $(t', t')$ as key/value-pair
]

---

# Sortierung $\tau$ 1/2

.more-more-condensed[
- Ergebnis von $\tau_{A_1,…,A_k}(R)$ ist eine Liste von Tupeln aus $R$, die primär nach $A_1$, sekundär nach $A_2$ usw. sortiert ist
<table class="tablepadding">
<tr>
<td>

Bestellung
<table class="result textcenter small-font tablepadding">
<tr>
<th><span class="underline">BestID</span></th>
<th>Datum</th>
<th>PID<br/>$\rightarrow$ Teil</th>
<th>KID<br/>$\rightarrow$ Kunde</th>
</tr>
<tr>
<td>1</td>
<td>2.1.18</td>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>2</td>
<td>3.1.18</td>
<td>12</td>
<td>15</td>
</tr>
<tr>
<td>3</td>
<td>4.1.18</td>
<td>10</td>
<td>14</td>
</tr>
</table>

</td>
<td>

$\tau_{KID,Datum}$(Bestellung)
<table class="result textcenter small-font margin-bottom tablepadding">
<tr>
<th><span class="underline">BestID</span></th>
<th>Datum</th>
<th>PID<br/>$\rightarrow$ Teil</th>
<th>KID<br/>$\rightarrow$ Kunde</th>
</tr>
<tr>
<td>1</td>
<td>2.1.18</td>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>3</td>
<td>4.1.18</td>
<td>10</td>
<td>14</td>
</tr>
<tr>
<td>2</td>
<td>3.1.18</td>
<td>12</td>
<td>15</td>
</tr>
</table>

</td>
</tr>
</table>
- Wichtig: 
  - Ergebnis der Sortierung ist keine (Multi-)Menge, sondern eine Liste
  - Sortieroperation immer letzte Operation, da ansonsten wieder (Multi-) Mengen entstehen
  - In DBMS wird häufig auch zwischendurch sortiert (oder auf vorsortierte Eingaben aus einem Index zugegriffen), um optimierte Algorithmen anzuwenden, die sortierte Eingaben erfordern
]

---

# Sortierung $\tau$ 2/2

.more-more-condensed[
- Ergebnis von $\tau_{A_1,…,A_k}(R)$ ist eine Liste von Tupeln aus $R$, die primär nach $A_1$, sekundär nach $A_2$ usw. sortiert ist
- MapReduce
  - Map
      - $\forall t \in R:$ Emit $((t[A_1], …, t[A_k]), t)$ as key/value-pair
  - Reduce
      - MapReduce ordnet die Reducer nach der Ordnung der Schlüssel der Eingabe, d.h. Reducer $i$ erhält nur Schlüssel-Wert-Paare, deren Schlüssel kleiner sind als die von Reducer $i+1$
]

---

<board-exercise></board-exercise>

# .darkblue[SPARQL-Anfrage in der Cloud]

- .darkblue[Welche Map- und Reduce-Phasen] sind notwendig zum Verarbeiten folgender<br/>SPARQL-Anfrage.darkblue[?]

<table class="fullwidth">
<tr>
<td style="width:50%">
.small-font24[
```sparql11
PREFIX …
SELECT ?person ?name
WHERE {
  ?article rdf:type bench:Article .
  ?article dc:creator ?person .
  ?person  foaf:name  ?name .
}
ORDER BY ?name
```
]
</td>
<td class="center">
<div class="inline-block">
<div class="round-border blue-border small-font darkblue padding-left padding-right">.bold[Annahme:]<br/>Durch geschickte Verwendung<br/>von Indexen können die<br/>Ergebnisse der Tripelmuster<br/>mit einem Indexzugriff erfolgen.</div>
</div>
</td>
</tr>
</table>

---

# Zusammenfassung

.condensed[
- Relationale Algebra als Basis von vielen Anfragesprachen
- Operatoren der Relationalen Algebra als Map/Reduce-Jobs ausführbar
- Komplexe Anfragen erfordern Hintereinanderschaltung mehrerer Map/Reduce-Jobs
]