chore: add orm

Author: chrootlogin

docs/9_orm/0_intro.md

@@ -0,0 +1,32 @@
+# Object-Relational Mapping (ORM)
+
+Die meisten modernen Anwendungen sind objektorientiert aufgebaut, während die Daten in relationalen Datenbanken gespeichert werden. Diese grundlegende Diskrepanz zwischen objektorientierter Programmierung und relationalen Datenbanken - bekannt als "Object-Relational Impedance Mismatch" - stellt Entwickler vor eine besondere Herausforderung: Wie überbrückt man die konzeptionelle Lücke zwischen Objekten in der Anwendung und Tabellen in der Datenbank effizient?
+
+Object-Relational Mapping (ORM) ist die Antwort auf diese Herausforderung. ORMs bieten eine Abstraktionsschicht zwischen dem Anwendungscode und der relationalen Datenbank, die es ermöglicht, mit Daten in Form von Objekten zu arbeiten, anstatt SQL-Abfragen manuell zu schreiben.
+
+:::{important} Lernziele
+Nach Abschluss dieses Kapitels wirst du:
+- Das Konzept und die Grundprinzipien von Object-Relational Mapping verstehen
+- Die Vor- und Nachteile von ORMs im Vergleich zu direktem SQL-Zugriff beurteilen können
+- Grundlegende Mapping-Strategien zwischen Objekten und Datenbanktabellen kennen
+- Die Rolle von ORM-Frameworks in modernen Anwendungen einordnen können
+- Die Bedeutung von Schemaversionierung in datenbankbasierten Anwendungen erfassen
+- Wissen, wann ORMs an ihre Grenzen stossen und direktes SQL die bessere Wahl ist
+:::
+
+## Warum sind ORMs für Entwickler relevant?
+
+Als Softwareentwickler stehst du häufig vor der Herausforderung, deine objektorientierten Anwendungen mit relationalen Datenbanken zu verbinden. Ohne geeignete Abstraktionen müsstest du:
+
+- SQL-Abfragen manuell schreiben und in deinen Code einbetten
+- Die Ergebnisse dieser Abfragen selbst in Objekte umwandeln
+- Änderungen an Objekten zurück in SQL-UPDATE-Anweisungen transformieren
+- Beziehungen zwischen Objekten manuell durch JOINs oder mehrere Abfragen abbilden
+
+Dieser Ansatz ist fehleranfällig und erhöht den Wartungsaufwand erheblich. Jede Änderung am Datenbankschema erfordert entsprechende Anpassungen im Code, und das Management komplexer Beziehungen zwischen Objekten wird schnell unübersichtlich.
+
+Object-Relational Mapper lösen diese Probleme, indem sie eine strukturierte Brücke zwischen der objektorientierten und der relationalen Welt schaffen. Sie ermöglichen es dir, dich auf die Geschäftslogik deiner Anwendung zu konzentrieren, während sich das ORM um die Datenpersistenz kümmert.
+
+In diesem Kapitel werden wir die grundlegenden Konzepte und Prinzipien von ORMs betrachten und anhand von repräsentativen Beispielen aus Java und Python veranschaulichen. Du wirst lernen, wann der Einsatz eines ORMs sinnvoll ist und wann du besser auf direktes SQL zurückgreifen solltest.
+
+Besonders wichtig wird dabei die Betrachtung der Schemaversionierung sein - ein oft übersehener, aber kritischer Aspekt in der professionellen Softwareentwicklung mit Datenbanken. Wir werden erklären, warum eine kontrollierte Verwaltung von Datenbankschemas in professionellen Umgebungen dem automatischen Schema-Management durch ORMs vorzuziehen ist.

docs/9_orm/1_orm_basics.md

