Datenbanken - Praktische Umsetzung

Question:
# Prüfungskern
Was ist der typische Lösungsweg für praktische Datenbankaufgaben?

Answer:
1. **Schema verstehen:** Tabellen, Attribute, Primär- und Fremdschlüssel erkennen.
2. **Integrität prüfen:** `NOT NULL`, `UNIQUE`, `CHECK`, `FOREIGN KEY` und Referenzaktionen beachten.
3. **Passenden SQL-Befehl wählen:** DDL, DML, DQL, DCL oder TCL.
4. **Bedingungen sauber setzen:** besonders `WHERE`, `JOIN ... ON`, `GROUP BY`, `HAVING`.
5. **Nebenwirkungen prüfen:** Transaktion, Sperren, Constraints, Performance, NoSQL-Abgrenzung.


Datenbanken - Praktische Umsetzung

Question:
# Daten, Information, Wissen
Wie unterscheiden sich Daten, Information und Wissen?

Answer:
- **Daten:** rohe Zeichen/Werte ohne Kontext, z. B. `42`.
- **Information:** Daten mit Bedeutung/Kontext, z. B. `42 offene Bestellungen`.
- **Wissen:** interpretierte Information plus Erfahrung/Regeln, z. B. `42 offene Bestellungen sind SLA-kritisch`.

Prüfungsfalle: Nicht jeden gespeicherten Wert automatisch als Wissen bezeichnen.


Datenbanken - Praktische Umsetzung

Question:
# Datenbank, DBMS, Datenbanksystem
Was ist der Unterschied?

Answer:
- **Datenbank:** logisch zusammengehörender Datenbestand inklusive Metadaten.
- **DBMS:** Software zum Definieren, Speichern, Abfragen, Sichern und Verwalten der Daten.
- **Datenbanksystem:** Datenbank + DBMS + Anwendungskontext/Nutzer/Hardware.

Beispiel: PostgreSQL als DBMS, konkrete Kundendatenbank als Datenbank.


Datenbanken - Praktische Umsetzung

Question:
# DBMS-Anforderungen
Welche zentralen Aufgaben übernimmt ein DBMS?

Answer:
Ein DBMS übernimmt typischerweise:

- Datenbanksprachen: DDL, DML/DQL, DCL, TCL
- Zugriffskontrolle und Autorisierung
- Integritätssicherung
- Recovery nach Fehlern
- Mehrbenutzer-Synchronisation
- Optimierung und effizienter physischer Zugriff

Kernidee: Anwendungen sollen nicht direkt auf physischen Dateien arbeiten.

Skript Einführung S. 11; Zusammenfassung §2.2


Datenbanken - Praktische Umsetzung

Question:
# SQL-Sprachklassen
Wofür stehen DDL, DML, DQL, DCL und TCL?

Answer:
| Klasse | Zweck | Beispiele |
|---|---|---|
| DDL | Strukturen definieren/ändern | `CREATE`, `ALTER`, `DROP` |
| DML | Daten ändern | `INSERT`, `UPDATE`, `DELETE` |
| DQL | Daten abfragen | `SELECT` |
| DCL | Rechte steuern | `GRANT`, `REVOKE` |
| TCL | Transaktionen steuern | `COMMIT`, `ROLLBACK` |

Prüfungsfalle: `CREATE` fügt keine Nutzdaten ein.


Datenbanken - Praktische Umsetzung

Question:
# ANSI-SPARC
Welche drei Ebenen beschreibt die ANSI-SPARC-Architektur?

Answer:
1. **Externe Ebene:** Benutzersichten, z. B. Views oder Anwendungsausschnitte.
2. **Konzeptionelle Ebene:** logisches Gesamtschema.
3. **Interne Ebene:** physische Speicherung, Indexe, Zugriffspfade.

Ziel: **Datenunabhängigkeit**. Änderungen unten sollen möglichst wenig Auswirkungen oben haben.


Datenbanken - Praktische Umsetzung

Question:
# Relationales Modell
Wie werden Tabellen formal verstanden?

Answer:
Eine Tabelle ist eine **Relation**:

- Spalten = Attribute
- Zeilen = Tupel/Datensätze
- Domänen = zulässige Wertebereiche
- Ergebnis relationaler Operationen ist wieder eine Relation

Typische Operatoren: Selektion $\sigma$, Projektion $\pi$, Verbund $R \bowtie S$.


Datenbanken - Praktische Umsetzung

Question:
# Primärschlüssel vs Fremdschlüssel
Wie unterscheiden sie sich?

Answer:
- **Primärschlüssel (`PRIMARY KEY`):** identifiziert jede Zeile eindeutig; impliziert `UNIQUE` und `NOT NULL`.
- **Fremdschlüssel (`FOREIGN KEY`):** verweist auf einen Schlüssel einer anderen oder derselben Tabelle.

Prüfungsfalle: Ein Fremdschlüssel ist nicht automatisch eindeutig. Viele Kindzeilen dürfen auf denselben Elternsatz zeigen.


Datenbanken - Praktische Umsetzung

Question:
# PostgreSQL
Warum eignet sich PostgreSQL als Kursdatenbank?

Answer:
PostgreSQL ist:

- frei und quelloffen
- nah am SQL-Standard
- ACID-konform, auch bei vielen DDL-Operationen
- stark erweiterbar: Typen, Funktionen, Operatoren, PL/pgSQL, JSON/JSONB
- praktisch geeignet für SQL, Transaktionen, Trigger und NoSQL-nahe Erweiterungen


Datenbanken - Praktische Umsetzung

Question:
# DBeaver
Welche Rolle spielt DBeaver in der Vorlesung?

Answer:
DBeaver ist ein plattformunabhängiger Datenbankclient mit SQL-Editor, Syntax-Highlighting, Autovervollständigung, Import/Export und Schema-Visualisierung.

Prüfungsfalle: Die Visualisierung wird oft als ER-Modell bezeichnet, zeigt praktisch aber meist das **Relationenschema** mit Tabellen und Fremdschlüsseln.


Datenbanken - Praktische Umsetzung

Question:
# SQL-Konventionen
Welche Schreibkonventionen sind wichtig?

Answer:
- SQL-Schlüsselwörter groß schreiben: `SELECT`, `FROM`, `WHERE`.
- Nicht gequotete PostgreSQL-Bezeichner werden klein normalisiert.
- Quoted identifiers wie `"CustomerID"` sind case-sensitive.
- Konkrete Spalten besser explizit nennen statt `SELECT *`.

SQL ist deklarativ: Es beschreibt **was** geliefert werden soll, nicht **wie** der Zugriff technisch erfolgt.


Datenbanken - Praktische Umsetzung

Question:
# SELECT *
Warum ist `SELECT *` in Klausurantworten riskant?

Answer:
`SELECT *` ist bequem, aber unpräzise:

- gibt alle Spalten zurück, auch unerwünschte
- macht Ergebnis abhängig von Schemaänderungen
- kann bei Joins doppelte/mehrdeutige Spalten liefern
- zeigt nicht, ob die geforderte Projektion verstanden wurde

Wenn konkrete Attribute gefragt sind: explizit projizieren.


Datenbanken - Praktische Umsetzung

Question:
# CREATE TABLE
Wie sieht ein typisches `CREATE TABLE` mit Constraints aus?

Answer:
```sql
CREATE TABLE album (
  album_id INTEGER PRIMARY KEY,
  title VARCHAR(160) NOT NULL,
  artist_id INTEGER NOT NULL,
  CONSTRAINT fk_album_artist
    FOREIGN KEY (artist_id)
    REFERENCES artist(artist_id)
);
```

Wichtig: Datentypen, `NOT NULL`, Primärschlüssel und Fremdschlüssel vollständig notieren.

Zusammenfassung §4.1; Übungsklausur Typ DDL


Datenbanken - Praktische Umsetzung

Question:
# PostgreSQL-Datentypen
Welche Datentypen sind klausurrelevant?

Answer:
Typische Datentypen:

- Zahlen: `INTEGER`, `BIGINT`, `NUMERIC(p, s)`, `REAL`, `DOUBLE PRECISION`
- Text: `CHAR(n)`, `VARCHAR(n)`, `TEXT`
- Zeit: `DATE`, `TIME`, `TIMESTAMP`
- Boolean: `BOOLEAN`
- Automatische IDs: `SERIAL` oder standardnäher `GENERATED ... AS IDENTITY`

Prüfungsfalle: `SERIAL` ist PostgreSQL-praktisch, aber kein echter Standard-SQL-Typ.


Datenbanken - Praktische Umsetzung

