jleibl/ihk-ausbildung
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: IHK Ausbildung materials

Browse Source
This commit is contained in:
Jan-Marlon Leibl
2026-03-13 11:46:08 +01:00
commit eb4a13ef7c
67 changed files with 11361 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
1-Ausbildungsjahr/LF3-Datenbanken/LF3-00-Übersicht.md Normal file
View File

@@ -0,0 +1,43 @@
# Lernfeld 3: Datenbanken entwickeln
## Übersicht
Dieses Lernfeld behandelt die Entwicklung und Verwaltung von Datenbanken.
## Themen
| Nr. | Thema | Beschreibung |
|-----|-------|-------------|
| 3.1 | [[LF3-01-Datenbankgrundlagen|Datenbankgrundlagen]] | Grundbegriffe, DBMS, Datenmodelle |
| 3.2 | [[LF3-02-Datenmodellierung|Datenmodellierung]] | ER-Modell, Normalisierung |
| 3.3 | [[LF3-03-SQL-Grundlagen|SQL-Grundlagen]] | SELECT, INSERT, UPDATE, DELETE |
| 3.4 | [[LF3-04-SQL-Abfragen|SQL-Abfragen]] | JOINs, Aggregatfunktionen, Unterabfragen |
| 3.5 | [[LF3-05-Datenbankmanagement|Datenbankmanagement]] | Rechte, Sicherheit, Backup |
## Lernziele
- Datenbanken konzipieren und modellieren
- SQL-Abfragen erstellen
- Datenbanken verwalten und absichern
## Voraussetzungen
- LF1: Unternehmen und Rolle
- LF2: Arbeitsplätze ausstatten
## Prüfungsrelevanz
- Teil 1 Abschlussprüfung (schriftlich)
- Teil 2 Abschlussprüfung (praktisch)
---
## Querverweise
- [[LF2-06-Beschaffung|Zurück: Beschaffung und Inbetriebnahme]]
- [[LF4-IT-Sicherheit|Nächstes Lernfeld: IT-Sicherheit]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Datenschutz]]
---
*Stand: 2024*

127
1-Ausbildungsjahr/LF3-Datenbanken/LF3-01-Datenbankgrundlagen.md Normal file
View File

@@ -0,0 +1,127 @@
# 3.1 Datenbankgrundlagen
## Was ist eine Datenbank?
Eine Datenbank ist eine **strukturierte Sammlung von Daten**, die elektronisch gespeichert und verwaltet werden.
### Vorteile gegenüber Dateisystem
| Dateisystem | Datenbank |
|-------------|-----------|
| Redundanz | Keine/reduzierte Redundanz |
| Inkonsistenzen | Datenkonsistenz |
| Zugriffskontrollle | Integrierte Rechteverwaltung |
| Parallelzugriff | Concurrent Access |
| Datensicherung | Backup/Recovery |
---
## Datenbankmanagementsystem (DBMS)
### Funktionen
```
DBMS - Kernfunktionen
├── Datendefinition (DDL)
├── Datenmanipulation (DML)
├── Zugriffskontrolle
├── Transaktionsmanagement
├── Datenintegrität
└── Datensicherung
```
### DBMS-Typen
| Typ | Beispiele | Einsatz |
|-----|-----------|----------|
| Relational | MySQL, PostgreSQL, Oracle | Standard |
| Dokumentenorientiert | MongoDB | Unstrukturierte Daten |
| Key-Value | Redis | Caching |
| Graph | Neo4j | Netzwerke |
### Relationale Datenbanken
```
Relationales Modell
├── Tabelle (Relation)
├── Zeile (Tupel/Datensatz)
├── Spalte (Attribut)
├── Primärschlüssel
└── Fremdschlüssel
```
---
## Datenbankarchitektur
### Dreischichtenarchitektur
```
Architektur
├── Externe Ebene (Benutzersicht)
├── Konzeptionelle Ebene (logisches Modell)
└── Interne Ebene (physikalische Speicherung)
```
### ANSI-SPARC-Architektur
| Ebene | Beschreibung |
|-------|-------------|
| Extern | Benutzeransichten |
| Konzeptuell | Gesamtsicht der DB |
| Intern | Speicherstrukturen |
---
## Datenmodelle
### Hierarchisches Modell
```
Baumstruktur
Root
├── Kind1
│ └── Enkel1
└── Kind2
```
### Netzwerkmodell
```
Netzstruktur
Knoten1 ←→ Knoten2 ←→ Knoten3
```
### Relationales Modell
```
Tabellenmodell
Kunde (ID, Name, Adresse)
↓
Bestellung (ID, Kunde_ID, Datum)
```
---
## Wichtige Begriffe
| Begriff | Erklärung |
|---------|-----------|
| **Tabelle** | Sammlung von Datensätzen |
| **Datensatz** | Eine Zeile in einer Tabelle |
| **Attribut** | Eine Spalte in einer Tabelle |
| **Primärschlüssel** | Eindeutige ID eines Datensatzes |
| **Fremdschlüssel** | Verweis auf andere Tabelle |
| **Index** | Beschleunigt den Zugriff |
| **Sicht (View)** | Gespeicherte Abfrage |
---
## Querverweise
- [[LF3-02-Datenmodellierung|Nächstes Thema: Datenmodellierung]]
- [[LF5-03-Programmierung|Programmierung]]
---
*Stand: 2024*