@@ -0,0 +1,170 @@
+# Grundlagen des Object-Relational Mappings
+
+Object-Relational Mapping (ORM) ist ein Programmierparadigma, das die Lücke zwischen objektorientierter Programmierung und relationalen Datenbanken überbrückt. In diesem Kapitel betrachten wir die grundlegenden Konzepte und Mechanismen, die ORMs verwenden, um eine nahtlose Integration zwischen diesen beiden Welten zu ermöglichen.
+
+## Die konzeptionelle Herausforderung
+
+```mermaid
+flowchart LR
+    subgraph "Objektorientierte Welt"
+        A[Klassen] --- B[Vererbung]
+        B --- C[Polymorphismus]
+        A --- D[Objekte mit Methoden]
+        D --- E[Objektreferenzen]
+    end
+    
+    subgraph "Relationale Welt"
+        F[Tabellen] --- G[Spalten/Datentypen]
+        G --- H[Constraints]
+        F --- I[Zeilen mit Werten]
+        I --- J[Fremdschlüssel]
+    end
+    
+    K[ORM] --- A
+    K --- F
+```
+
+Die obige Abbildung veranschaulicht den fundamentalen Unterschied zwischen objektorientierter Programmierung und relationalen Datenbanken. Objektorientierte Programmierung basiert auf Klassen, Vererbung und Objektreferenzen, während relationale Datenbanken auf Tabellen, Zeilen und Fremdschlüsselbeziehungen aufbauen. Diese unterschiedlichen Paradigmen führen zu mehreren Herausforderungen:
+
+1. **Strukturelle Unterschiede**: Objekte können komplexe Vererbungshierarchien haben, während Tabellen flach strukturiert sind.
+2. **Identitätskonzepte**: In der objektorientierten Welt hat jedes Objekt eine eigene Identität, während in relationalen Datenbanken die Identität durch Primärschlüssel definiert wird.
+3. **Beziehungsdarstellung**: Objekte verwenden Referenzen für Beziehungen, relationale Datenbanken nutzen Fremdschlüssel und JOINs.
+4. **Datentypen**: Programmiersprachen und Datenbanken haben unterschiedliche Typsysteme.
+5. **Verhalten**: Objekte beinhalten sowohl Daten als auch Verhalten (Methoden), während Tabellen nur Daten speichern.
+
+ORMs versuchen, diese Unterschiede zu überbrücken und eine konsistente Programmierumgebung zu schaffen, in der Entwickler hauptsächlich mit Objekten arbeiten können.
+
+## Kernkomponenten eines ORM-Systems
+
+Ein typisches ORM-System besteht aus mehreren Schlüsselkomponenten:
+
+### 1. Entity-Mapping
+
+Das Entity-Mapping bildet Klassen auf Datenbanktabellen ab. In den meisten ORM-Frameworks geschieht dies durch Annotationen oder Konfigurationsdateien.
+
+**Beispiel für Entity-Mapping:**
+
+```java
+// Java mit JPA
+@Entity
+@Table(name = "mitglieder")
+public class Mitglied {
+    @Id
+    private Long id;
+    
+    @Column(name = "nachname")
+    private String nachname;
+    
+    // Weitere Eigenschaften...
+}
+```
+
+```python
+# Python mit SQLAlchemy
+class Mitglied(Base):
+    __tablename__ = 'mitglieder'
+    
+    id = Column(Integer, primary_key=True)
+    nachname = Column(String)
+    # Weitere Eigenschaften...
+```
+
+### 2. Beziehungs-Mapping
+
+ORMs bieten Mechanismen, um verschiedene Arten von Beziehungen zwischen Entitäten abzubilden:
+
+**Beispiele für Beziehungs-Mapping:**
+
+```java
+// Java: One-to-Many Beziehung
+@Entity
+public class Verein {
+    // ...
+    @OneToMany(mappedBy = "verein")
+    private List<Mitglied> mitglieder;
+}
+
+@Entity
+public class Mitglied {
+    // ...
+    @ManyToOne
+    @JoinColumn(name = "verein_id")
+    private Verein verein;
+}
+```
+
+```python
+# Python: Many-to-Many Beziehung
+mitglied_veranstaltung = Table(
+    'mitglied_veranstaltung',
+    Base.metadata,
+    Column('mitglied_id', Integer, ForeignKey('mitglieder.id')),
+    Column('veranstaltung_id', Integer, ForeignKey('veranstaltungen.id'))
+)
+
+class Mitglied(Base):
+    # ...
+    veranstaltungen = relationship("Veranstaltung", secondary=mitglied_veranstaltung)
+```
+
+### 3. Object-Relational-Mapping-Lebenszyklus
+
+ORMs verwalten den Lebenszyklus von Entitäten durch verschiedene Zustände:
+
+```mermaid
+stateDiagram-v2
+    [*] --> Transient: Neues Objekt erstellt
+    Transient --> Persistent: persist()/save()
+    Persistent --> Detached: close()/clear()
+    Detached --> Persistent: merge()/update()
+    Persistent --> Removed: remove()/delete()
+    Removed --> [*]
+    Detached --> [*]: Garbage Collection
+```
+
+1. **Transient**: Ein neues Objekt, das nicht mit einer Datenbankzeile verbunden ist
+2. **Persistent**: Ein Objekt, das einer Datenbankzeile zugeordnet ist und vom ORM verwaltet wird
+3. **Detached**: Ein Objekt, das einer Datenbankzeile zugeordnet war, aber nicht mehr vom ORM verwaltet wird
+4. **Removed**: Ein Objekt, das zum Löschen markiert wurde
+
+### 4. Lazy Loading vs. Eager Loading
+
+Ein wichtiges Konzept in ORMs ist die Ladestrategie für Beziehungen:
+
+- **Lazy Loading**: Beziehungen werden erst geladen, wenn explizit auf sie zugegriffen wird
+  ```java
+  // Lazy Loading (Standard in den meisten ORM-Frameworks)
+  @OneToMany(mappedBy = "verein", fetch = FetchType.LAZY)
+  private List<Mitglied> mitglieder;
+  ```
+
+- **Eager Loading**: Beziehungen werden sofort geladen, wenn das Hauptobjekt geladen wird
+
+Die Wahl der richtigen Ladestrategie ist entscheidend für die Performance der Anwendung. Lazy Loading reduziert den initialen Ladeaufwand, kann aber zu dem "N+1-Problem" führen, wenn in einer Schleife auf viele beziehungsgebundene Objekte zugegriffen wird.
+
+## Abfragesprachen von ORMs
+
+ORMs bieten in der Regel eigene Abfragesprachen, die objektorientierten Zugriff auf die Datenbank ermöglichen:
+
+Die ORMs bieten verschiedene Abfragesprachen, die objektorientiert sind und eine Alternative zu direktem SQL darstellen:
+
+```java
+// JPQL in Java
+TypedQuery<Mitglied> query = entityManager.createQuery(
+    "SELECT m FROM Mitglied m WHERE m.nachname = :nachname", Mitglied.class);
+query.setParameter("nachname", "Müller");
+List<Mitglied> results = query.getResultList();
+```
+
+```python
+# Method Chaining in SQLAlchemy
+session.query(Mitglied).filter(Mitglied.nachname == "Müller").all()
+```
+
+Diese spezifischen Abfragesprachen ermöglichen es, komplexe Datenbankoperationen in einer objektorientierten Weise auszudrücken, die sich natürlicher in den Programmcode einfügt.
+
+## Fazit
+
+Die Grundlagen des Object-Relational Mappings umfassen Entity-Mapping, Beziehungs-Mapping, den Entitäts-Lebenszyklus und spezielle Abfragesprachen. Diese Konzepte bilden das Fundament für den effizienten Einsatz von ORMs in Anwendungen.
+
+Im nächsten Kapitel werden wir die Vor- und Nachteile von ORMs genauer betrachten und diskutieren, wann ihr Einsatz sinnvoll ist und wann möglicherweise direktes SQL die bessere Alternative darstellt.