Was kannst Du über Performance Tuning in Qlik Sense lernen?

Nach diesem Guide kannst Du:

1. Memory-Optimierung mit AutoNumber durchführen
2. Optimized QVD Loads nutzen (100x Speedup!)
3. Expressions performance-optimiert schreiben

Wie funktioniert das Prinzip: Measure Before Optimize in Qlik Sense?

Was sind die Performance-Bereiche im Überblick für Qlik Sense?

Wie kann QVD Optimization als Game Changer für Qlik Sense wirken?

Was sind die Unterschiede zwischen Optimized und Non-Optimized Loads?

// ❌ NON-OPTIMIZED - Langsam!
LOAD
    CustomerID,
    Upper(CustomerName) as CustomerName,  // Transformation!
    Country,
    Sales
FROM [DataCustomers.qvd] (qvd);

// ✓ OPTIMIZED - 100x schneller!
LOAD
    CustomerID,
    CustomerName,  // Keine Transformation
    Country,
    Sales
FROM [DataCustomers.qvd] (qvd);

Erklärung:

• Optimized Load: Qlik lädt Daten direkt aus QVD in Memory
• Non-Optimized: Qlik muss jede Zeile einzeln verarbeiten
• Performance-Unterschied: 10-100x!

Wann ist QVD Load optimiert?

Wie funktioniert das Pattern: Two-Step Load in der Performance Tuning von Qlik Sense?

// STEP 1: Optimized Load aus QVD
TEMP_Customers:
LOAD
    CustomerID,
    CustomerName,
    Country
FROM [QVDCustomers.qvd] (qvd)
WHERE EXISTS(CustomerID);  // Bleibt optimized!

// STEP 2: Transformationen in Preceding Load
Customers:
LOAD
    CustomerID,
    Upper(CustomerName) as CustomerName,  // Jetzt transformieren
    Country,
    If(Country = 'Germany', 'DE', Country) as CountryCode
RESIDENT TEMP_Customers;

DROP TABLE TEMP_Customers;

Erklärung:

• Step 1: Optimized Load – nur relevante Daten, super schnell
• Step 2: Transformationen auf kleinerem Dataset
• Result: Beste Performance!

Wie verbessert WHERE EXISTS() die Performance in Qlik Sense?

// SCHRITT 1: Lade Facts (definiert EXISTS-Pool)
Facts_Sales:
LOAD
    OrderID,
    CustomerID,  // Definiert: Welche CustomerIDs existieren
    ProductID,
    Sales
FROM [QVDSales.qvd] (qvd);

// SCHRITT 2: Lade nur relevante Customers
Dim_Customer:
LOAD
    CustomerID,
    CustomerName,
    Country
FROM [QVDCustomers.qvd] (qvd)
WHERE EXISTS(CustomerID);  // Nur Customers mit Sales!

Erklärung:

• Ohne WHERE EXISTS: 1 Million Customers geladen
• Mit WHERE EXISTS: 50,000 Customers (nur die mit Sales)
• Impact: 95% weniger Daten, viel schneller!

Wie kann ich die Memory Optimization in Qlik Sense verbessern?

Wie kann man Symbol Tables in Qlik Sense verstehen?

Qlik speichert jeden eindeutigen Wert nur einmal:

// CustomerID als String: "C00001", "C00002", ...
// Memory: 7 bytes × 1,000,000 rows = 7 MB

// CustomerID als Number: 1, 2, 3, ...
// Memory: 4 bytes × 1,000,000 rows = 4 MB
// Savings: 43%!

Wie optimiert man die Key-Generierung mit AutoNumber() in Qlik Sense?

// ❌ OHNE AutoNumber - String Keys
LOAD
    CustomerID,      // "CUST-00001" = 11 bytes
    OrderID,         // "ORD-123456" = 11 bytes
    ProductID,       // "PROD-ABC-123" = 13 bytes
    Sales
FROM Sales.csv;

// ✓ MIT AutoNumber - Integer Keys
LOAD
    AutoNumber(CustomerID, 'Customer') as CustomerKey,  // 1,2,3,... = 4 bytes
    AutoNumber(OrderID, 'Order') as OrderKey,
    AutoNumber(ProductID, 'Product') as ProductKey,
    Sales
FROM Sales.csv;

Erklärung:

• AutoNumber(): Konvertiert Strings zu Integers
• Second Parameter: Context (verschiedene IDs nicht vermischen)
• Memory Savings: 40-60% bei großen Fact Tables!

Was sind die besten Praktiken für AutoNumber in Qlik Sense?

//============================================
// TRANSFORM LAYER: Keys generieren
//============================================

// Customers
TRF_Customers:
LOAD
    AutoNumber(CustomerID, 'Customer') as CustomerKey,
    CustomerID as CustomerID_Original,  // Original behalten
    CustomerName,
    Country
FROM [QVDSTG_Customers.qvd] (qvd);

// Sales Fact
TRF_Sales:
LOAD
    AutoNumber(OrderID, 'Order') as OrderKey,
    AutoNumber(CustomerID, 'Customer') as CustomerKey,  // Gleicher Context!
    AutoNumber(ProductID, 'Product') as ProductKey,
    Sales,
    Quantity
