yourpart3/backend/README_SCHEMA_UPDATES.md

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)

// 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)

// 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)

// 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)

await model.sync({ force: true });

• Löscht alle Daten!
• Nur in Entwicklungsumgebung verwenden

Aktuelle Implementierung

Intelligente Synchronisation

// 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

// 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

// checkTableForUpdates() prüft jede Tabelle:
// - Fehlende Spalten
// - Neue Spalten
// - Geänderte Spalten
// - Model-zu-Tabelle-Zuordnung

Umfassende Spalten-Prüfung

// 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

// In models/.../model.js
// Neue Felder, Constraints, etc. hinzufügen

Schritt 2: Automatische Erkennung

// 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

// Die intelligente Synchronisation:
// - Erkennt Änderungen automatisch
// - Wendet sie sicher an
// - Verhindert Duplikate

Constraint-Bereinigung

Analyse ausführen

cd backend
node utils/cleanupDatabaseConstraints.js

Manuelle Bereinigung

-- 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

# Analyse ausführen
node utils/cleanupDatabaseConstraints.js

# Manuell bereinigen
# Siehe SQL-Beispiele oben

Problem: Schema-Synchronisation schlägt fehl

// 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