====== LU04b - Die Crow’s-Foot-Notation ======

{{:modul:m290_guko:learningunits:lu04:theorie:daniel-shapiro-d-vbdk5rqr0-unsplash_converted_medium.jpg?nolink&400|}}

„Crow’s Foot“ bedeutet übersetzt **Krähenfuss**. Der Name kommt vom Symbol für //many// (viele), das wie ein kleiner Krähenfuss aussieht.  {{:modul:m290_guko:learningunits:lu04:theorie:crows_foot.png?nolink&50|}}

Die **Crow’s-Foot-Notation** stellt eine Datenbank so dar, dass man sofort erkennt:  
  * wie **Entitäten** (Tabellen) miteinander verknüpft sind,  
  * wie viele Objekte (Instanzen) einer Entität mit wie vielen Objekten einer anderen verbunden sein können (= **Kardinalität**),  
  * welche **Primärschlüssel (PK)** und **Fremdschlüssel (FK)** definiert sind,  
  * welche **Attribute** zu einer Tabelle gehören (auf Wunsch auch mit Datentypen).  

Damit kann die Crow’s-Foot-Notation Teil eines **logischen Datenbankschemas** sein und bildet die Brücke von der Analyse (Chen-Notation) zur technischen Umsetzung in SQL.  



==== Kardinalitäten in der Crow’s-Foot-Notation ====
Die **Kardinalität** beschreibt die Art der Beziehung zwischen zwei Entitäten. Es gibt drei Haupttypen:  

1. **One-to-One (1:1)**  
Eine Instanz von Entität A gehört genau zu einer Instanz von Entität B.  

Beispiel:  
  * Ein:e Mitarbeitende ↔ genau ein Arbeitsplatz  
  * Jeder Reisepass ↔ genau eine Person  

Darstellung: Linie mit kurzem Strich auf beiden Seiten.

{{:modul:m290_guko:learningunits:lu04:theorie:one-to-one.png?nolink&400|One-to-One Beziehung}}
//One-to-One (1:1) Beziehung: __Ein__ Auto kann (gleichzeitig) immer nur __einen__ Fahrer, __eine__ Fahrerin haben. __Eine__ Fahrerin, __ein__ Fahrer kann (gleichzeitig) nur immer __Ein__ Auto fahren.//


2. **One-to-Many (1:N)**  
Eine Instanz von Entität A kann mit vielen Instanzen von Entität B verbunden sein.  
Umgekehrt gehört jede Instanz von B zu genau einer Instanz von A.  

Beispiel:  
  * Ein Regisseur ↔ viele Filme  
  * Ein Spotify-Artist ↔ viele Songs  
  * Eine Klasse ↔ viele Lernende  

Darstellung: Linie mit Strich (= „eins“) auf Seite A und einem „Krähenfuss“ (drei Linien) auf Seite B.

{{:modul:m290_guko:learningunits:lu04:theorie:one-to-many.png?nolink&400|One-to-Many Beziehung}}
//One-to-Many (1:n) Beziehung: __Ein__ Regisseur, __eine__ Regisseurin kann __mehrere__ Filme drehen. __Ein__ Film wird (in der Regel) nur von __einem__ Regisseur, __einer__ Regisseurin gedreht. //



3. **Many-to-Many (M:N)**  
Mehrere Instanzen von Entität A können mit mehreren Instanzen von Entität B verknüpft sein.  

Beispiel:  
  * Mehrere Schauspieler:innen ↔ spielen in mehreren Filmen  
  * Viele Lernende ↔ besuchen mehrere Module  
  * Viele Songs ↔ sind in mehreren Playlists enthalten  

Darstellung: Krähenfüsse auf beiden Seiten der Beziehung.

{{:modul:m290_guko:learningunits:lu04:theorie:many-to-many.png?nolink&400|Many-to-Many Beziehung}}
//Many-to-Many (n:m) Beziehung: __Ein:e__ Schauspieler:in kann in __mehreren__ Filme spielen. __Ein__ Film kann __mehrere__ Schauspieler:innen haben. //


Die folgende Abbildung zeigt alle möglichen Kardinalitäten:  

{{:modul:m290:learningunits:lu03:theorie:crow-notation-chart-4127045304.png?300|Alle möglichen Kardinalitäten in der Crow’s-Foot-Notation}}



==== Warum Crow’s-Foot-Notation? ====
Die **Crow’s-Foot-Notation** wird oft in der Praxis eingesetzt, weil sie eine **klare und technische Darstellung** bietet.  