FROM [QVDSTG_Sales.qvd] (qvd);

Wie kann man Expression Optimization in Qlik Sense optimieren?

Wie funktioniert Set Analysis mit IF() in Qlik Sense?

// ❌ LANGSAM: IF() iteriert über alle Zeilen
Sum(If(Year = 2024, Sales))
Sum(If(Country = 'Germany' and Year = 2024, Sales))

// ✓ SCHNELL: Set Analysis nutzt Index
Sum({<Year={2024}>} Sales)
Sum({<Country={'Germany'}, Year={2024}>} Sales)

Performance-Unterschied: 5-10x schneller!

Wie funktioniert Pre-Calculation im Script für Performance Tuning in Qlik Sense?

// ❌ LANGSAM: Berechnung in jedem Chart
// Chart Expression:
Sum(Sales) / Sum(TOTAL Sales)  // TOTAL ist teuer!

// ✓ SCHNELL: Im Script vorberechnen
// Script:
LOAD
    OrderID,
    Sales,
    Sales / Sum(TOTAL Sales) as SalesPercent  // Einmal berechnen
FROM Sales.csv;

// Chart Expression:
Sum(SalesPercent)  // Nur noch Summe!

Wie kann man Flags statt IF() im Frontend verwenden?

// Script: Flags vorbereiten
LOAD
    OrderID,
    Sales,
    OrderDate,

    // Flags für häufige Filter
    If(Year(OrderDate) = Year(Today()), 1, 0) as IsCurrentYear,
    If(Sales > 1000, 1, 0) as IsHighValue,
    If(Month(OrderDate) = Month(Today()), 1, 0) as IsCurrentMonth
FROM Sales.csv;

// ❌ Frontend LANGSAM:
Sum(If(Year(OrderDate) = Year(Today()), Sales))

// ✓ Frontend SCHNELL:
Sum(Sales * IsCurrentYear)
// oder mit Set Analysis:
Sum({<IsCurrentYear={1}>} Sales)

Wie kann man AGGR() effizient nutzen?

// ❌ LANGSAM: AGGR() in Chart
Sum(AGGR(
    If(Sum(Sales) > 10000, Sum(Sales), 0),
    Customer
))

// ✓ SCHNELL: Im Script vorberechnen
// Script:
CustomerSales:
LOAD
    Customer,
    Sum(Sales) as CustomerSales
FROM Sales
GROUP BY Customer;

SalesWithFlag:
LOAD
    *,
    If(CustomerSales > 10000, CustomerSales, 0) as HighValueSales
RESIDENT CustomerSales;

// Chart:
Sum(HighValueSales)  // Einfach!

Wie kann ich Model Optimization in Qlik Sense optimieren?

Was ist das Star Schema und wie optimiert es die Struktur?

//============================================
// OPTIMAL: Star Schema
//============================================

// Facts in der Mitte
Facts_Sales:
LOAD
    OrderID,
    CustomerKey,  // Link zu Dim
    ProductKey,   // Link zu Dim
    DateKey,      // Link zu Dim
    Sales,
    Quantity
FROM [QVDTRF_Sales.qvd] (qvd);

// Dimensions drum herum
Dim_Customer:
LOAD
    CustomerKey,
    CustomerName,
    Country,
    Region
FROM [QVDTRF_Customer.qvd] (qvd);

Dim_Product:
LOAD
    ProductKey,
    ProductName,
    Category,
    Brand
FROM [QVDTRF_Product.qvd] (qvd);

Performance-Vorteile:

• Schnellere Aggregationen
• Geringerer Memory-Verbrauch
• Bessere Query-Performance

Wie kann man Synthetic Keys vermeiden?

// ❌ PROBLEM: Synthetic Keys
Orders:
LOAD OrderID, CustomerID, ProductID, Sales FROM Orders.csv;

OrderDetails:
LOAD OrderID, CustomerID, ProductID, Quantity FROM Details.csv;
// → Qlik erstellt $Syn1 (OrderID+CustomerID+ProductID)

// ✓ LÖSUNG: Qualifizieren oder eindeutige Keys
Orders:
LOAD
    OrderID,
    CustomerID,
    ProductID,
    Sales
FROM Orders.csv;

OrderDetails:
LOAD
    OrderID,              // Nur gemeinsamer Key!
    Quantity
FROM Details.csv;

Wie kann ich Profiling mit Operations Monitor in Qlik Sense durchführen?

// Aktiviere Profiling im Script
SET vProfiler = 1;

// Dein Code...

// Operations Monitor zeigt:
// - Execution Time pro LOAD-Statement
// - Memory Usage pro Tabelle
// - QVD Read Times

QMC → Operations Monitor:

• App Performance → Reload Time
• Session Performance → Chart Response Times
• Memory Usage per App

Wie erstelle ich eine Performance Checklist für Qlik Sense?

✓ QVD Optimization:

• [ ] Nutze Optimized Loads (keine Transformationen im FROM)
• [ ] WHERE EXISTS() für Dimension-Filtering
• [ ] Two-Step Load Pattern bei Bedarf

✓ Memory Optimization:

• [ ] AutoNumber() für alle Keys im Transform Layer
• [ ] Original-IDs für Debugging behalten
• [ ] Memory Usage mit Operations Monitor prüfen

✓ Expression Optimization:

• [ ] Set Analysis statt IF() wo möglich
• [ ] Flags im Script statt Berechnungen im Frontend
• [ ] AGGR() sparsam einsetzen

✓ Model Optimization:

• [ ] Star Schema statt Snowflake
• [ ] Synthetic Keys vermeiden
• [ ] Facts und Dimensions klar trennen

Wie kann ich Quick Wins für die Performance-Tuning in Qlik Sense nutzen?

1. Optimized Loads aktivieren (5 Min):

// Transformationen raus aus FROM-Clause
// Vorher:
LOAD *, Upper(Name) FROM Data.qvd (qvd);
// Nachher:
LOAD * FROM Data.qvd (qvd);
NoConcatenate
LOAD *, Upper(Name) RESIDENT temp;

2. WHERE EXISTS() hinzufügen (10 Min):

// Bei Dimensions die zu Facts linken
LOAD * FROM Customers.qvd (qvd)
WHERE EXISTS(CustomerID);

3. AutoNumber für Keys (15 Min):

// Im Transform Layer
LOAD AutoNumber(CustomerID, 'Customer') as CustomerKey, *
FROM STG_Customers.qvd (qvd);

Wie kann ich die Performance-Messung in Qlik Sense optimieren?

Wie kann man die Reload-Time in Qlik Sense messen?

LET vStartTime = Now(1);
TRACE ======================================;
TRACE RELOAD STARTED: $(vStartTime);
TRACE ======================================;

// ... Dein Load-Code ...

LET vEndTime = Now(1);
LET vDuration = Interval(vEndTime - vStartTime, 'hh:mm:ss');
TRACE ======================================;
TRACE RELOAD COMPLETED: $(vEndTime);
TRACE Duration: $(vDuration);
TRACE ======================================;

Wie messe ich die Tabellen-Size in Qlik Sense?

SUB LogTableSize(pTableName)
    LET vRows = NoOfRows('$(pTableName)');
    LET vFields = NoOfFields('$(pTableName)');

    TRACE [TABLE SIZE] $(pTableName);
    TRACE   - Rows: $(vRows);
    TRACE   - Fields: $(vFields);
END SUB

CALL LogTableSize('Facts_Sales');
CALL LogTableSize('Dim_Customer');

Wie behebt man Probleme beim Performance Tuning in Qlik Sense?

// Check im Script Log:
// "4 fields found: X,Y,Z,... 12,345 lines fetched"
// Wenn "Optimized" NICHT steht → Non-Optimized!

// Häufige Ursachen:
// - Transformation im FROM (Upper, Date, etc.)
// - WHERE mit Funktion statt literal
// - Preceding Load über QVD

// Check Table Memory in Document Properties
// Wenn Keys (CustomerID, etc.) viel Memory → AutoNumber nutzen

LOAD
    AutoNumber(CustomerID, 'Customer') as CustomerKey,
    // ... andere Felder
FROM Customers.qvd (qvd);

// Ersetze IF() mit Set Analysis
// Vorher:
Sum(If(Year = 2024, Sales))

// Nachher:
Sum({<Year={2024}>} Sales)

// Oder: Flag im Script
// Script:
If(Year = 2024, 1, 0) as IsYear2024
// Chart:
Sum(Sales * IsYear2024)

Wie kann ich den Performance-Tuning Workflow in Qlik Sense optimieren?

Phase 1: Messen (1 Tag)

1. Baseline erfassen: Reload-Time, Memory, Chart Response
2. Operations Monitor analysieren
3. Bottlenecks identifizieren

Phase 2: Quick Wins (1-2 Tage)

1. Optimized Loads aktivieren
2. WHERE EXISTS() hinzufügen
3. AutoNumber für Keys

Phase 3: Deep Optimization (1 Woche)

1. Model Review (Star Schema?)
2. Expression Optimization
3. Incremental Loads implementieren

Phase 4: Monitoring (laufend)

1. Operations Monitor regelmäßig prüfen
2. Performance-Trends tracken
3. Bei Regression analysieren

Was sind die nächsten Schritte zur Optimierung von Qlik Sense?

Du kannst jetzt Qlik-Apps systematisch optimieren! Als nächstes:

1. Deployment: Optimierte Apps ausrollen. Deployment zeigt wie.

2. Three-Stage Architecture: Optimization-Points pro Layer. Three-Stage kombinieren.

Slug: qlik-performance-tuning
Keywords: Qlik Performance Tuning, Qlik Memory Optimization, AutoNumber Qlik, Optimized QVD Loads, WHERE EXISTS Qlik, Set Analysis Performance, Qlik Expression Optimization, Star Schema Qlik, Operations Monitor Qlik