Question:
# NULL
Was bedeutet `NULL` in SQL?

Answer:
`NULL` bedeutet **unbekannt, nicht vorhanden oder nicht anwendbar**. Es ist kein leerer String und nicht die Zahl `0`.

Regeln:

- Vergleich mit `=` funktioniert nicht: nutze `IS NULL` / `IS NOT NULL`.
- Viele Aggregatfunktionen ignorieren `NULL`.
- `COUNT(*)` zählt Zeilen, `COUNT(spalte)` zählt nur Nicht-NULL-Werte.

Zusammenfassung §6.3-6.4; SQL Teil 2 S. 69


Datenbanken - Praktische Umsetzung

Question:
# Constraints
Welche Integritätsbedingungen solltest du bei DDL-Aufgaben prüfen?

Answer:
- `PRIMARY KEY`: eindeutige, nicht-leere Identifikation
- `FOREIGN KEY`: referentielle Integrität
- `UNIQUE`: Eindeutigkeit ohne Primärschlüsselrolle
- `NOT NULL`: Pflichtfeld
- `CHECK`: fachliche Bedingung, z. B. `price >= 0`
- `DEFAULT`: Standardwert beim Einfügen

Klausurtechnik: Erst Relationenschema lesen, dann jede Bedingung explizit in SQL übersetzen.


Datenbanken - Praktische Umsetzung

Question:
# PRIMARY KEY vs UNIQUE
Wie unterscheiden sich `PRIMARY KEY` und `UNIQUE`?

Answer:
- `PRIMARY KEY` identifiziert die Zeile zentral und erlaubt keine `NULL`-Werte.
- `UNIQUE` verhindert doppelte Werte, ist aber nicht der primäre Identifikator.
- Eine Tabelle hat höchstens einen Primärschlüssel, aber mehrere `UNIQUE`-Constraints.

PostgreSQL-Hinweis: `UNIQUE` erlaubt bei `NULL` typischerweise mehrere `NULL`-Einträge, weil `NULL` unbekannt ist.


Datenbanken - Praktische Umsetzung

Question:
# Fremdschlüssel-Aktionen
Was bedeuten `CASCADE`, `RESTRICT` und `SET NULL`?

Answer:
- `ON DELETE CASCADE`: Löschen des Elternsatzes löscht abhängige Kindzeilen mit.
- `ON DELETE RESTRICT` / `NO ACTION`: Löschen wird verhindert, solange Kindzeilen existieren.
- `ON DELETE SET NULL`: Fremdschlüssel in Kindzeilen wird auf `NULL` gesetzt.

Prüfungsfalle: `SET NULL` passt nur, wenn die FK-Spalte `NULL` erlauben darf.


Datenbanken - Praktische Umsetzung

Question:
# Referentielle Integrität
Was stellt sie sicher?

Answer:
Referentielle Integrität stellt sicher, dass ein Fremdschlüsselwert auf einen existierenden Datensatz der referenzierten Tabelle verweist.

```sql
FOREIGN KEY (artist_id) REFERENCES artist(artist_id)
```

Dann darf `album.artist_id` nur Werte enthalten, die in `artist.artist_id` existieren - außer die Spalte erlaubt `NULL`.


Datenbanken - Praktische Umsetzung

Question:
# ALTER TABLE
Wofür nutzt man `ALTER TABLE`?

Answer:
`ALTER TABLE` ändert bestehende Tabellenstrukturen:

```sql
ALTER TABLE album ADD COLUMN release_year INTEGER;
ALTER TABLE album DROP COLUMN release_year;
ALTER TABLE album ADD CONSTRAINT chk_year CHECK (release_year >= 1900);
```

Klausurpunkt: `ALTER` ändert Struktur, `UPDATE` ändert Daten.


Datenbanken - Praktische Umsetzung

Question:
# DROP und CASCADE
Was ist bei `DROP ... CASCADE` zu beachten?

Answer:
`DROP` löscht Datenbankobjekte. Mit `CASCADE` werden abhängige Objekte mitgelöscht.

```sql
DROP TABLE artist CASCADE;
```

Das kann abhängige Fremdschlüssel, Views oder weitere Objekte betreffen. Nur verwenden, wenn Abhängigkeiten wirklich mit entfernt werden sollen.


Datenbanken - Praktische Umsetzung

Question:
# INSERT
Wie schreibt man ein robustes `INSERT`?

Answer:
```sql
INSERT INTO genre (genre_id, name)
VALUES (1, 'Rock');
```

Robust, weil die Spaltenliste explizit ist. Ohne Spaltenliste müssen Anzahl, Reihenfolge und Typen exakt zur Tabelle passen.


Datenbanken - Praktische Umsetzung

Question:
# INSERT SELECT
Wann verwendet man `INSERT ... SELECT`?

Answer:
Wenn Daten aus einer Abfrage in eine Tabelle übernommen werden sollen:

```sql
INSERT INTO premium_customer (customer_id, name)
SELECT customer_id, name
FROM customer
WHERE total_revenue > 1000;
```

Die ausgewählten Spalten müssen zur Zieltabelle passen: Anzahl, Reihenfolge und kompatible Datentypen.


Datenbanken - Praktische Umsetzung

Question:
# UPDATE
Was ist die wichtigste Prüfungsfalle bei `UPDATE`?

Answer:
Eine fehlende oder falsche `WHERE`-Klausel ändert zu viele Zeilen.

```sql
UPDATE track
SET unit_price = unit_price * 1.10
WHERE genre_id = 1;
```

Ohne `WHERE` würden alle Tracks geändert. Bei DML immer prüfen: **Welche Zeilen sind betroffen?**


Datenbanken - Praktische Umsetzung

Question:
# DELETE vs TRUNCATE
Wie unterscheiden sie sich?

Answer:
- `DELETE FROM t WHERE ...`: löscht ausgewählte Zeilen, kann gefiltert werden.
- `DELETE FROM t`: löscht alle Zeilen, aber zeilenorientiert.
- `TRUNCATE t`: leert Tabelle meist schneller und struktureller, ohne `WHERE`.

Wenn nur bestimmte Datensätze gelöscht werden sollen, brauchst du `DELETE ... WHERE`.


Datenbanken - Praktische Umsetzung

Question:
# SELECT-Reihenfolge
In welcher logischen Reihenfolge wird `SELECT` verarbeitet?

Answer:
Logische Reihenfolge:

1. `FROM` / `JOIN`
2. `WHERE`
3. `GROUP BY`
4. `HAVING`
5. `SELECT`
6. `DISTINCT`
7. `ORDER BY`
8. `LIMIT` / `OFFSET`

Merke: `WHERE` filtert Zeilen vor der Gruppierung, `HAVING` Gruppen nach der Gruppierung.


Datenbanken - Praktische Umsetzung

Question:
# SELECT-Minimum
Welche Bestandteile sind bei einer einfachen Tabellenabfrage zwingend?

Answer:
Normalerweise:

```sql
SELECT spalten
FROM tabelle;
```

Optional: `WHERE`, `GROUP BY`, `HAVING`, `ORDER BY`, `LIMIT`.

Klausurrelevant: `SELECT` und `FROM` sind die Pflichtbestandteile klassischer Tabellenabfragen.


Datenbanken - Praktische Umsetzung

Question:
# Aliase
Warum nutzt man Aliase in SQL?

Answer:
Aliase verbessern Lesbarkeit und vermeiden Mehrdeutigkeit:

```sql
SELECT c.last_name AS nachname, i.total
FROM customer AS c
JOIN invoice AS i ON i.customer_id = c.customer_id;
```

Besonders wichtig bei Joins, Self Joins und berechneten Spalten.


Datenbanken - Praktische Umsetzung

Question:
# DISTINCT
Was macht `DISTINCT` und warum ist es nicht immer harmlos?

Answer:
`DISTINCT` entfernt doppelte Ergebniszeilen.

SQL arbeitet grundsätzlich mit Multimengen: gleiche Zeilen dürfen mehrfach vorkommen.

Prüfungsfalle: `DISTINCT` kann einen falschen Join kaschieren, der eigentlich unnötige Duplikate erzeugt.


Datenbanken - Praktische Umsetzung

Question:
# COUNT
Wie unterscheiden sich `COUNT(*)` und `COUNT(spalte)`?

Answer:
- `COUNT(*)` zählt alle Zeilen der Ergebnisgruppe.
- `COUNT(spalte)` zählt nur Zeilen, in denen `spalte IS NOT NULL` ist.

Wenn `email` teilweise `NULL` ist, ist `COUNT(email)` kleiner als `COUNT(*)`.


