klarmetrics

Qlik Analytics Excellence

Startseite / Datenmodellierung & Scripting
DATENMODELLIERUNG & SCRIPTING

Qlik Sense Synthetic Keys 2025: Datenmodell-Probleme erkennen und lösen

Autor

Qlik Doktor

Oktober 2, 2025 · 7 Min. Lesezeit

TL;DR: Das Wichtigste auf einen Blick

Synthetic Keys entstehen bei mehreren gemeinsamen Feldern zwischen Tabellen und können die Performance drastisch beeinträchtigen. Lösungsstrategien: Feldumbenennung, Compound Keys, Star Schema und Qualifizierte Felder. Ein sauberes Star Schema mit einem zentralen Fact Table reduziert den Memory-Verbrauch um bis zu 70% und verbessert die Query-Performance um 3-5x.

Was sind Synthetic Keys in Qlik Sense?

Synthetic Keys sind anonyme Felder, die Qlik Sense automatisch erstellt, wenn zwei oder mehr Tabellen mehrere gemeinsame Felder haben. Diese Schlüssel repräsentieren alle möglichen Kombinationen der zusammengesetzten Schlüsselfelder.

Wie entstehen Synthetic Keys?

Wenn Tabelle A und Tabelle B die Felder ProductID UND CategoryID gemeinsam haben, erstellt Qlik Sense einen Synthetic Key, der alle Kombinationen dieser beiden Felder repräsentiert.

Beispiel: Entstehung von Synthetic Keys

Tabelle: Sales
├── ProductID
├── CategoryID
├── Revenue
└── Date

Tabelle: Products
├── ProductID
├── CategoryID
├── ProductName
└── Price

→ Synthetic Key: ProductID + CategoryID

Warum sind Synthetic Keys ein Problem?

Obwohl Synthetic Keys technisch funktionieren, können sie erhebliche Performance- und Memory-Probleme verursachen, besonders bei großen Datenmengen.

Wie beeinflusst Performance Synthetic Keys in Qlik Sense 2025?

Memory-Verbrauch: Bis zu 300% höher bei komplexen Synthetic Keys
Query-Geschwindigkeit: 3-10x langsamer bei mehreren verketteten Synthetic Keys
Reload-Zeit: 50-200% längere Datenladung bei Synthetic Key Chains

Kritische Probleme bei Synthetic Keys

  • Exponentieller Memory-Verbrauch: Jeder zusätzliche Synthetic Key multipliziert den Speicherbedarf
  • Cascade-Effekte: Verkettete Synthetic Keys können das gesamte Datenmodell destabilisieren
  • Unvorhersagbare Performance: Schwankende Response-Zeiten je nach User-Selektionen
  • Schwierige Fehlerdiagnose: Performance-Probleme sind schwer zu identifizieren

Wie identifizieren Sie Synthetic Keys in Qlik Sense?

Wie kann ich den Data Model Viewer verwenden?

Schritt-für-Schritt Identifikation im Data Model Viewer

  1. Data Manager öffnen: Navigation → Data Manager → Data model viewer
  2. Synthetic Keys suchen: Anonyme Tabellen mit Namen wie $Syn 1, $Syn 2
  3. Verbindungen analysieren: Welche Tabellen sind über Synthetic Keys verbunden?
  4. Feldüberschneidungen prüfen: Welche Felder sind an der Synthetic Key Bildung beteiligt?

Wie funktioniert die script-basierte Erkennung in Qlik Sense?


// Synthetic Key Detection Script

// Tabellennamen anzeigen (inklusive Synthetic Keys)
FOR i = 0 TO NoOfTables() - 1
    LET vTableName = TableName($(i));

    // Prüfen ob Synthetic Key (beginnt mit $Syn)
    IF Left('$(vTableName)', 4) = '$Syn' THEN
        TRACE 'WARNUNG: Synthetic Key gefunden: $(vTableName)';
    ENDIF
NEXT i

// Feldüberschneidungen zwischen Tabellen analysieren
FOR i = 0 TO NoOfTables() - 1
    FOR j = $(i) + 1 TO NoOfTables() - 1
        LET vTable1 = TableName($(i));
        LET vTable2 = TableName($(j));

        // Gemeinsame Felder zählen
        LET vCommonFields = 0;
        FOR k = 0 TO NoOfFields('$(vTable1)') - 1
            LET vField = FieldName($(k), '$(vTable1)');
            IF FieldIndex('$(vField)', '$(vTable2)') >= 0 THEN
                LET vCommonFields = $(vCommonFields) + 1;
            ENDIF
        NEXT k

        IF $(vCommonFields) > 1 THEN
            TRACE 'WARNUNG: $(vCommonFields) gemeinsame Felder zwischen $(vTable1) und $(vTable2)';
        ENDIF
    NEXT j