174
1-Ausbildungsjahr/LF3-Datenbanken/LF3-02-Datenmodellierung.md Normal file
View File

@@ -0,0 +1,174 @@
# 3.2 Datenmodellierung
## ER-Modell (Entity-Relationship)
Das ER-Modell ist ein **konzeptionelles Datenmodell** zur Beschreibung von Datenstrukturen.
### Grundbegriffe
```
ER-Modell - Komponenten
├── Entitäten (Entities)
├── Beziehungen (Relationships)
└── Attribute (Eigenschaften)
```
### Entitäten
Eine Entität ist ein **Objekt der realen Welt**, das eindeutig identifizierbar ist.
| Entität | Beispiel |
|---------|----------|
| Person | Kunde, Mitarbeiter |
| Ding | Produkt, Auto |
| Konzept | Bestellung, Rechnung |
### Attribute
Attribute beschreiben **Eigenschaften** von Entitäten.
```
Attribute - Typen
├── Einfachwertig
├── Mehrwertig (z.B. Telefonnummern)
├── Zusammengesetzt (z.B. Adresse)
└── Abgeleitet (z.B. Alter aus Geburtsdatum)
```
### Beziehungen (Relationships)
Beziehungen verknüpfen Entitäten miteinander.
```
Beziehungsgrade
├── 1:1 (One-to-One)
├── 1:n (One-to-Many)
└── n:m (Many-to-Many)
```
---
## ER-Diagramm
### Symbole
```
Notation (Chen-Notation)
Rechteck → Entität
Raute → Beziehung
Ellipse → Attribut
Unterstrich → Primärschlüssel
Doppel ellipse → Mehrwertiges Attribut
```
### Kardinalitäten
| Symbol | Bedeutung |
|--------|-----------|
| 1 | Genau eins |
| N | Eins bis viele |
| 0..1 | Null bis eins |
| 0..N | Null bis viele |
### Beispiel: Webshop
```
ER-Diagramm - Webshop
Kunde ──────── Bestellung ──────── Produkt
(1) (1..n) (1) (1..n) (1) (1..n)
Kunde: {Kunden_ID (PK), Name, E-Mail, Adresse}
Bestellung: {Bestell_ID (PK), Kunden_ID (FK), Datum, Status}
Produkt: {Produkt_ID (PK), Name, Preis, Kategorie}
BestellPosition: {Bestell_ID (FK), Produkt_ID (FK), Menge}
```
---
## Normalisierung
Normalisierung reduziert **Redundanz** und vermeidet **Anomalien**.
### Normalformen
```
Normalisierungsstufen
├── 1. Normalform (1NF)
├── 2. Normalform (2NF)
├── 3. Normalform (3NF)
└── Boyce-Codd-Normalform (BCNF)
```
### 1. Normalform (1NF)
**Bedingung**: Jedes Attribut enthält nur atomare (unteilbare) Werte.
```
Nicht 1NF:
Bestellung | Produkte
-----------|------------------
1 | A, B, C
1NF:
Bestellung | Produkt
-----------|----------
1 | A
1 | B
1 | C
```
### 2. Normalform (2NF)
**Bedingung**: 1NF erfüllt + jedes Nicht-Schlüssel-Attribut ist vom gesamten Primärschlüssel abhängig.
### 3. Normalform (3NF)
**Bedingung**: 2NF erfüllt + keine transitiven Abhängigkeiten.
```
Nicht 3NF:
{Student_ID, Kurs_ID} → {Note} → {Bewertungstext}
3NF:
{Student_ID, Kurs_ID} → {Note}
{Note} → {Bewertungstext}
```
---
## Übung: Datenmodell erstellen
### Aufgabenstellung
Erstelle ein ER-Diagramm für eine Bibliothek:
- Bücher können ausgeliehen werden
- Kunden leihen Bücher aus
- Ein Buch hat mehrere Exemplare
### Lösung
```
Entitäten:
- Kunde (Kunden_ID, Name, Adresse)
- Buch (ISBN, Titel, Autor, Verlag)
- Exemplar (Exemplar_ID, ISBN, Status)
- Ausleihe (Ausleihe_ID, Kunden_ID, Exemplar_ID, Datum)
Beziehungen:
- Kunde (1) ─── (0..n) Ausleihe
- Exemplar (1) ─── (0..1) Ausleihe
- Buch (1) ─── (1..n) Exemplar
```
---
## Querverweise
- [[LF3-01-Datenbankgrundlagen|Zurück: Datenbankgrundlagen]]
- [[LF3-03-SQL-Grundlagen|Nächstes Thema: SQL-Grundlagen]]
---
*Stand: 2024*