Datenbanken - Praktische Umsetzung

Question:
# Aggregatfunktionen und NULL
Wie behandeln Aggregatfunktionen `NULL`?

Answer:
Viele Aggregatfunktionen ignorieren `NULL`:

- `SUM(spalte)` ignoriert `NULL`
- `AVG(spalte)` mittelt nur Nicht-NULL-Werte
- `MIN`/`MAX` ignorieren `NULL`
- `COUNT(spalte)` zählt Nicht-NULL-Werte
- `COUNT(*)` zählt alle Zeilen


Datenbanken - Praktische Umsetzung

Question:
# WHERE-Operatoren
Welche typischen Operatoren gehören in die `WHERE`-Klausel?

Answer:
Typische Filter:

```sql
WHERE price >= 10
WHERE country IN ('Germany', 'Austria')
WHERE total BETWEEN 100 AND 500
WHERE name LIKE 'A%'
WHERE deleted_at IS NULL
```

Erst Zeilenbedingung formulieren, dann Gruppierung/Aggregation ergänzen.


Datenbanken - Praktische Umsetzung

Question:
# LIKE
Was bedeuten `%` und `_` in `LIKE`-Mustern?

Answer:
- `%` steht für beliebig viele Zeichen, auch null Zeichen.
- `_` steht für genau ein beliebiges Zeichen.

```sql
WHERE name LIKE 'A%'   -- beginnt mit A
WHERE code LIKE 'A_1'  -- A, genau ein Zeichen, dann 1
```

`LIKE 'A_'` passt nicht auf `A` und nicht auf `ABC`.


Datenbanken - Praktische Umsetzung

Question:
# NULL-Vergleich
Warum ist `WHERE spalte = NULL` falsch?

Answer:
`NULL` ist unbekannt. Der Vergleich `= NULL` ergibt nicht `TRUE`.

Richtig:

```sql
WHERE spalte IS NULL
WHERE spalte IS NOT NULL
```

Das ist eine häufige Klausurfalle bei Filtern und Aggregaten.


Datenbanken - Praktische Umsetzung

Question:
# ORDER BY, LIMIT, OFFSET
Wofür nutzt man diese Klauseln?

Answer:
- `ORDER BY`: sortiert das Ergebnis.
- `LIMIT`: begrenzt die Anzahl der zurückgegebenen Zeilen.
- `OFFSET`: überspringt Zeilen, oft für Pagination.

```sql
SELECT *
FROM invoice
ORDER BY invoice_date DESC
LIMIT 10 OFFSET 20;
```

Ohne `ORDER BY` ist die Reihenfolge nicht verlässlich.


Datenbanken - Praktische Umsetzung

Question:
# GROUP BY und HAVING
Wann nutzt man `GROUP BY`, wann `HAVING`?

Answer:
`GROUP BY` bildet Gruppen. `HAVING` filtert Gruppen nach Aggregation.

```sql
SELECT country, COUNT(*) AS anzahl
FROM customer
GROUP BY country
HAVING COUNT(*) > 1;
```

`WHERE` filtert einzelne Zeilen vorher; `HAVING` aggregierte Gruppen nachher.


Datenbanken - Praktische Umsetzung

Question:
# GROUP-BY-Regel
Welche Spalten dürfen in der `SELECT`-Liste stehen?

Answer:
Bei Gruppierung dürfen in `SELECT` nur stehen:

- Spalten, die in `GROUP BY` stehen
- Aggregatfunktionen wie `COUNT(*)`, `SUM(total)`, `AVG(price)`

Falsch:

```sql
SELECT country, first_name, COUNT(*)
FROM customer
GROUP BY country;
```

`first_name` ist weder gruppiert noch aggregiert.


Datenbanken - Praktische Umsetzung

Question:
# Unterabfragen
Welche Typen von Unterabfragen sind wichtig?

Answer:
- **Skalare Unterabfrage:** liefert einen einzelnen Wert.
- **Mengen-Unterabfrage:** liefert mehrere Werte, oft mit `IN`.
- **Korrelierte Unterabfrage:** hängt von der äußeren Abfrage ab und wird logisch je äußerer Zeile ausgewertet.

Beispiel:

```sql
WHERE customer_id IN (SELECT customer_id FROM invoice)
```


Datenbanken - Praktische Umsetzung

Question:
# Korrelierte Unterabfrage
Was ist das?

Answer:
Eine korrelierte Unterabfrage verwendet Werte der äußeren Abfrage.

```sql
SELECT p1.name
FROM person p1
WHERE EXISTS (
  SELECT 1
  FROM person p2
  WHERE p2.last_name = p1.last_name
    AND p2.salary > p1.salary
);
```

Sie ist logisch abhängig von jeder Zeile der äußeren Abfrage.


Datenbanken - Praktische Umsetzung

Question:
# IN vs EXISTS
Wann passt was?

Answer:
- `IN` prüft, ob ein Wert in einer Ergebnisliste vorkommt.
- `EXISTS` prüft, ob eine passende Zeile existiert.

```sql
WHERE EXISTS (
  SELECT 1 FROM invoice i
  WHERE i.customer_id = c.customer_id
)
```

Bei korrelierten Existenzprüfungen ist `EXISTS` oft ausdrucksstärker.


Datenbanken - Praktische Umsetzung

Question:
# INNER JOIN
Was liefert ein `INNER JOIN`?

Answer:
Ein `INNER JOIN` liefert nur Zeilen, für die die Join-Bedingung auf beiden Seiten passt.

```sql
SELECT a.title, ar.name
FROM album a
JOIN artist ar ON ar.artist_id = a.artist_id;
```

Alben ohne passenden Künstler und Künstler ohne Album erscheinen nicht.


Datenbanken - Praktische Umsetzung

Question:
# OUTER JOIN
Wie unterscheiden sich `LEFT`, `RIGHT` und `FULL OUTER JOIN`?

Answer:
- `LEFT JOIN`: alle Zeilen links, passende rechts; fehlende rechte Werte werden `NULL`.
- `RIGHT JOIN`: alle Zeilen rechts, passende links.
- `FULL OUTER JOIN`: alle Zeilen beider Seiten, fehlende Partner als `NULL`.

Bei „auch wenn kein Partner existiert“ ist meist ein Outer Join nötig.


Datenbanken - Praktische Umsetzung

Question:
# Kartesisches Produkt
Wann entsteht es in SQL?

Answer:
Ein kartesisches Produkt entsteht, wenn Tabellen ohne passende Join-Bedingung kombiniert werden:

```sql
SELECT *
FROM customer, invoice;
```

Jede Zeile von `customer` wird mit jeder Zeile von `invoice` kombiniert. Bei Joins immer `ON` prüfen.


Datenbanken - Praktische Umsetzung

Question:
# SELF JOIN
Was ist ein Self Join?

Answer:
Ein Self Join verknüpft eine Tabelle mit sich selbst, meist über Aliase.

```sql
SELECT e.name AS employee, m.name AS manager
FROM employee e
LEFT JOIN employee m ON m.employee_id = e.manager_id;
```

Typisch für Hierarchien, z. B. Mitarbeiter und Vorgesetzte.


Datenbanken - Praktische Umsetzung

Question:
# JOINs vs Mengenoperationen
Wie unterscheiden sie sich?

Answer:
- **JOINs** kombinieren Tabellen horizontal: Spalten werden nebeneinandergeführt.
- **Mengenoperationen** kombinieren Ergebnisse vertikal: Zeilen werden untereinandergeführt.

Mengenoperationen: `UNION`, `INTERSECT`, `EXCEPT`.

Bedingung: gleiche Spaltenanzahl und kompatible Typen an denselben Positionen.


Datenbanken - Praktische Umsetzung

Question:
# UNION vs UNION ALL
Was ist der Unterschied?

Answer:
- `UNION` entfernt Duplikate.
- `UNION ALL` behält Duplikate.

Wenn Mehrfachvorkommen fachlich relevant sind, nicht versehentlich `UNION` verwenden.


Datenbanken - Praktische Umsetzung

Question:
# Views
Was ist eine View?

Answer:
Eine View ist eine gespeicherte SQL-Abfrage, die wie eine virtuelle Tabelle genutzt wird.

```sql
CREATE VIEW german_customers AS
SELECT customer_id, first_name, last_name
FROM customer
WHERE country = 'Germany';
```

Nutzen: Vereinfachung, Zugriffsbeschränkung, stabile externe Sicht.


Datenbanken - Praktische Umsetzung

Question:
# Änderbare Views
Wann ist eine View typischerweise nicht änderbar?