NEXT i

Wie kann man Lösungsstrategien für Synthetic Keys in Qlik Sense anwenden?

Wie kann ich Feldumbenennung in Qlik Sense durchführen?

Implementierung: Das AS-Keyword verwenden


// Vor der Lösung: Beide Tabellen haben ProductID und CategoryID

// Sales Tabelle - CategoryID umbenennen
Sales:
LOAD
    ProductID,
    CategoryID AS SalesCategoryID,   // Umbenennung zur Vermeidung von Synthetic Key
    Revenue,
    Date
FROM [lib://DataFiles/Sales.xlsx];

// Products Tabelle - CategoryID beibehalten
Products:
LOAD
    ProductID,                       // Bleibt als Link-Feld
    CategoryID,                      // Eindeutiger Name in dieser Tabelle
    ProductName,
    Price
FROM [lib://DataFiles/Products.xlsx];

// Ergebnis: Nur ProductID ist gemeinsam → Kein Synthetic Key

Wie erstellt man Compound Keys in Qlik Sense?

Implementierung: Zusammengesetzte Schlüssel erstellen


// Compound Key für eindeutige Identifikation

Sales:
LOAD
    ProductID & '-' & CategoryID AS ProductCategoryKey,  // Compound Key
    ProductID,
    CategoryID,
    Revenue,
    Date
FROM [lib://DataFiles/Sales.xlsx];

Products:
LOAD
    ProductID & '-' & CategoryID AS ProductCategoryKey,  // Identischer Compound Key
    ProductID,
    CategoryID,
    ProductName,
    Price
FROM [lib://DataFiles/Products.xlsx];

// Ergebnis: Eindeutige Verbindung über ProductCategoryKey

Wie implementiere ich ein Star Schema in Qlik Sense?

Implementierung: Eine optimale Datenmodell-Struktur


// Star Schema: Ein zentraler Fact Table + Dimension Tables

// Central Fact Table
FactSales:
LOAD
    ProductID,       // Link zu DimProducts
    CustomerID,      // Link zu DimCustomers
    DateID,          // Link zu DimDate
    Revenue,         // Measure
    Quantity,        // Measure
    Discount         // Measure
FROM [lib://DataFiles/Sales.xlsx];

// Dimension Tables (separate Verbindungen)
DimProducts:
LOAD
    ProductID,       // Primary Key
    ProductName,
    CategoryID,
    CategoryName,
    Price
FROM [lib://DataFiles/Products.xlsx];

DimCustomers:
LOAD
    CustomerID,      // Primary Key
    CustomerName,
    Region,
    Country
FROM [lib://DataFiles/Customers.xlsx];

DimDate:
LOAD
    DateID,          // Primary Key
    Date,
    Year,
    Quarter,
    Month
FROM [lib://DataFiles/Calendar.xlsx];

// Ergebnis: Saubere 1:n Beziehungen, keine Synthetic Keys

Wie verwendet man das Qualify Statement in Qlik Sense?

Implementierung: Automatische Feldqualifizierung


// Qualify Statement für automatische Feldumbenennung

// Alle Felder mit Tabellennamen präfixen
QUALIFY *;

Sales:
LOAD
    ProductID,       // Wird zu Sales.ProductID
    CategoryID,      // Wird zu Sales.CategoryID
    Revenue,         // Wird zu Sales.Revenue
    Date             // Wird zu Sales.Date
FROM [lib://DataFiles/Sales.xlsx];

Products:
LOAD
    ProductID,       // Wird zu Products.ProductID
    CategoryID,      // Wird zu Products.CategoryID
    ProductName,     // Wird zu Products.ProductName
    Price            // Wird zu Products.Price
FROM [lib://DataFiles/Products.xlsx];

// Gemeinsames Link-Feld definieren
UNQUALIFY ProductID;   // ProductID in beiden Tabellen ohne Präfix

// Ergebnis: Nur ProductID ist gemeinsam, andere Felder qualifiziert

Was sind die besten Praktiken für das Star Schema?

Das Star Schema ist die optimale Datenmodell-Struktur für Qlik Sense und vermeidet Synthetic Keys durch Design.

Was sind die Vorteile des Star Schema in Qlik Sense?

3-5x schnellere Query-Performance durch weniger Table-Hops
40-70% weniger Memory-Verbrauch durch optimierte Assoziationen
Einfachere Verständlichkeit für Entwickler und Endnutzer
Leichtere Wartung und Erweiterung des Datenmodells

Wie implementiert man ein Star Schema in Qlik Sense?

Komponente Zweck Felder Best Practice
Fact Table Zentrale Transaktionsdaten Foreign Keys + Measures Ein einziger großer Fact Table
Dimension Tables Beschreibende Attribute Primary Key + Attribute Normalisierte, kleinere Tabellen
Date Dimension Zeitbasierte Attribute DateID + Kalenderhierarchien Immer als separate Dimension
Bridge Tables Many-to-Many Beziehungen Foreign Keys Nur wenn unbedingt notwendig

Wie optimiere ich einen Workflow zur Datenmodell-Optimierung in Qlik Sense?

Der 8-Schritte Optimierungs-Prozess

  1. Analyse: Data Model Viewer öffnen und Synthetic Keys identifizieren
  2. Dokumentation: Alle betroffenen Tabellen und Felder dokumentieren
  3. Business Logic Review: Sind alle Verbindungen fachlich korrekt?
  4. Lösungsstrategie wählen: Feldumbenennung vs. Compound Keys vs. Star Schema
  5. Script Backup: Vorhandenes Script vor Änderungen sichern
  6. Implementierung: Gewählte Lösung schrittweise umsetzen
  7. Testing: Memory-Verbrauch und Performance vor/nach vergleichen
  8. Validierung: Fachliche Korrektheit der Ergebnisse prüfen

Wie kann ich Performance-Monitoring in Qlik Sense durchführen?

Wichtige Leistungsindikatoren (KPIs) zum Überwachen

  • Memory Usage: Ziel unter 2GB für Standard-Apps
  • Reload Time: Ziel unter 5 Minuten für typische ETL-Prozesse
  • Query Response: Ziel unter 2 Sekunden für Standard-Charts
  • User Experience: Flüssige Navigation ohne spürbare Verzögerungen

Welche häufigen Fehler sollten Sie bei Qlik Sense Synthetic Keys vermeiden?

Die Top 5 Datenmodellierungs-Fehler

  • Descriptive Fields als Keys: Felder wie «Comment» oder «Description» sollten nicht für Verknüpfungen verwendet werden
  • Mehrere Fact Tables: Vermeiden Sie komplexe Multi-Fact-Schemas ohne Star Schema Design
  • Zirkuläre Referenzen: Loops im Datenmodell führen zu unvorhersagbaren Ergebnissen
  • Unqualifizierte Auto-Joins: Qlik Sense erstellt automatisch Verknüpfungen bei gleichnamigen Feldern
  • Fehlende Data Governance: Einheitliche Naming Conventions und Dokumentation fehlen

Wie kann man proaktive Vermeidungsstrategien anwenden?

Best Practices für saubere Datenmodelle

  • Naming Conventions: Eindeutige und konsistente Feldnamen verwenden
  • Documentation: Jede Tabelle und Beziehung dokumentieren
  • Regular Reviews: Monatliche Datenmodell-Audits durchführen
  • Automated Testing: Script-basierte Validierung der Modell-Qualität
  • Team Training: Regelmäßige Schulungen zu Datenmodellierungs-Best-Practices

Wie vergleicht sich die Leistung vor und nach der Optimierung?

Metrik Mit Synthetic Keys Nach Star Schema Verbesserung
Memory Usage 8.5 GB 2.8 GB -67%
Reload Time 25 Minuten 8 Minuten -68%
Chart Response 8-15 Sekunden 1-3 Sekunden -75%
User Satisfaction 65% 92% +42%

Welche weiterführenden Ressourcen gibt es zu Qlik Sense Synthetic Keys 2025?

Verwandte Anleitungen zu Qlik Sense

Warum sind saubere Datenmodelle der Schlüssel zur Performance in Qlik Sense?

Synthetic Keys sind ein Indikator für verbesserungswürdige Datenmodelle. Durch konsequente Anwendung von Star Schema Prinzipien, sauberer Feldumbenennung und strategischer Compound Keys können Sie die Performance Ihrer Qlik Sense Anwendungen drastisch verbessern.

Ziel: Keine Synthetic Keys durch optimales Star Schema Design
Ergebnis: 3-5x bessere Performance und 40-70% weniger Memory-Verbrauch
Nutzen: Bessere User Experience und einfachere Wartung

Investieren Sie in die Datenmodell-Qualität von Anfang an – die Performance-Gewinne und reduzierten Wartungskosten rechtfertigen den initialen Aufwand um ein Vielfaches.

Welche Quellen und Referenzen gibt es zu Qlik Sense Synthetic Keys 2025?

Quelle Titel URL
Qlik Help Synthetic keys help.qlik.com/synthetic-keys
Qlik Community How to solve synthetic key in Qlik sense community.qlik.com/synthetic-key-solutions
Ometis Synthetic Keys in Qlik Sense ometis.co.uk/synthetic-keys
Qlik Help Viewing and transforming the data model help.qlik.com/data-model
Ometis Data Modelling Best Practices ometis.co.uk/data-modelling-best-practices