# Datenbank-Schema-Updates

## Problem
Sequelize erstellt bei jedem `sync()` mit `alter: true` die Constraints neu, was zu Duplikaten und Problemen führen kann.

## Lösung

### 1. Intelligente Schema-Synchronisation (Standard)
```javascript
// In utils/sequelize.js - syncModelsWithUpdates()
// Prüft automatisch ob Schema-Updates nötig sind
// Verwendet alter: true nur bei Bedarf
await syncModelsWithUpdates(models);
```
- **Automatische Erkennung** von Schema-Updates
- **alter: true nur bei Bedarf** - verhindert Duplikate
- **Fallback** zu alter: false wenn keine Updates nötig
- **Sicher und effizient**

### 2. Normale Synchronisation (ohne Updates)
```javascript
// In utils/sequelize.js - syncModels()
await model.sync({ alter: false, force: false });
```
- **Keine Schema-Änderungen**
- **Keine Constraints werden neu erstellt**
- **Schnell und sicher**

### 3. Manuelle Schema-Updates (nur bei Bedarf)
```javascript
// In utils/sequelize.js - updateSchema()
await model.sync({ alter: true, force: false });
```
- **Nur bei expliziten Schema-Änderungen verwenden**
- **Kann zu Duplikaten führen**
- **Nach Update: Zurück zu intelligenter Synchronisation**

### 4. Vollständiger Reset (nur in Entwicklung)
```javascript
await model.sync({ force: true });
```
- **Löscht alle Daten!**
- **Nur in Entwicklungsumgebung verwenden**

## Aktuelle Implementierung

### Intelligente Synchronisation
```javascript
// syncModelsWithUpdates() prüft automatisch:
// 1. Alle verfügbaren Schemas (community, falukant_data, match3, etc.)
// 2. Alle Tabellen in jedem Schema
// 3. Alle Spalten in jeder Tabelle
// 4. Datentypen, Constraints und Standardwerte
// 5. Verwendet alter: true nur wenn nötig
```

### Universelle Schema-Prüfung
```javascript
// checkSchemaUpdates() prüft alle Schemas:
// - community (Benutzer, Rechte, etc.)
// - falukant_data (Spieldaten)
// - falukant_type (Spieltypen)
// - falukant_predefine (Vordefinierte Daten)
// - falukant_log (Spiel-Logs)
// - chat (Chat-System)
// - forum (Forum-System)
// - match3 (Match3-Spiel)
// - logs (Allgemeine Logs)
// - type (Allgemeine Typen)
// - service (Service-Daten)
```

### Detaillierte Tabellen-Prüfung
```javascript
// checkTableForUpdates() prüft jede Tabelle:
// - Fehlende Spalten
// - Neue Spalten
// - Geänderte Spalten
// - Model-zu-Tabelle-Zuordnung
```

### Umfassende Spalten-Prüfung
```javascript
// checkColumnForUpdates() prüft jede Spalte:
// - Datentyp-Änderungen (INTEGER → BIGINT)
// - NULL/NOT NULL Constraints
// - Standardwerte
// - Längen-Änderungen (VARCHAR)
```

## Workflow für Schema-Updates

### Schritt 1: Schema ändern
```javascript
// In models/.../model.js
// Neue Felder, Constraints, etc. hinzufügen
```

### Schritt 2: Automatische Erkennung
```javascript
// syncModelsWithUpdates() erkennt automatisch:
// - Welche Updates nötig sind
// - Verwendet alter: true nur bei Bedarf
// - Läuft bei jedem Start sicher
```

### Schritt 3: Keine manuellen Änderungen nötig
```javascript
// Die intelligente Synchronisation:
// - Erkennt Änderungen automatisch
// - Wendet sie sicher an
// - Verhindert Duplikate
```

## Constraint-Bereinigung

### Analyse ausführen
```bash
cd backend
node utils/cleanupDatabaseConstraints.js
```

### Manuelle Bereinigung
```sql
-- Doppelte Foreign Keys entfernen
ALTER TABLE schema.table_name DROP CONSTRAINT constraint_name;

-- Doppelte Indexe entfernen
DROP INDEX IF EXISTS index_name;
```

## Best Practices

1. **Intelligente Synchronisation verwenden** - `syncModelsWithUpdates()`
2. **Keine manuellen Schema-Updates** bei jedem Start
3. **updateSchema() nur bei komplexen Änderungen** verwenden
4. **Constraints regelmäßig prüfen** auf Duplikate
5. **Backup vor Schema-Updates** erstellen

## Aktuelle Konfiguration

- **Standard-Synchronisation**: `syncModelsWithUpdates()` (intelligent)
- **Schema-Updates**: Automatisch erkannt und angewendet
- **Manuelle Updates**: Separate `updateSchema()` Funktion
- **Automatische Updates**: Aktiviert und sicher
- **Manuelle Kontrolle**: Verfügbar bei Bedarf

## Troubleshooting

### Problem: Duplizierte Constraints
```bash
# Analyse ausführen
node utils/cleanupDatabaseConstraints.js

# Manuell bereinigen
# Siehe SQL-Beispiele oben
```

### Problem: Schema-Synchronisation schlägt fehl
```javascript
// Intelligente Synchronisation sollte das automatisch handhaben
// Bei Problemen: updateSchema() verwenden
await updateSchema(models);
```

### Problem: Performance-Probleme
- **Intelligente Synchronisation** läuft nur bei Bedarf
- **alter: true** wird nur verwendet wenn nötig
- **Normale Starts** sind schnell und sicher

## Vorteile der neuen Lösung

1. **Automatisch**: Erkennt Schema-Updates automatisch
2. **Sicher**: Verwendet alter: true nur bei Bedarf
3. **Effizient**: Normale Starts ohne Schema-Updates
4. **Flexibel**: Kann für verschiedene Modelle erweitert werden
5. **Wartbar**: Klare Trennung zwischen Update-Logik und Synchronisation