Answer:
Views sind oft nicht direkt änderbar, wenn sie enthalten:

- Aggregationen
- `GROUP BY`
- `DISTINCT`
- Joins mit Mehrdeutigkeiten
- berechnete Spalten
- Mengenoperationen

Eine View sieht wie eine Tabelle aus, ist aber nicht automatisch eine änderbare Tabelle.


Datenbanken - Praktische Umsetzung

Question:
# Index
Was macht ein Index?

Answer:
Ein Index beschleunigt Such-, Sortier- und Join-Zugriffe auf Kosten von Speicher und Schreibaufwand.

```sql
CREATE INDEX idx_invoice_customer
ON invoice(customer_id);
```

Indexe ändern nicht die logische Ergebnismenge, sondern die Zugriffseffizienz.


Datenbanken - Praktische Umsetzung

Question:
# Index-Falle
Warum nicht „auf jede Spalte“ einen Index setzen?

Answer:
Jeder Index kostet:

- Speicherplatz
- Pflege bei `INSERT`, `UPDATE`, `DELETE`
- Optimizer-Komplexität

Sinnvoll sind Indexe vor allem auf häufig gefilterten, gejointen oder sortierten Spalten mit geeigneter Selektivität.


Datenbanken - Praktische Umsetzung

Question:
# Rechteverwaltung
Wie funktionieren `GRANT` und `REVOKE`?

Answer:
`GRANT` vergibt Rechte, `REVOKE` entzieht sie.

```sql
GRANT SELECT ON customer TO martin;
REVOKE SELECT ON customer FROM martin;
```

Auch spaltenbezogene Rechte sind möglich:

```sql
GRANT SELECT (first_name, last_name) ON customer TO martin;
```


Datenbanken - Praktische Umsetzung

Question:
# System Catalog vs Information Schema
Was ist der Unterschied?

Answer:
- `information_schema`: standardisierte Metadaten-Sichten, portabler zwischen SQL-Datenbanken.
- PostgreSQL-Systemkataloge (`pg_*`): PostgreSQL-spezifisch, oft detaillierter.

Für portable Metadatenabfragen zuerst an `information_schema` denken.


Datenbanken - Praktische Umsetzung

Question:
# DB-seitige Logik
Warum verlagert man Logik in die Datenbank?

Answer:
Vorteile:

- Nähe zu Daten, weniger Netzwerkverkehr
- zentrale Durchsetzung von Regeln
- Wiederverwendung durch mehrere Anwendungen
- Performance bei datenintensiven Operationen

Nachteile: DB-spezifische Syntax, schwierigere Tests/Versionierung, stärkere DB-Kopplung.

Zusammenfassung §8.1; Skript DB-seitig/Transaktionen


Datenbanken - Praktische Umsetzung

Question:
# SQL-Function
Wie sieht eine PostgreSQL-Function mit `LANGUAGE SQL` aus?

Answer:
```sql
CREATE OR REPLACE FUNCTION track_count()
RETURNS INTEGER
LANGUAGE SQL
AS $$
  SELECT COUNT(*) FROM track;
$$;
```

Bei `LANGUAGE SQL` ergibt sich der Rückgabewert aus der letzten SQL-Anweisung.


Datenbanken - Praktische Umsetzung

Question:
# PL/pgSQL-Function
Welche Grundstruktur hat sie?

Answer:
```sql
CREATE OR REPLACE FUNCTION get_total(p_invoice_id INTEGER)
RETURNS NUMERIC
LANGUAGE plpgsql
AS $$
DECLARE
  v_total NUMERIC;
BEGIN
  SELECT total INTO v_total
  FROM invoice
  WHERE invoice_id = p_invoice_id;

  RETURN v_total;
END;
$$;
```

Wichtig: `DECLARE`, `BEGIN ... END`, `SELECT ... INTO`, `RETURN`.


Datenbanken - Praktische Umsetzung

Question:
# SELECT INTO in PL/pgSQL
Was macht `SELECT ... INTO variable`?

Answer:
Es speichert ein Abfrageergebnis in eine PL/pgSQL-Variable.

```sql
SELECT COUNT(*) INTO v_count
FROM invoice
WHERE customer_id = p_customer_id;
```

Prüfungsfalle: In PL/pgSQL ist das eine Variablenzuweisung, nicht eine Tabellenerzeugung.


Datenbanken - Praktische Umsetzung

Question:
# Function vs Procedure
Wie unterscheiden sie sich in PostgreSQL?

Answer:
| Function | Procedure |
|---|---|
| liefert Wert oder `void` | kein klassischer Rückgabewert nötig |
| kann in SQL-Ausdrücken genutzt werden | wird mit `CALL` aufgerufen |
| keine Transaktionsbefehle in der Function | Procedures können Transaktionsbefehle enthalten, je nach Kontext |

Merksatz: Function berechnet, Procedure führt Ablauf aus.


Datenbanken - Praktische Umsetzung

Question:
# Procedure-Syntax
Wie wird eine Procedure erstellt und aufgerufen?

Answer:
```sql
CREATE OR REPLACE PROCEDURE raise_prices(p_factor NUMERIC)
LANGUAGE plpgsql
AS $$
BEGIN
  UPDATE track
  SET unit_price = unit_price * p_factor;
END;
$$;

CALL raise_prices(1.10);
```

Klausurfalle: Eine Procedure wird per `CALL` aufgerufen, nicht per `SELECT`.


Datenbanken - Praktische Umsetzung

Question:
# Trigger
Was ist ein Trigger?

Answer:
Ein Trigger ist automatisch ausgeführte DB-Logik bei Ereignissen wie `INSERT`, `UPDATE` oder `DELETE`.

Typische Einsatzfälle:

- Default-/Validierungslogik
- Audit-Tabellen
- abgeleitete Werte
- Integritätsregeln, die mit einfachen Constraints nicht gut ausdrückbar sind

PostgreSQL benötigt dafür eine separate Trigger-Funktion.

Zusammenfassung §8.5; Übungsklausur Functions/Trigger


Datenbanken - Praktische Umsetzung

Question:
# NEW, OLD, TG_OP
Welche Trigger-Spezialvariablen sind wichtig?

Answer:
In PostgreSQL-Triggerfunktionen:

- `NEW`: neue Zeile bei `INSERT`/`UPDATE`
- `OLD`: alte Zeile bei `UPDATE`/`DELETE`
- `TG_OP`: Operation als Text, z. B. `INSERT`

```sql
IF NEW.name IS NULL THEN
  NEW.name := 'Untitled Genre';
END IF;
```


Datenbanken - Praktische Umsetzung

Question:
# BEFORE vs AFTER Trigger
Wann nutzt man was?

Answer:
- `BEFORE`: vor der Änderung; geeignet, um `NEW` zu prüfen oder zu verändern.
- `AFTER`: nach erfolgreicher Änderung; geeignet für Logging, Audit, Folgeaktionen.
- `FOR EACH ROW`: pro betroffener Zeile.
- `FOR EACH STATEMENT`: einmal pro SQL-Anweisung.

Default setzen: meist `BEFORE INSERT FOR EACH ROW`.


Datenbanken - Praktische Umsetzung

Question:
# Trigger-Beispiel
Wie setzt man per Trigger einen Default-Namen für neue Genres?

Answer:
```sql
CREATE OR REPLACE FUNCTION set_default_genre_name()
RETURNS TRIGGER
LANGUAGE plpgsql
AS $$
BEGIN
  IF NEW.name IS NULL THEN
    NEW.name := 'Untitled Genre';
  END IF;
  RETURN NEW;
END;
$$;

CREATE TRIGGER trg_genre_default_name
BEFORE INSERT ON genre
FOR EACH ROW
EXECUTE FUNCTION set_default_genre_name();
```

Wichtig: Trigger-Funktion und `CREATE TRIGGER` getrennt angeben.

Übungsklausur S. 4; Zusammenfassung §8.5


Datenbanken - Praktische Umsetzung

Question:
# ACID
Wofür stehen die ACID-Eigenschaften?

Answer:
- **Atomicity:** ganz oder gar nicht.
- **Consistency:** gültiger DB-Zustand bleibt gültig.
- **Isolation:** parallele Transaktionen stören sich nicht unzulässig.
- **Durability:** bestätigte Änderungen bleiben nach Fehlern erhalten.

Klausurpunkt: ACID-Konsistenz meint Integritätsregeln, nicht CAP-Einheitlichkeit.


Datenbanken - Praktische Umsetzung

Question:
# Auto-Commit
Was bedeutet Auto-Commit?

