Ottimizzazione delle prestazioni dell'applicazione

Introduzione

Con applicazioni QlikView di piccole e medie dimensioni la progettazione dell'applicazione, ai fini delle prestazioni, non rappresenta mai un problema. Con l'aumentare della quantità di dati, tuttavia, i limiti di tempo e memoria possono diventare notevolmente evidenti se l'applicazione non è stata progettata in modo ottimale. È possibile migliorare le prestazioni in modo sostanziale con alcune semplici modifiche di progettazione. Questa appendice fornisce una descrizione di alcuni comuni trabocchetti e ne suggerisce i rimedi.

In generale, le prestazioni vengono migliorate trasferendo i "problemi" dagli oggetti delle applicazioni al database gestito da script. Questo è un compromesso abbastanza ricorrente. I tempi di risposta risultano migliorati e la capacità dedicata ridotta. I suggerimenti riportati di seguito non devono tuttavia essere visti come soluzioni generali ed è consigliabile utilizzarli se migliorano lo stato generale dell'applicazione o se in acune situazioni fanno una piccola, ma sostanziale, differenza.

Nell'elenco riportato di seguito è possibile esaminare alcuni esempi di metodi che vengono applicati per la gestione dei problemi indicati in precedenza. Il loro scopo è illustrare il problema e fornire indicazioni per l'utilizzo ottimale di QlikView. Non è possibile ricavare suggerimenti generali sull'efficacia di un metodo rispetto ad un altro, tuttavia l'ordine degli esempi è indicativo.

If ( Condition(Text),....)

In genere, le clausole if, che includono confronti di testo, comportano un utilizzo intensivo delle risorse. Tra le possibili soluzioni rientrano il mapping del testo su numeri, ad esempio utilizzando autonumber (vedere gli esempi nel paragrafo precedente) e/o l'esecuzione di un test nello script.

L'esecuzione di test di stringhe di testo è un'operazione più lenta rispetto al test numerico. Considerare l'espressione

If (Alfa= ‘ABC’, ‘ABC’, left (Alfa, 2))

Il test può essere eseguito direttamente nello script senza alcuna perdita di flessibilità.

Load

*,

If (Alfa = ‘ABC’, 1, 0) as Flag

resident table_1 ;

L'espressione diventa

If ( Flag = 1,’ABC’, left (Alfa, 2))

e il test diventa molto più semplice.

Sum ( If (Condition, ‘FieldName’…))

In questo caso, l'aggregazione è indipendente dalle dimensioni della tabella e il risultato è distribuito sulle dimensioni della tabella stessa. Il problema può essere risolto eseguendo il test nello script e l'aggregazione nella tabella o effettuando l'intera operazione a livello di script. A tale proposito sono disponibili numerose tecniche, ad esempio interval match, group by, peek, if....then....else.

Questo caso richiede due passaggi: il test della "condizione" e l'aggregazione del risultato. Prendendo l'esempio precedente e aggiungendo l'aggregazione

Sum ( If (Alfa= ‘ABC’, Num*1.25 , Num) )

Load

*,

If (Alfa = ‘ABC’, 1, 0) as Flag

resident table_1 ;

L'espressione diventa

Sum ( If ( Flag = 1, Num* 1.25 , Num ) )

L'aggregazione può essere effettuata direttamente nello script, come illustrato di seguito:

table_2:

Load

*,

If (Alfa = ‘ABC’, 1, 0) as Flag

resident table_1 ;

table_3:

Load

Alfa,

If ( Flag = 1, Num* 1.25 , Num ) as NewNum

resident table_2 ;

 

table_4:

Load

Alfa,

Sum( NewNum ) as SumNum

resident table_3

group by Alfa ;

Nota: L'aggregazione viene effettuata su Alfa perché si tratta della dimensione nel test.

If ( Condition, Sum(‘FieldName’)..)

Questa costruzione viene inclusa qui solo per sottolineare la differenza con il caso precedente. Questa aggregazione è completamente contestuale e in genere non causa problemi di prestazioni.