235
1-Ausbildungsjahr/LF3-Datenbanken/LF3-03-SQL-Grundlagen.md Normal file
View File

@@ -0,0 +1,235 @@
# 3.3 SQL-Grundlagen
## Was ist SQL?
**SQL** (Structured Query Language) ist die Standardsprache für die Kommunikation mit relationalen Datenbanken.
### SQL-Teilsprachen
```
SQL - Kategorien
├── DDL (Data Definition Language)
│ ├── CREATE → Objekte erstellen
│ ├── ALTER → Objekte ändern
│ └── DROP → Objekte löschen
├── DML (Data Manipulation Language)
│ ├── SELECT → Daten abfragen
│ ├── INSERT → Daten einfügen
│ ├── UPDATE → Daten ändern
│ └── DELETE → Daten löschen
├── DCL (Data Control Language)
│ ├── GRANT → Rechte vergeben
│ └── REVOKE → Rechte entziehen
└── TCL (Transaction Control Language)
├── COMMIT → Transaktion abschließen
├── ROLLBACK → Transaktion zurücksetzen
└── SAVEPOINT → Speicherpunkt
```
---
## Datentypen
### Numerisch
| Datentyp | Beschreibung | Bereich |
|----------|-------------|---------|
| INT | Ganzzahl | -2 Mrd. bis 2 Mrd. |
| DECIMAL(p,s) | Dezimalzahl | p= Stellen, s= Nachkommastellen |
| FLOAT | Gleitkommazahl | ~7 Stellen |
| DOUBLE | Doppelte Präzision | ~15 Stellen |
### Zeichenketten
| Datentyp | Beschreibung | max. Länge |
|----------|-------------|-------------|
| CHAR(n) | Festlänge | 255 |
| VARCHAR(n) | Variable Länge | 65.535 |
| TEXT | Langer Text | 65.535+ |
| LONGTEXT | Sehr langer Text | 4 GB |
### Datum/Zeit
| Datentyp | Beschreibung |
|----------|-------------|
| DATE | Datum (JJJJ-MM-TT) |
| TIME | Zeit (HH:MM:SS) |
| DATETIME | Datum + Zeit |
| TIMESTAMP | Unix-Zeitstempel |
---
## DDL - Datenbankobjekte erstellen
### Tabelle erstellen (CREATE TABLE)
```sql
CREATE TABLE Kunde (
Kunden_ID INT PRIMARY KEY,
Vorname VARCHAR(50) NOT NULL,
Nachname VARCHAR(50) NOT NULL,
E-Mail VARCHAR(100) UNIQUE,
Geburtsdatum DATE,
Erstellt_AM TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
### Tabelle ändern (ALTER TABLE)
```sql
-- Spalte hinzufügen
ALTER TABLE Kunde ADD Telefon VARCHAR(20);
-- Spalte ändern
ALTER TABLE Kunde MODIFY E-Mail VARCHAR(150);
-- Spalte löschen
ALTER TABLE Kunde DROP COLUMN Telefon;
```
### Tabelle löschen (DROP TABLE)
```sql
DROP TABLE Kunde;
```
---
## DML - Daten bearbeiten
### Daten einfügen (INSERT)
```sql
-- Einzelne Zeile
INSERT INTO Kunde (Kunden_ID, Vorname, Nachname, E-Mail)
VALUES (1, 'Max', 'Mustermann', 'max@example.com');
-- Mehrere Zeilen
INSERT INTO Kunde (Kunden_ID, Vorname, Nachname)
VALUES
(2, 'Anna', 'Schmidt'),
(3, 'Peter', 'Müller');
```
### Daten ändern (UPDATE)
```sql
-- Ein Datensatz
UPDATE Kunde
SET E-Mail = 'max.neu@example.com'
WHERE Kunden_ID = 1;
-- Mehrere Datensätze
UPDATE Kunde
SET Nachname = 'Meier'
WHERE Nachname = 'Müller';
```
### Daten löschen (DELETE)
```sql
-- Bestimmte Zeilen
DELETE FROM Kunde WHERE Kunden_ID = 1;
-- Alle Zeilen (Tabelle bleibt)
DELETE FROM Kunde;
```
---
## SELECT - Daten abfragen
### Grundstruktur
```sql
SELECT -- Was?
Spalten
FROM -- Woher?
Tabelle
WHERE -- Filter
Bedingung
ORDER BY -- Sortierung
Spalte;
```
### Einfache Abfragen
```sql
-- Alle Spalten
SELECT * FROM Kunde;
-- Bestimmte Spalten
SELECT Vorname, Nachname FROM Kunde;
-- Mit Alias
SELECT Vorname AS 'Vorname', Nachname AS 'Nachname' FROM Kunde;
```
### WHERE-Klausel
```sql
-- Einfache Bedingung
SELECT * FROM Kunde WHERE Nachname = 'Mustermann';
-- Vergleichsoperatoren
SELECT * FROM Kunde WHERE Alter >= 18;
SELECT * FROM Produkt WHERE Preis > 100 AND Preis < 500;
-- LIKE (Mustervergleich)
SELECT * FROM Kunde WHERE Name LIKE 'M%'; -- beginnt mit M
SELECT * FROM Kunde WHERE Name LIKE '%er%'; -- enthält 'er'
SELECT * FROM Kunde WHERE Name LIKE '___'; -- genau 3 Zeichen
-- IN (in Liste)
SELECT * FROM Kunde WHERE Stadt IN ('Berlin', 'Hamburg', 'München');
-- BETWEEN (Bereich)
SELECT * FROM Produkt WHERE Preis BETWEEN 100 AND 500;
```
---
## Übung: SQL-Grundlagen
### Aufgaben
1. Erstelle eine Tabelle "Produkt" mit ID, Name, Preis, Kategorie
2. Füge 3 Produkte ein
3. Ändere den Preis des ersten Produkts auf 99,99
4. Lösche das teuerste Produkt
### Lösung
```sql
-- 1. Tabelle erstellen
CREATE TABLE Produkt (
Produkt_ID INT PRIMARY KEY,
Name VARCHAR(100),
Preis DECIMAL(10,2),
Kategorie VARCHAR(50)
);
-- 2. Daten einfügen
INSERT INTO Produkt VALUES
(1, 'Laptop', 1299.99, 'Elektronik'),
(2, 'Maus', 29.99, 'Zubehör'),
(3, 'Tastatur', 79.99, 'Zubehör');
-- 3. Preis ändern
UPDATE Produkt SET Preis = 99.99 WHERE Produkt_ID = 1;
-- 4. Teuerstes löschen
DELETE FROM Produkt WHERE Preis = (SELECT MAX(Preis) FROM Produkt);
```
---
## Querverweise
- [[LF3-02-Datenmodellierung|Zurück: Datenmodellierung]]
- [[LF3-04-SQL-Abfragen|Nächstes Thema: SQL-Abfragen]]
- [[LF6-04-Sicherheit-Web|Sicherheit: SQL-Injection]]
---
*Stand: 2024*

263
1-Ausbildungsjahr/LF3-Datenbanken/LF3-04-SQL-Abfragen.md Normal file
View File

@@ -0,0 +1,263 @@
# 3.4 SQL-Abfragen
## JOINs - Tabellen verknüpfen
JOINs verbinden Daten aus mehreren Tabellen.
### Arten von JOINs
```
JOIN-Typen
├── INNER JOIN
├── LEFT OUTER JOIN
├── RIGHT OUTER JOIN
├── FULL OUTER JOIN
└── CROSS JOIN
```
### INNER JOIN
Gibt nur übereinstimmende Zeilen zurück.
```sql
-- Syntax
SELECT spalten
FROM tabelle1
INNER JOIN tabelle2 ON tabelle1.spalte = tabelle2.spalte;
-- Beispiel: Kunden mit Bestellungen
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
INNER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
-- Kurzschreibweise (impliziter Join)
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde, Bestellung
WHERE Kunde.Kunden_ID = Bestellung.Kunden_ID;
```
### LEFT OUTER JOIN
Gibt alle Zeilen der linken Tabelle zurück.
```sql
-- Alle Kunden, auch ohne Bestellung
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
LEFT OUTER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
```
### RIGHT OUTER JOIN
Gibt alle Zeilen der rechten Tabelle zurück.
```sql
-- Alle Bestellungen, auch ohne Kunden
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
RIGHT OUTER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
```
### Mehrere JOINs
```sql
SELECT
Kunde.Name,
Bestellung.Datum,
Produkt.Name AS Produkt
FROM Kunde
INNER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID
INNER JOIN BestellPosition ON Bestellung.Bestell_ID = BestellPosition.Bestell_ID
INNER JOIN Produkt ON BestellPosition.Produkt_ID = Produkt.Produkt_ID;
```
---
## Aggregatfunktionen
Aggregatfunktionen fassen mehrere Zeilen zu einem Ergebnis zusammen.
| Funktion | Beschreibung | Beispiel |
|----------|-------------|----------|
| COUNT() | Anzahl der Zeilen | COUNT(*) |
| SUM() | Summe | SUM(Preis) |
| AVG() | Durchschnitt | AVG(Preis) |
| MIN() | Minimum | MIN(Preis) |
| MAX() | Maximum | MAX(Preis) |
### Beispiele
```sql
-- Anzahl der Kunden
SELECT COUNT(*) AS AnzahlKunden FROM Kunde;
-- Summe aller Bestellungen
SELECT SUM(Gesamtbetrag) AS Gesamtumsatz FROM Bestellung;
-- Durchschnittspreis
SELECT AVG(Preis) AS Durchschnittspreis FROM Produkt;
-- Minimale/Maximale Bestellung
SELECT MIN(Gesamtbetrag) AS KleinsteBestellung,
MAX(Gesamtbetrag) AS GrößteBestellung
FROM Bestellung;
```
---
## GROUP BY - Gruppierung
Gruppiert Ergebnisse nach bestimmten Kriterien.
```sql
-- Umsatz pro Kunde
SELECT Kunden_ID, SUM(Gesamtbetrag) AS Umsatz
FROM Bestellung
GROUP BY Kunden_ID;
-- Anzahl Bestellungen pro Kunde
SELECT Kunden_ID, COUNT(*) AS AnzahlBestellungen
FROM Bestellung
GROUP BY Kunden_ID;
-- Umsatz pro Kategorie
SELECT Kategorie, SUM(Preis) AS Gesamtumsatz
FROM Produkt
GROUP BY Kategorie;
```
### HAVING - Filter nach Aggregation
```sql
-- Kunden mit mehr als 3 Bestellungen
SELECT Kunden_ID, COUNT(*) AS Anzahl
FROM Bestellung
GROUP BY Kunden_ID
HAVING COUNT(*) > 3;
```
---
## Unterabfragen (Subqueries)
Unterabfragen sind verschachtelte SELECT-Anweisungen.
### Skalar-Unterabfrage
Gibt einen einzelnen Wert zurück.
```sql
-- Alle Produkte, die teurer als der Durchschnitt sind
SELECT Name, Preis
FROM Produkt
WHERE Preis > (SELECT AVG(Preis) FROM Produkt);
```
### Unterabfrage mit IN
```sql
-- Kunden, die mindestens eine Bestellung haben
SELECT Name
FROM Kunde
WHERE Kunden_ID IN (SELECT Kunden_ID FROM Bestellung);
```
### Korrelierte Unterabfrage
Referenziert Spalten der äußeren Abfrage.
```sql
-- Produkte mit dem höchsten Preis pro Kategorie
SELECT Name, Preis, Kategorie
FROM Produkt p1
WHERE Preis = (
SELECT MAX(Preis)
FROM Produkt p2
WHERE p1.Kategorie = p2.Kategorie
);
```
---
## ORDER BY - Sortierung
```sql
-- Aufsteigend (Standard)
SELECT * FROM Produkt ORDER BY Preis;
-- Absteigend
SELECT * FROM Produkt ORDER BY Preis DESC;
-- Mehrere Sortierspalten
SELECT * FROM Bestellung
ORDER BY Datum DESC, Gesamtbetrag DESC;
```
---
## LIMIT / TOP - Ergebnismenge begrenzen
```sql
-- MySQL/MariaDB
SELECT * FROM Produkt ORDER BY Preis DESC LIMIT 10;
-- SQL Server
SELECT TOP 10 * FROM Produkt ORDER BY Preis DESC;
-- PostgreSQL
SELECT * FROM Produkt ORDER BY Preis DESC LIMIT 10;
```
---
## Übung: Komplexe Abfragen
### Ausgangsdaten
```sql
-- Kunden (ID, Name, Stadt)
-- Bestellungen (ID, Kunden_ID, Datum, Gesamtbetrag)
-- BestellPositionen (Bestell_ID, Produkt_ID, Menge, Preis)
```
### Aufgaben
1. Finde die 5 umsatzstärksten Kunden
2. Liste alle Bestellungen mit Kundenname
3. Zeige den durchschnittlichen Bestellwert pro Stadt
### Lösungen
```sql
-- 1. Top 5 Kunden
SELECT K.Name, SUM(B.Gesamtbetrag) AS Umsatz
FROM Kunde K
JOIN Bestellung B ON K.Kunden_ID = B.Kunden_ID
GROUP BY K.Kunden_ID, K.Name
ORDER BY Umsatz DESC
LIMIT 5;
-- 2. Bestellungen mit Kundenname
SELECT B.Bestell_ID, K.Name, B.Datum, B.Gesamtbetrag
FROM Bestellung B
JOIN Kunde K ON B.Kunden_ID = K.Kunden_ID
ORDER BY B.Datum DESC;
-- 3. Durchschnittsbestellwert pro Stadt
SELECT K.Stadt, AVG(B.Gesamtbetrag) AS Durchschnitt
FROM Kunde K
JOIN Bestellung B ON K.Kunden_ID = B.Kunden_ID
GROUP BY K.Stadt;
```
---
## Querverweise
- [[LF3-03-SQL-Grundlagen|Zurück: SQL-Grundlagen]]
- [[LF3-05-Datenbankmanagement|Nächstes Thema: Datenbankmanagement]]
- [[LF5-03-Programmierung|Programmierung]]
---
*Stand: 2024*

245
1-Ausbildungsjahr/LF3-Datenbanken/LF3-05-Datenbankmanagement.md Normal file
View File

@@ -0,0 +1,245 @@
# 3.5 Datenbankmanagement
## Benutzerverwaltung
### Benutzer erstellen
```sql
-- MySQL/MariaDB
CREATE USER 'benutzer'@'localhost' IDENTIFIED BY 'passwort';
-- PostgreSQL
CREATE USER benutzer WITH PASSWORD 'passwort';
```
### Rechte vergeben (GRANT)
```sql
-- Alle Rechte auf eine Datenbank
GRANT ALL PRIVILEGES ON datenbank.* TO 'benutzer'@'localhost';
-- Nur Leserechte
GRANT SELECT ON datenbank.tabelle TO 'benutzer'@'localhost';
-- Mehrere Rechte
GRANT SELECT, INSERT, UPDATE ON datenbank.tabelle TO 'benutzer'@'localhost';
```
### Rechte entziehen (REVOKE)
```sql
REVOKE INSERT ON datenbank.tabelle FROM 'benutzer'@'localhost';
```
### Rollen (PostgreSQL)
```sql
-- Rolle erstellen
CREATE ROLE leser;
-- Rechte zuweisen
GRANT SELECT ON tabelle TO leser;
-- Rolle zu Benutzer
GRANT leser TO benutzer;
```
---
## Transaktionen
Transaktionen garantieren die **ACID-Eigenschaften**.
```
ACID - Eigenschaften
├── Atomicity (Atomarität)
├── Consistency (Konsistenz)
├── Isolation (Isolierung)
└── Durability (Dauerhaftigkeit)
```
### Transaktionssteuerung
```sql
-- Transaktion starten (implizit bei vielen DBMS)
START TRANSACTION;
-- Änderungen speichern
COMMIT;
-- Änderungen zurücknehmen
ROLLBACK;
-- Sicherungspunkt setzen
SAVEPOINT speicherpunkt1;
```
### Beispiel: Überweisung
```sql
START TRANSaktion;
-- Geld abbuchen
UPDATE Konto SET Kontostand = Kontostand - 100
WHERE Konto_ID = 1;
-- Geld gutschreiben
UPDATE Konto SET Kontostand = Kontostand + 100
WHERE Konto_ID = 2;
-- Wenn alles OK, speichern
COMMIT;
-- Bei Fehler: alles zurücksetzen
ROLLBACK;
```
---
## Datensicherung (Backup)
### Backup-Typen
| Typ | Beschreibung |
|-----|-------------|
| Vollbackup | Alle Daten sichern |
| Inkrementell | Nur Änderungen seit letztem Backup |
| Differentiell | Änderungen seit Vollbackup |
### MySQL/MariaDB
```bash
# Vollbackup
mysqldump -u root -p datenbank > backup.sql
# Mehrere Datenbanken
mysqldump -u root -p --databases db1 db2 > backup.sql
# Wiederherstellen
mysql -u root -p datenbank < backup.sql
```
### PostgreSQL
```bash
# Vollbackup
pg_dump -U benutzer datenbank > backup.sql
# Wiederherstellen
psql -U benutzer datenbank < backup.sql
```
### Backup-Strategie
```
Backup-Plan
├── Täglich: Inkrementelles Backup
├── Wöchentlich: Vollbackup
├── Monatlich: Archivierung
└── Offsite: Externe Speicherung
```
---
## Datenbankoptimierung
### Indizes
Indizes beschleunigen den Zugriff auf Daten.
```sql
-- Index erstellen
CREATE INDEX idx_name ON tabelle (spalte);
-- Zusammengesetzter Index
CREATE INDEX idx_name ON tabelle (spalte1, spalte2);
-- Eindeutiger Index
CREATE UNIQUE INDEX idx_email ON tabelle (email);
-- Index löschen
DROP INDEX idx_name ON tabelle;
```
### EXPLAIN - Abfrage analysieren
```sql
-- Ausführungsplan anzeigen
EXPLAIN SELECT * FROM tabelle WHERE spalte = 'wert';
-- MySQL
EXPLAIN FORMAT=JSON SELECT * FROM tabelle WHERE spalte = 'wert';
```
### Optimierungstipps
| Tipp | Beschreibung |
|------|-------------|
| INDEX verwenden | Für WHERE-Joins und -Spalten |
| SELECT * vermeiden | Nur benötigte Spalten |
| JOINs minimieren | Nicht mehr als nötig |
| Wildcards vermeiden | `LIKE '%wert'` ist langsam |
---
## Datensicherheit
### SQL Injection verhindern
```sql
-- NICHT SO: Direkte Eingabe
SELECT * FROM benutzer WHERE name = '" + eingabe + "'
-- BESSER: Prepared Statements
PREPARE stmt FROM 'SELECT * FROM benutzer WHERE name = ?';
SET @name = eingabe;
EXECUTE stmt USING @name;
```
### Verschlüsselung
```
Verschlüsselungsebenen
├── Transport Layer Security (TLS)
├── Transparent Data Encryption (TDE)
└── Spaltenweise Verschlüsselung
```
---
## Monitoring
### MySQL/MariaDB
```sql
-- Aktuelle Verbindungen
SHOW PROCESSLIST;
-- Statusvariablen
SHOW STATUS LIKE 'Connections';
SHOW STATUS LIKE 'Threads%';
-- Langsame Abfragen
SHOW VARIABLES LIKE 'slow_query_log';
```
### Wichtige Metriken
| Metrik | Beschreibung |
|--------|-------------|
| Connection Usage | Aktive Verbindungen |
| Query Cache | Cache-Trefferquote |
| Lock Waits | Warteschlangen |
| Buffer Pool | Speicherauslastung |
---
## Querverweise
- [[LF3-04-SQL-Abfragen|Zurück: SQL-Abfragen]]
- [[LF4-IT-Sicherheit|Sicherheit: Zugriffskontrolle]]
- [[Wissen/Wirtschafts-Sozialkunde/WISO-Zusammenfassung|WISO: Datenschutz]]
---
*Stand: 2024*