Answer:
Bei Auto-Commit wird jede einzelne SQL-Anweisung automatisch als eigene Transaktion bestätigt.

Für zusammengehörige Schritte:

```sql
BEGIN;
UPDATE account SET balance = balance - 100 WHERE id = 1;
UPDATE account SET balance = balance + 100 WHERE id = 2;
COMMIT;
```

Bei Fehler: `ROLLBACK`.

Zusammenfassung §9.1; DB-seitig/Transaktionen S. 72


Datenbanken - Praktische Umsetzung

Question:
# Nebenläufigkeitsanomalien
Welche typischen Anomalien gibt es?

Answer:
- **Dirty Read:** Lesen nicht bestätigter Daten.
- **Non-Repeatable Read:** dieselbe Zeile liefert später andere Werte.
- **Phantom Read:** dieselbe Bereichsabfrage liefert später zusätzliche/fehlende Zeilen.
- **Lost Update:** parallele Änderungen überschreiben sich.

Isolation Levels reduzieren diese Effekte unterschiedlich stark.


Datenbanken - Praktische Umsetzung

Question:
# Isolation Levels
Welche Level sind klausurrelevant?

Answer:
| Level | Idee |
|---|---|
| `READ UNCOMMITTED` | sehr schwach; in PostgreSQL wie Read Committed behandelt |
| `READ COMMITTED` | nur bestätigte Daten lesen |
| `REPEATABLE READ` | wiederholtes Lesen bleibt stabiler |
| `SERIALIZABLE` | Ergebnis wie serielle Ausführung |

Tradeoff: höhere Isolation = weniger Anomalien, aber mehr Konfliktkosten.


Datenbanken - Praktische Umsetzung

Question:
# Locks
Warum verwendet ein DBMS Locks?

Answer:
Locks koordinieren parallele Zugriffe:

- Schreibvorgänge sollen keine inkonsistenten Zustände erzeugen.
- Leser und Schreiber werden je nach Isolation/Sperrtyp koordiniert.
- Sperren können auf Zeilen, Tabellen oder anderen Objekten liegen.

Mehr Sperren erhöhen Korrektheit, können aber Wartezeiten und Deadlocks verursachen.


Datenbanken - Praktische Umsetzung

Question:
# Deadlock
Was ist ein Deadlock?

Answer:
Ein Deadlock entsteht, wenn Transaktionen zyklisch aufeinander warten.

- T1 hält Lock auf A und wartet auf B.
- T2 hält Lock auf B und wartet auf A.

DBMS erkennen Deadlocks typischerweise und brechen eine Transaktion ab. Anwendungen müssen ggf. wiederholen.


Datenbanken - Praktische Umsetzung

Question:
# Two-Phase Locking vs Two-Phase Commit
Was ist der Unterschied?

Answer:
- **2PL (Two-Phase Locking):** Sperrprotokoll für Isolation/Serialisierbarkeit mit Wachstums- und Schrumpfphase.
- **2PC (Two-Phase Commit):** Protokoll für verteiltes Commit mit Prepare/Vote und Commit/Abort.

Nicht verwechseln: 2PL regelt Sperren, 2PC regelt verteilte Transaktionsentscheidung.

Zusammenfassung §9.5; Erweiterungen/verteilte DB


Datenbanken - Praktische Umsetzung

Question:
# JDBC-Treibertypen
Welche Treibertypen gibt es grob?

Answer:
Klassische Einteilung:

1. Typ 1: JDBC-ODBC-Bridge
2. Typ 2: Native-API-Treiber
3. Typ 3: Middleware/Netzwerktreiber
4. Typ 4: Pure Java, direktes DB-Protokoll

Praktisch heute wichtig: Typ-4-Treiber, z. B. PostgreSQL JDBC Driver.


Datenbanken - Praktische Umsetzung

Question:
# JDBC-Ablauf
Wie sieht der typische Ablauf für eine `SELECT`-Abfrage aus?

Answer:
1. `Connection` bereitstellen.
2. `PreparedStatement` oder `Statement` erzeugen.
3. SQL mit `executeQuery()` ausführen.
4. `ResultSet` zeilenweise lesen.
5. Ressourcen schließen, ideal mit `try-with-resources`.

```java
try (Connection con = dataSource.getConnection();
     PreparedStatement ps = con.prepareStatement(sql);
     ResultSet rs = ps.executeQuery()) {
  while (rs.next()) { /* Werte lesen */ }
}
```

Zusammenfassung §10.1; Übungsklausur JDBC


Datenbanken - Praktische Umsetzung

Question:
# executeQuery, executeUpdate, execute
Wann nutzt man welche Methode?

Answer:
- `executeQuery()`: für `SELECT`, liefert `ResultSet`.
- `executeUpdate()`: für `INSERT`, `UPDATE`, `DELETE`, DDL; liefert Anzahl betroffener Zeilen bzw. Status.
- `execute()`: allgemein, wenn Ergebnisart nicht vorher klar ist.

Klausurfalle: `SELECT` nicht mit `executeUpdate()` lösen.


Datenbanken - Praktische Umsetzung

Question:
# ResultSet
Wie funktioniert ein `ResultSet`?

Answer:
Ein `ResultSet` ist ein Cursor über Ergebniszeilen.

```java
while (rs.next()) {
  int id = rs.getInt("customer_id");
  String name = rs.getString("last_name");
}
```

`rs.next()` bewegt den Cursor zur nächsten Zeile und liefert `false`, wenn keine Zeile mehr existiert.


Datenbanken - Praktische Umsetzung

Question:
# JDBC-Ressourcen
Warum ist Ressourcenfreigabe wichtig?

Answer:
Connections, Statements und ResultSets belegen DB- und Netzwerkressourcen.

Empfohlen:

```java
try (Connection con = ds.getConnection();
     PreparedStatement ps = con.prepareStatement(sql);
     ResultSet rs = ps.executeQuery()) {
  // Verarbeitung
}
```

Dadurch werden Ressourcen auch bei Exceptions zuverlässig geschlossen.

Übungsklausur S. 6; Zusammenfassung §10.1


Datenbanken - Praktische Umsetzung

Question:
# JDBC-Transaktionen
Wie steuert man Transaktionen in JDBC?

Answer:
```java
con.setAutoCommit(false);
try {
  // mehrere SQL-Operationen
  con.commit();
} catch (SQLException ex) {
  con.rollback();
  throw ex;
}
```

Wichtig: Auto-Commit deaktivieren, bei Erfolg `commit`, bei Fehler `rollback`.


Datenbanken - Praktische Umsetzung

Question:
# SQL Injection
Was ist das?

Answer:
SQL Injection entsteht, wenn Benutzereingaben ungeprüft in SQL-Strings verkettet werden.

Riskant:

```java
String sql = "SELECT * FROM user WHERE name = '" + input + "'";
```

Ein Angreifer kann SQL-Logik einschleusen, z. B. über `' OR '1'='1`.


Datenbanken - Praktische Umsetzung

Question:
# PreparedStatement
Warum verhindert es SQL Injection?

Answer:
Parameter werden getrennt vom SQL-Code übertragen:

```java
PreparedStatement ps = con.prepareStatement(
  "SELECT * FROM customer WHERE email = ?"
);
ps.setString(1, email);
ResultSet rs = ps.executeQuery();
```

Die Eingabe wird als Wert behandelt, nicht als ausführbarer SQL-Code.


Datenbanken - Praktische Umsetzung

Question:
# REST und 3-Schichten
Wie passt REST in die Architektur?

Answer:
Typische Schichten:

1. **Präsentation:** UI/Client.
2. **Anwendungs-/Service-Schicht:** REST-API, Geschäftslogik, Validierung.
3. **Datenhaltung:** DBMS, SQL, JPA/JDBC.

REST stellt Ressourcen über HTTP bereit. Die Datenbank bleibt hinter der Service-Schicht gekapselt.


Datenbanken - Praktische Umsetzung

Question:
# ORM, JPA, Hibernate
Wie hängen sie zusammen?

Answer:
- **ORM:** Prinzip, Objekte auf relationale Tabellen abzubilden.
- **JPA:** Java-Spezifikation für Persistenz/ORM.
- **Hibernate:** konkrete JPA-Implementierung.

Merksatz: JPA ist die Spezifikation, Hibernate eine Implementierung.


Datenbanken - Praktische Umsetzung

Question:
# Object-Relational Impedance Mismatch
Was bedeutet das?

Answer:
Objektmodell und relationales Modell passen nicht perfekt zusammen:

- Objekte haben Identität, Referenzen, Vererbung, Collections.
- Relationale DBs arbeiten mit Tabellen, Schlüsseln, Mengen und Joins.
- Beziehungen müssen zwischen Objektgraphen und Fremdschlüsseln übersetzt werden.

ORM reduziert den Aufwand, beseitigt den Grundkonflikt aber nicht vollständig.


Datenbanken - Praktische Umsetzung

Question:
# EntityManager
Welche Aufgaben hat der JPA `EntityManager`?

Answer:
Der `EntityManager` verwaltet Entitäten und Persistenzkontext:

- `persist(entity)`: neue Entität persistent machen
- `find(Entity.class, id)`: Entität laden
- `merge(entity)`: detached Änderungen zusammenführen
- `remove(entity)`: Entität löschen
- Queries/JPQL ausführen

Er ist die zentrale API zwischen Java-Objekten und Datenbank.


Datenbanken - Praktische Umsetzung

Question:
# JPA-Lebenszyklus
Welche Zustände hat eine Entity?

Answer:
Wichtige Zustände:

- **new/transient:** Objekt existiert nur im Speicher.
- **managed/persistent:** EntityManager verwaltet das Objekt; Änderungen werden synchronisiert.
- **detached:** Objekt nicht mehr im Persistenzkontext.
- **removed:** zum Löschen markiert.

Klausurfalle: Nur managed Entities werden automatisch per Dirty Checking berücksichtigt.


Datenbanken - Praktische Umsetzung

Question:
# JPQL vs SQL
Wie unterscheidet sich JPQL von SQL?

Answer:
- SQL fragt Tabellen und Spalten ab.
- JPQL fragt Entities und deren Attribute ab.

Beispiel:

```java
SELECT c FROM Customer c WHERE c.country = :country
```

`Customer` ist eine Entity, nicht zwingend der Tabellenname.


Datenbanken - Praktische Umsetzung

Question:
# OLTP vs OLAP
Wie unterscheiden sie sich?

Answer:
| OLTP | OLAP |
|---|---|
| Tagesgeschäft | Analyse/Entscheidung |
| viele kurze Transaktionen | wenige komplexe Abfragen |
| schreib- und änderungsnah | lese- und aggregationsnah |
| aktuelle operative Daten | historische/verdichtete Daten |

Bestellung buchen = OLTP, Umsatztrend analysieren = OLAP.

Zusammenfassung §11.1; Erweiterungen/verteilte DB S. 46


Datenbanken - Praktische Umsetzung

Question:
# ORDBMS
Was ist ein objektrelationales DBMS?

Answer:
Ein ORDBMS erweitert relationale Datenbanken um objektnahe Konzepte:

- komplexe Datentypen
- benutzerdefinierte Typen/Funktionen
- Vererbung oder strukturierte Werte
- JSON/Array-Unterstützung je nach System

PostgreSQL besitzt viele objektrelationale Erweiterungen.

Zusammenfassung §11.2; Erweiterungen/verteilte DB


Datenbanken - Praktische Umsetzung

Question:
# SAP HANA und Code-to-Data
Was bedeutet Code-to-Data?

Answer:
**Data-to-Code:** Daten werden zur Anwendung übertragen, dort verarbeitet.

**Code-to-Data:** Berechnungslogik wird nah an die Datenbank verlagert.

Vorteil bei HANA/In-Memory/Column Store: große Datenmengen können direkt in der DB gescannt und aggregiert werden; weniger Netzwerk- und Applikationsserverlast.

Zusammenfassung §11.2; Erweiterungen/verteilte DB S. 24, 46


Datenbanken - Praktische Umsetzung

Question:
# Verteilte Datenbank
Was ist das?

Answer:
Eine verteilte Datenbank ist logisch eine zusammengehörige Datenbank, deren Daten physisch auf mehrere über ein Netzwerk verbundene Rechner verteilt sind.

Wichtige Konzepte:

- Fragmentierung: horizontal oder vertikal
- Replikation: Kopien auf mehreren Knoten
- verteilte Transaktionen
- Konsistenz- und Verfügbarkeitsprobleme

Zusammenfassung §11.3; Erweiterungen/verteilte DB S. 46


Datenbanken - Praktische Umsetzung

Question:
# Horizontale vs vertikale Fragmentierung
Wie unterscheiden sie sich?

Answer:
- **Horizontal:** Tabelle wird nach Zeilen aufgeteilt, z. B. Kunden nach Region.
- **Vertikal:** Tabelle wird nach Spalten aufgeteilt; der Primärschlüssel muss in Fragmenten erhalten bleiben.

Beispiel horizontal: `customer_eu`, `customer_us`.
Beispiel vertikal: `customer_contact`, `customer_billing`.

Erweiterungen/verteilte DB S. 46; Zusammenfassung §11.3


Datenbanken - Praktische Umsetzung

Question:
# CAP-Theorem
Wofür stehen C, A und P?

Answer:
- **Consistency:** alle Knoten sehen denselben aktuellen Datenstand.
- **Availability:** jede Anfrage erhält eine Antwort.
- **Partition Tolerance:** System arbeitet trotz Netzwerkpartition weiter.

Bei einer Netzwerkpartition muss ein verteiltes System zwischen strikter Konsistenz und Verfügbarkeit abwägen.

Zusammenfassung §11.4; Erweiterungen/verteilte DB S. 46


Datenbanken - Praktische Umsetzung

Question:
# CAP-Tradeoff
Warum kann man bei Partition nicht gleichzeitig strikte C und A garantieren?

Answer:
Bei Netzwerktrennung können Knoten nicht sicher synchronisieren.

- Wählt man **Consistency**, müssen unsichere Anfragen abgelehnt oder blockiert werden.
- Wählt man **Availability**, antworten Knoten weiter, riskieren aber veraltete/abweichende Daten.

Partition Tolerance ist in verteilten Systemen praktisch unvermeidbar.

Zusammenfassung §11.4; Erweiterungen/verteilte DB S. 46


Datenbanken - Praktische Umsetzung

Question:
# ACID-Konsistenz vs CAP-Konsistenz
Warum meint Konsistenz nicht dasselbe?

Answer:
- **ACID Consistency:** Eine Transaktion erhält Integritätsregeln der Datenbank. Gültiger Zustand -> gültiger Zustand.
- **CAP Consistency:** Alle Knoten liefern denselben aktuellen Wert, also Einheitlichkeit der Replikate.

Prüfungsfalle: Nicht beide Begriffe vermischen.

Zusammenfassung §11.4; Erweiterungen/verteilte DB S. 46


Datenbanken - Praktische Umsetzung

Question:
# BASE
Wofür steht BASE und wie grenzt es sich von ACID ab?

Answer:
BASE steht für:

- **Basically Available**
- **Soft State**
- **Eventual Consistency**

BASE akzeptiert vorübergehend inkonsistente Zustände zugunsten von Verfügbarkeit und Skalierbarkeit. ACID zielt auf strikte Transaktionssicherheit.


Datenbanken - Praktische Umsetzung

Question:
# Eventual Consistency
Was bedeutet das?

Answer:
Nach einem Schreibvorgang sehen nicht sofort alle Knoten denselben Wert. Wenn keine weiteren Änderungen passieren, konvergieren die Replikate irgendwann zu demselben Zustand.

Klausurformulierung: **vorübergehend inkonsistent, langfristig konsistent**.

Zusammenfassung §11.4; Erweiterungen/verteilte DB S. 46


Datenbanken - Praktische Umsetzung

Question:
# NoSQL-Grundidee
Warum ist „nicht-relational“ oft präziser als „NoSQL“?

Answer:
Viele NoSQL-Systeme besitzen SQL-ähnliche Sprachen, z. B. Cassandra CQL. Das Hauptmerkmal ist daher nicht zwingend „kein SQL“, sondern:

- anderes Datenmodell
- flexible Schemata
- horizontale Skalierung
- Replikation/Partitionierung
- oft BASE/Eventual Consistency

Kategorien: Key-Value, Dokument, Wide-Column, Graph.


Datenbanken - Praktische Umsetzung

Question:
# Drei Vs
Welche Big-Data-Treiber führen häufig zu NoSQL?

Answer:
Die drei klassischen Vs:

- **Volume:** große Datenmengen
- **Variety:** vielfältige/heterogene Strukturen
- **Velocity:** hohe Geschwindigkeit bei Erzeugung/Verarbeitung

NoSQL-Systeme adressieren diese Anforderungen oft durch horizontale Skalierung und flexiblere Datenmodelle.


Datenbanken - Praktische Umsetzung

Question:
# NoSQL-Kategorien
Welche Hauptkategorien gibt es?