If ( Condition1, Sum(‘FieldName’), If (Condition2, Sum(‘FieldName’).....

La logica nidificata di If...then else... è concettualmente semplice, ma spesso risulta complicata da gestire. In precedenza sono stati esaminati casi con centinaia di livelli di nidificazione, che comportano un uso intensivo di CPU e memoria. Spesso queste "condizioni" possono essere sostituite trasformandole. Un esempio tipico è l'aggregazione di quantità*prezzo dove prezzo è una variabile. Questa aggregazione può essere gestita con una corrispondenza estesa di intervalli. Se devono essere soddisfatte due condizioni, ad esempio “A AND B”, il test può essere sostituito da una condizione “C“.

Esempio:

sum((GAC12_STD_COST * GAC15_EXCHANGE_RATE) * GIV24_DISP_QTY)

Replaces

Sum(

If((GAC12_EFCT_DT<= GIV23_REJ_DT and

GAC12_EXPIRE_DT>GIV23_REJ_DT) and

(GAC15_EFCT_DT<= GIV23_REJ_DT and GAC15_EXPIRE_DT>GIV23_REJ_DT),

GAC12_STD_COST * GAC15_EXCHANGE_RATE) * GIV24_DISP_QTY,

Null()))

and

Sum(

If(GAC12_EFCT_DT<= GIV23_REJ_DT,

If(GAC12_EXPIRE_DT>GIV23_REJ_DT,

If(GAC15_EFCT_DT<= GIV23_REJ_DT,

If(GAC15_EXPIRE_DT>GIV23_REJ_DT,

(GAC12_STD_COST * GAC15_EXCHANGE_RATE) * GIV24_DISP_QTY,

Null())))))

Leggendo i campi GAC12_STD_COST e GAC15_EXCHANGE_RATE come dimensioni che subiscono modifiche lentamente.

Vedere: Uso della sintassi intervalmatch estesa per risolvere i problemi di rallentamento nella modifica delle dimensioni

Ordinamento del testo

QlikView stabilisce automaticamente se un campo deve essere trattato come numerico, di testo o generale. L'ordinamento dei campi di testo è l'operazione più lenta e può essere sostituita con l'operazione manuale in base all'ordine di caricamento. Se l'ordinamento delle caselle di elenco non è necessario, disattivarlo.

QlikView esegue l'ordinamento delle stringhe di caratteri e numeri misti in ordine alfanumerico. Vale a dire, i numeri vengono ordinati in base al valore, mentre i valori non numerici vengono ordinati in base al metodo ASCII, diversamente dall'ordinamento tradizionale basato esclusivamente sul metodo ASCII. Esempio:

Ordinamento ASCII Ordinamento alfanumerico
A1 A1
A10 A4
A11 A5
A30 A6
A4 A10
A5 A11
A6 A30

Didascalie dinamiche e oggetti di testo

Le espressioni calcolate in modo dinamico possono essere immesse in qualsiasi punto in cui è possibile immettere anche testo. Le risorse richieste per la valutazione di una qualsiasi espressione dipendono tuttavia dal suo ambiente. Le espressioni nei grafici e nelle tabelle che sono definite nella finestra di dialogo dell'espressione vengono calcolate solo quando l'oggetto è visibile e i dati cambiano. Ad esempio, non vengono calcolate quando l'oggetto è ridotto a icona.

D'altra parte, se viene calcolato il titolo dell'oggetto, il calcolo viene eseguito ogni volta che si apporta una modifica. Esistono molti metodi per definire le condizioni di visualizzazione, le condizioni di calcolo e così via. Anche questi test verranno eseguiti sempre.

Alcune espressioni sono più dispendiose di altre e diventano più dispendiose quante più volte vengono valutate. L'introduzione del calcolo asincrono ha modificato questo tipo di funzionamento; è possibile che gli effetti risultino più evidenti nelle applicazioni.

Le funzioni di tempo, ad esempio Now() e Today(), vengono valutate ogni volta in cui è necessario un ricalcolo. Specialmente la funzione Now() può diventare particolarmente dispendiosa in termini di risorse, perché determina un ricalcolo dell'applicazione ogni secondo.

Ad esempio:

If ( ReloadTime()+3>Now(), 'Old Data', 'New Data')

È possibile prendere in considerazione

If ( ReloadTime()+3>Today(), 'Old Data', 'New Data')

Per eseguire un semplice test, inserire le espressioni nelle caselle di testo, quindi provare a dimensionare la casella di testo inserendo Now().

Eventi di Avvio Macro (“on change”)

È possibile impostare le macro affinché vengano attivate da qualsiasi evento in corso nell'applicazione. Prestare attenzione agli eventi ricorrenti o in cascata, dove un evento attiva il successivo, il quale a sua volta attiva il successivo e così via.