Im Unterschied zur Chen-Notation, die eher **fachlich und abstrakt** ist, dient Crow’s-Foot als **Brücke zur Umsetzung in SQL**:  
  * Sie zeigt **Entitäten als Tabellen** mit ihren Attributen.  
  * Sie markiert **Primärschlüssel (PK)** und **Fremdschlüssel (FK)**.  
  * Sie stellt **Beziehungen und Kardinalitäten** (1:1, 1:n, n:m) deutlich dar. 
  * Es können auch die Datentypen der Attribute (Spalten) vermerkt werden. 

Damit ist sie die **letzte Station vor der praktischen Umsetzung** mit SQL-Befehlen wie //CREATE TABLE …//.  

Crow’s-Foot wird also vor allem von **Entwickler:innen, Datenbank-Designer:innen und Lernenden** genutzt, die den Schritt von der Analyse (Chen) zur technischen Umsetzung (SQL) machen.  



==== Beispiel Crow’s-Foot-Notation ====
Stellen wir uns einen **Online-Buchshop** vor. Wir haben die Entitäten:  

  * **Kunde**  
  * **Bestellung**  
  * **Produkt**  

Beziehungen:  
  * Ein Kunde kann viele Bestellungen aufgeben (1:N).  
  * Eine Bestellung kann mehrere Produkte enthalten, und ein Produkt kann in vielen Bestellungen vorkommen (M:N).  

{{:modul:m290_guko:learningunits:lu04:theorie:bestellung_crows_feet.drawio_1_.png?direct&600|}}

Darstellung in Crow’s-Foot-Notation:  
  * Linie zwischen Kunde und Bestellung, mit Strich (1) auf der Kundenseite und Krähenfuss (N) auf der Bestellungsseite.  
  * Linie zwischen Bestellung und Produkt mit Krähenfuss auf beiden Seiten.  


===== Beispiel: Vom Schema zur Tabelle =====

Ausgangspunkt ist ein kleines **Crow’s Foot Schema**:  
{{:modul:m290_guko:learningunits:lu04:theorie:film_regisseur_crowsfoot.drawio_1_.png?direct&600|}}

  * **Regisseur** (RegisseurID **PK**, Name)  
  * **Film** (FilmID **PK**, Titel, Jahr, RegisseurID **FK**)  
  * Beziehung: **1 Regisseur ↔ n Filme**  



==== Umsetzung in SQL ====

**1. Datenbank anlegen**
<WRAP center box round 80%>
<code sql>
CREATE DATABASE filmdatenbank;
USE filmdatenbank;
</code>
</WRAP>

**2. Tabelle "regisseur" anlegen**
<WRAP center box round 80%>
<code sql>
CREATE TABLE regisseur (
  regisseur_id INT AUTO_INCREMENT,
  name VARCHAR(50) NOT NULL,
  birthday DATE,
  PRIMARY KEY (regisseur_id)
);
</code>
</WRAP>
**3. Tabelle "film" anlegen**
<WRAP center box round 80%>
<code sql>
CREATE TABLE film (
  film_id INT AUTO_INCREMENT,
  titel VARCHAR(50) NOT NULL,
  jahr YEAR,
  regisseur_id INT,
  PRIMARY KEY (film_id),
  FOREIGN KEY (regisseur_id) REFERENCES regisseur(regisseur_id)
);
</code>
</WRAP>
**4. Daten einfügen**

Fügen Sie mit Webstorm manuell (Tabelle anklicken und dann -> "Edit Data" (Tabellen-Icon)) ein paar Daten in die beiden Tabellen. Sie können zur Inspiration Daten aus der Tabelle //imbd_top_1000// verwenden, welche wir zu einem früheren Zeitpunkt bereits importiert haben.

**5. Daten abfragen**

Mit einem Select können wir beide Tabellen gleichzeitig abfragen:
<WRAP center box round 80%>
<code sql>
SELECT f.titel, f.jahr, r.name AS regisseur
FROM film f, regisseur r
WHERE f.regisseur_id = r.regisseur_id;

</code>
</WRAP>

Was zu einem ähnlichen Ergebnis, wie hier führen könnte:
<WRAP center box round 80%>
^ Titel               ^ Jahr ^ Regisseur         ^
| Inception           | 2010 | Christopher Nolan |
| Lost in Translation | 2003 | Sofia Coppola     |

</WRAP>

----
[[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]]