Answer:
1. **Key-Value Stores:** Schlüssel -> Wert, z. B. Redis.
2. **Dokumentendatenbanken:** Dokumente, z. B. MongoDB.
3. **Wide-Column Stores:** Column Families, z. B. Cassandra.
4. **Graphdatenbanken:** Knoten und Kanten, z. B. Neo4j.

Merksatz: Datenmodell nach Zugriffsmuster wählen.


Datenbanken - Praktische Umsetzung

Question:
# Redis
Was ist das Grundmodell?

Answer:
Redis ist ein Key-Value Store. Daten werden über Schlüssel adressiert, Werte können verschiedene Strukturen haben:

- Strings
- Hashes
- Lists
- Sets
- Sorted Sets

Typisch: Cache, Sessions, Zähler, Queues.


Datenbanken - Praktische Umsetzung

Question:
# Redis-Persistenz
Wie kann Redis trotz RAM-Nutzung persistent sein?

Answer:
Redis ist sehr schnell durch In-Memory-Verarbeitung, kann aber auf Platte sichern:

- **RDB Snapshots:** periodische Momentaufnahmen.
- **AOF (Append Only File):** Änderungsoperationen fortlaufend in ein Journal schreiben.

Tradeoff: Performance, Wiederherstellbarkeit und Datenverlustfenster hängen von der Konfiguration ab.


Datenbanken - Praktische Umsetzung

Question:
# MongoDB Mapping
Wie mappt MongoDB relationale Begriffe?

Answer:
| Relational | MongoDB |
|---|---|
| Tabelle | Collection |
| Zeile/Tupel | Document |
| Spalte | Field |
| Primärschlüssel | `_id` |

Dokumente sind meist BSON: Binary JSON, effizienter und mit zusätzlichen Datentypen wie Date.


Datenbanken - Praktische Umsetzung

Question:
# MongoDB ObjectId
Welche Rolle hat `_id`?

Answer:
Jedes MongoDB-Dokument braucht ein eindeutiges `_id`-Feld.

Wenn kein `_id` gesetzt wird, erzeugt MongoDB typischerweise automatisch eine `ObjectId`.

`_id` entspricht funktional dem eindeutigen Dokument-Identifier, ähnlich einem Primärschlüssel.


Datenbanken - Praktische Umsetzung

Question:
# Dokumentenmodell
Wann passt eine Dokumentendatenbank gut?

Answer:
Dokumentendatenbanken passen gut, wenn:

- Daten objekt-/dokumentartig zusammen gelesen werden
- Strukturen variieren dürfen
- eingebettete Teilobjekte sinnvoll sind
- horizontale Skalierung wichtiger ist als komplexe Joins

Prüfungsfalle: Flexible Schemata ersetzen kein gutes Zugriffsmuster-Design.


Datenbanken - Praktische Umsetzung

Question:
# Cassandra-Datenmodell
Wie lässt sich das Wide-Column-Modell kompakt darstellen?

Answer:
Kompakte Formel:

$$(RowKey, ColumnFamily, Column, Timestamp) \to Value$$

Cassandra speichert Daten in Tabellen/Column Families mit dynamischen Spalten. Der Partition Key bestimmt die Datenverteilung über Knoten.


Datenbanken - Praktische Umsetzung

Question:
# Cassandra Query First
Was bedeutet Query-First-Modellierung?

Answer:
Cassandra-Tabellen werden nach den benötigten Abfragen entworfen, nicht nach Normalformen.

Grund: Cassandra unterstützt keine freien Joins/Subqueries wie relationale Systeme.

Konsequenz:

- Denormalisierung ist normal.
- „One query per table“ ist ein typisches Designprinzip.
- Datenmodellierung beginnt bei Zugriffsmustern.


Datenbanken - Praktische Umsetzung

Question:
# Cassandra vs RDBMS
Was sind zentrale Unterschiede?

Answer:
| RDBMS | Cassandra |
|---|---|
| Normalisierung | Denormalisierung nach Query |
| Joins/Subqueries | stark eingeschränkt/nicht vorgesehen |
| referentielle Integrität | keine klassische FK-Integrität |
| oft vertikal + relational | stark horizontal skaliert |
| SQL | CQL mit SQL-ähnlicher Syntax |

CQL sieht SQL-ähnlich aus, bedeutet aber nicht relationale Abfragefreiheit.


Datenbanken - Praktische Umsetzung

Question:
# Cassandra UPSERT
Was bedeutet UPSERT?

Answer:
Schreiboperationen werden als Upsert behandelt:

- Existiert der Key bereits, wird der Wert überschrieben/ergänzt.
- Existiert er nicht, wird ein neuer Eintrag angelegt.

Das ist für hohen Schreibdurchsatz optimiert, verlangt aber sauberes Datenmodell und Konfliktverständnis.


Datenbanken - Praktische Umsetzung

Question:
# Neo4j Graphmodell
Welche Grundelemente gibt es?

Answer:
Neo4j modelliert Daten als Graph:

- **Nodes:** Entitäten, z. B. Person, Ort
- **Relationships:** gerichtete Beziehungen zwischen Nodes
- **Labels:** Typisierung von Nodes
- **Properties:** Attribute auf Nodes und Relationships

Stark, wenn Beziehungen wichtiger sind als einzelne Datensätze.


Datenbanken - Praktische Umsetzung

Question:
# Cypher
Wie sieht eine einfache Cypher-Abfrage aus?

Answer:
```cypher
MATCH (p:Person)-[:FRIEND_OF]->(f:Person)
WHERE p.name = 'Mia'
RETURN f.name;
```

Cypher beschreibt Muster im Graphen. Beziehungen sind im Graphmodell explizit gespeichert und werden nicht erst wie relationale Joins rekonstruiert.


Datenbanken - Praktische Umsetzung

Question:
# Neo4j und ACID
Welche Besonderheit hat Neo4j?

Answer:
Neo4j ist eine Graphdatenbank und gilt im Kurs als eine der NoSQL-Datenbanken mit vollständiger ACID-Konformität.

Prüfungsfalle: NoSQL bedeutet nicht automatisch „keine Transaktionen“ oder „nie ACID“. Die Eigenschaften sind systemabhängig.


Datenbanken - Praktische Umsetzung

Question:
# Polystores
Was ist ein Polystore-Ansatz?

Answer:
Ein Polystore nutzt mehrere spezialisierte Datenbanksysteme gemeinsam:

- relationale DB für Transaktionen
- Graphdatenbank für Beziehungen
- Dokumentenstore für flexible Dokumente
- Key-Value Store für Cache/Sessions

Idee: Best-of-Breed statt ein einziges System für alle Anforderungen.


Datenbanken - Praktische Umsetzung

Question:
# NoSQL-Einsatzszenarien
Wie wählt man einen passenden NoSQL-Typ?

Answer:
- **Redis/Key-Value:** Cache, Session, schnelle Lookups.
- **MongoDB/Dokument:** flexible, dokumentartige Aggregate.
- **Cassandra/Wide-Column:** sehr große, verteilte Schreiblast, Query-first.
- **Neo4j/Graph:** stark vernetzte Daten, Pfade, Beziehungen.

Immer vom Zugriffsmuster argumentieren, nicht nur vom Produktnamen.


Datenbanken - Praktische Umsetzung

Question:
# Historische nicht-relationale DBs
Wie unterscheiden sich hierarchische und Netzwerkdatenbanken?

Answer:
- **Hierarchische Datenbanken:** baumartige 1:n-Strukturen; Zugriff entlang der Hierarchie.
- **Netzwerkdatenbanken:** komplexere n:m-Beziehungen über Owner-Member-Sets.

Beide sind stärker navigierend/programmiert als relationale SQL-Systeme.


Datenbanken - Praktische Umsetzung

Question:
# DDL-Klausuraufgabe
Wie gehst du bei gegebenem Relationenschema vor?

Answer:
Checkliste:

1. Tabellenname und Attribute übernehmen.
2. Datentypen sinnvoll wählen.
3. `PRIMARY KEY` setzen.
4. Pflichtfelder mit `NOT NULL` markieren.
5. `UNIQUE`/`CHECK` ergänzen, falls fachlich gegeben.
6. `FOREIGN KEY ... REFERENCES ...` mit Referenzaktionen ergänzen.
7. Syntax auf Kommas und Klammern prüfen.

Übungsklausur S. 1; Zusammenfassung §13.1


Datenbanken - Praktische Umsetzung

Question:
# SQL-Ergebnis von Hand
Wie ermittelst du eine SQL-Ergebnistabelle?

Answer:
Vorgehen nach logischer Reihenfolge:

1. `FROM`/`JOIN`: Ausgangstabelle bilden.
2. `WHERE`: Zeilen streichen.
3. `GROUP BY`: Gruppen bilden.
4. Aggregate berechnen.
5. `HAVING`: Gruppen filtern.
6. `SELECT`: Spalten/Expressions auswählen.
7. `ORDER BY`, `LIMIT`, `OFFSET` anwenden.

Nicht in Schreibreihenfolge denken.

Übungsklausur S. 2; Zusammenfassung §13.1


Datenbanken - Praktische Umsetzung

Question:
# Function-/Trigger-Aufgabe
Was darf bei PostgreSQL-Trigger-Aufgaben nicht fehlen?

Answer:
Immer zwei Teile liefern:

1. Trigger-Funktion:

```sql
CREATE OR REPLACE FUNCTION ...
RETURNS TRIGGER
LANGUAGE plpgsql
AS $$ ... $$;
```

2. Trigger-Registrierung:

```sql
CREATE TRIGGER ...
BEFORE INSERT ON ...
FOR EACH ROW
EXECUTE FUNCTION ...();
```

Nur die Funktion zu schreiben reicht nicht.

Übungsklausur S. 3-4; Zusammenfassung §13.1


Datenbanken - Praktische Umsetzung

Question:
# JDBC-Klausuraufgabe
Welche Bausteine werden typischerweise geprüft?

Answer:
Häufige Lücken:

- `Connection` erzeugen/verwenden
- `Statement` oder besser `PreparedStatement`
- passende `execute...`-Methode
- `ResultSet` mit `while (rs.next())`
- Parameter setzen
- `commit`/`rollback` bei Transaktionen
- Ressourcen schließen

Prüfungsfalle: SQL Injection durch String-Verkettung vermeiden.

Übungsklausur S. 6; Zusammenfassung §13.1


Datenbanken - Praktische Umsetzung

Question:
# Häufige SQL-Fehler
Welche Fehler kosten schnell Punkte?

Answer:
- fehlendes `WHERE` bei `UPDATE`/`DELETE`
- falsche oder fehlende `JOIN ... ON`-Bedingung
- `= NULL` statt `IS NULL`
- `WHERE` und `HAVING` verwechselt
- nicht gruppierte Spalten in `SELECT`
- `COUNT(spalte)` statt `COUNT(*)` falsch interpretiert
- `UNION` verwendet, obwohl Duplikate relevant sind


Datenbanken - Praktische Umsetzung

Question:
# Häufige Architektur-Fehler
Welche konzeptionellen Verwechslungen sind typisch?

Answer:
- ACID-Konsistenz mit CAP-Konsistenz verwechseln.
- 2PL mit 2PC verwechseln.
- JPA als Implementierung statt Spezifikation beschreiben.
- Hibernate als Spezifikation statt Implementierung beschreiben.
- NoSQL als „keine SQL-Sprache“ definieren.
- DBeaver-Relationenschema als echtes ER-Modell behandeln.


Datenbanken - Praktische Umsetzung

Question:
# SQL-Muster: Länder mehrfach
Welche Abfrage findet Länder, die mehr als einmal vorkommen?

Answer:
```sql
SELECT country, COUNT(*) AS count
FROM customer
GROUP BY country
HAVING COUNT(*) > 1;
```

Warum `HAVING`? Die Bedingung bezieht sich auf die Gruppe nach `GROUP BY`, nicht auf einzelne Zeilen.

Übungsklausur S. 2; Zusammenfassung §6.6


Datenbanken - Praktische Umsetzung

Question:
# SQL-Muster: Alben eines Künstlers
Wie fragst du Alben eines bestimmten Künstlers ab?

Answer:
```sql
SELECT a.title
FROM album a
JOIN artist ar ON ar.artist_id = a.artist_id
WHERE ar.name = 'AC/DC';
```

Join-Bedingung verbindet Fremdschlüssel `album.artist_id` mit Primärschlüssel `artist.artist_id`; Filter auf Künstlernamen gehört in `WHERE`.

Zusammenfassung §13.2; mögliche Klausurfragen


Datenbanken - Praktische Umsetzung

Question:
# SQL-Muster: Duplikate finden
Wie findest du doppelte Werte in einer Spalte?

Answer:
```sql
SELECT email, COUNT(*) AS anzahl
FROM customer
GROUP BY email
HAVING COUNT(*) > 1;
```

Allgemeines Muster: Gruppiere nach der zu prüfenden Spalte und filtere Gruppen mit Anzahl größer als 1.


Datenbanken - Praktische Umsetzung

Question:
# SQL-Muster: fehlende Partner
Wie findest du Datensätze ohne passenden Partner?

Answer:
Typisches `LEFT JOIN ... IS NULL`-Muster:

```sql
SELECT c.customer_id
FROM customer c
LEFT JOIN invoice i ON i.customer_id = c.customer_id
WHERE i.invoice_id IS NULL;
```

Bedeutung: Alle Kunden, für die kein passender Rechnungsdatensatz existiert.


Datenbanken - Praktische Umsetzung

Question:
# SQL-Muster: sichere Änderung
Wie formulierst du eine sichere Preisänderung?

Answer:
```sql
UPDATE track
SET unit_price = unit_price * 1.10
WHERE genre_id = 1;
```

Vorher sinnvoll prüfen:

```sql
SELECT COUNT(*)
FROM track
WHERE genre_id = 1;
```

Die `WHERE`-Bedingung ist Teil der fachlichen Lösung.


Datenbanken - Praktische Umsetzung

Question:
# CHECK Constraint
Wie formulierst du eine einfache fachliche Wertebedingung?

Answer:
```sql
CREATE TABLE product (
  product_id INTEGER PRIMARY KEY,
  price NUMERIC(10, 2) NOT NULL,
  CONSTRAINT chk_product_price CHECK (price >= 0)
);
```

`CHECK` eignet sich für Regeln innerhalb einer Zeile, z. B. Preis nicht negativ.


Datenbanken - Praktische Umsetzung

Question:
# DEFAULT
Wann ist `DEFAULT` sinnvoll?

Answer:
`DEFAULT` setzt einen Standardwert, wenn beim `INSERT` kein Wert angegeben wird.

```sql
CREATE TABLE genre (
  genre_id INTEGER PRIMARY KEY,
  name VARCHAR(120) DEFAULT 'Untitled Genre'
);
```

Wenn die Regel komplexer ist oder vom Ereignis abhängt, kann ein Trigger passender sein.

Zusammenfassung §4.4; Übungsklausur Trigger


Datenbanken - Praktische Umsetzung

Question:
# Normalisierung vs Cassandra
Warum ist Normalisierung dort nicht immer das Ziel?

Answer:
Relationale Modellierung vermeidet Redundanz und nutzt Joins. Cassandra optimiert auf verteilte, schnelle Abfragen ohne freie Joins.

Deshalb wird bewusst denormalisiert:

- Daten nach Abfrage speichern
- Redundanz akzeptieren
- Partition Key passend zum Zugriff wählen

RDBMS-Normalformen nicht blind auf Cassandra übertragen.


Datenbanken - Praktische Umsetzung

Question:
# RDBMS oder NoSQL?
Wann ist ein relationales DBMS meist besser?

Answer:
Relational passt besonders gut bei:

- klar strukturierten Daten
- komplexen Ad-hoc-Abfragen
- Joins über mehrere Entitäten
- starken Transaktionen und Integritätsregeln
- ausgereiftem SQL-Reporting

NoSQL ist keine pauschale Verbesserung, sondern eine Architekturentscheidung.


Datenbanken - Praktische Umsetzung

Question:
# Code-to-Data und DB-seitige Funktionen
Wie hängen sie zusammen?

Answer:
Beide bringen Verarbeitung näher an die Daten.

- DB-seitige Functions/Procedures/Trigger kapseln Logik direkt im DBMS.
- Code-to-Data verlagert rechenintensive Verarbeitung zur Datenbank, um Datenbewegung zu reduzieren.

Tradeoff: Performance und Zentralisierung gegen DB-Kopplung und schwierigere Tests.


Datenbanken - Praktische Umsetzung

Question:
# Prüfungs-Merksatz SQL
Welcher Merksatz hilft bei fast jeder SQL-Aufgabe?

Answer:
**Erst die Datenbasis, dann die Zeilen, dann die Gruppen, dann die Ausgabe.**

Übersetzt:

```text
FROM/JOIN -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER/LIMIT
```

Damit vermeidest du viele Fehler bei Joins, Aggregaten und Ergebnisermittlung.