Load Scripting

In questa sezione verranno analizzate le procedure classiche di scripting per il caricamento e

trasformazione dei dati.
01.0 Sezioni; 1 11.0 Concatenate Load; 9
1.1 Main; 2 12.0 Associazioni Tabelle
1.2 Control e Sotto Sezioni; 2 12.1 Associazione Keep; 10
02.0 Sezioni; 2 12.2 Inner Join/Keep; 10
03.0 Caricamento Tabelle; 3 12.3 Left Join/Keep; 10
04.0 Load and Select; 3 12.4 Right Join/Keep; 11
05.0 Conversioni Date; 4 12.0 Associazioni Tabelle; 10
06.0 Preceding Load; 5 13.0 Link Table; 11
07.0 Load con costruzione di un campo 14.0 Qualify; 18
misura; 5 15.0 Caricamento da QVD; 20
08.0 Load con Aggregazione; 6 16.0 Variabili; 21
09.0 Mapping; 7
10.0 Resident Loading; 8

Sezioni
Per facilitare la lettura e la gestione degli script di caricamento, è consigliabile la suddivisione dello
stesso attraverso sezioni.
Ogni sezione, a partire dall’alto, viene letta ed eseguita dal motore Qlik durante la fase di Loading.
Main
è la prima sezione generata automaticamente del tool. Sono presenti le configurazioni per le
variabili generali utilizzate dall’app.
È possibile, ad esempio, modificare il separatore decimale inserendo il valore per la variabile
“DecimalSep”.
È consigliabile introdurre una variabile per stabilire la versione dell’app, in maniera tale che
apparirà la versione nei log generati in ogni caricamento, oppure potrà esser mostrata all’interno
dell’app di visualizzazione stessa.
Esempio:

Set v_Version = ‘0.1’;

Ogni qual volta vi saranno modifiche sull’app, la versione dovrà esser incrementata di un valore
decimale. È buona norma incrementare la versione di un valore intero per le app che sono
definitive e caricate in produzione con successo.
Control e Sotto Sezioni
Di norma ogni sessione dovrebbe rappresentare il caricamento o la trasformazione di una singola
tabella.
Verrà inclusa pertanto in una “Subfuction” il quale permetterà l’esecuzione del codice soltanto
dopo il comando per la sua esecuzione.
Tutti i comandi di esecuzione per tutte le varie sotto-funzioni verranno eseguiti in una sezione
finale chiamata “Control”
Esempio:

Sub [Nome Sezione]

[…Script Sezione]

end sub

La sotto-sezione verrà eseguita entro “Control” nel seguente modo:

Call [Nome Sezione]

Commenti
Seguono le rigole classiche di molti linguaggi di programmazione.
Commento di riga  // [Testo Commento]
Commento su più righe  /* [Testo Commento] */
Caricamento Tabelle
Il caricamento dei dati è eseguito tramite le istruzioni di Load e Select.
Qlik non fa alcuna distinzione tra il comando di Load o di Select, i quali, a fine del caricamento,
generano una tabella formata da righe e colonne a partire dai dati caricati.

La procedura standard per il caricamento di una fonte dati da script è la seguente:

 Aprire il Data Load Editor

 Utilizzando il menu a destra “Data Connections” cliccare sull’icona accanto alla

connessione dati desiderata.
 Selezionare dal menù a tendina il Database desiderato (Nota: in alcuni casi vi sarà un solo
database se questo è pre-configurato nella connessione esistente).
 Selezionare l’”Owner” del database
 Selezionare la tabella
 Selezionare i campi desiderati (si può scegliere l’opzione di selezionare tutti i campi o anche
rinominare i suddetti)
 Selezionare campi addizionali da altre tabelle
 Premere “Insert Script”

Possono esser selezionati dati direttamente da altre fonti come, ad esempio, un file Excel sul file
system. In questo caso vi saranno opzioni ulteriori come se includere o meno le intestazioni del
file.
Altre fonti data possono esser: Text Files, HTML Tables, XML, KML, files nativi Qlik quali QVD o
QVX, ecc…
Load Example
Un esempio di Select/Load di una tabella è il seguente.

NetSales:
Load
Key_Sales as Key_Net
,[GrossSales] * [Sales Qty] * (1 - Discount / 100) as NetSales
Resident Sales;
Conversioni Date
Le informazioni relative alle date spesso sono recuperate con diversi formati a seconda
dell’origine.
Una data può esser un testo in un formato particolare: 04/08/1992, Aug-92, ecc.. o in una forma
numerica duale: 1234,38 che verrà tradotta successivamente dal tool come una data specifica.
In Qlik esistono due funzioni di conversione data principali: Date() e Date#().

Tutti i campi data su Qlik, se propriamente formattati, sono duali (numeri con la virgola). Quindi
ognuno di essi ha una forma testuale di rappresentazione visuale come data, ed una forma
numerica sottostante per i calcoli tra le date.
Le funzioni Date() e Date#() manipolano solo la componente duale della data.
Date#(): prende in ingresso una stringa, Date#(‘04/08/1992’), e calcola il valore numerico duale
relativo nello stesso formato stringa originario
Un secondo parametro in ingresso opzionale, permette di definire il formato data voluto,
altrimenti sarà il default (definito nella sezione main)
Date(): prende in ingresso un numero e calcola il componente stringa.
Un secondo parametro in ingresso opzionale, permette di definire come interpretare la
stringa, altrimenti sarà il default (definito nella sezione main)

Esempio:
Caricare una stringa in formato 2015-01-15, da interpretare come una data, e formattare come
15/01/2015
Campo sorgente: OrderDate

Soluzione: Date(Date#([OrderDate],’YYYY-MM-DD’),’DD/MM/YYYY’)  Nota: DD indica i

giorni (con due cifre: 01, 02,03), MM indica i mesi, YYYY indica l’anno (con 4 cifre: 1990,
1991,1992,…)
In questo caso le operazioni eseguite sono le seguenti:
 OrderDate viene caricato  Stringa 2015-01-15 convertita in un valore data
 Viene restituito il valore data modificandone il formato in 15/01/2015

Esistono funzioni equivalenti anche per i formati temporali:

 Time() – Time#(): funzione che ritorna l’orario. Generalmente ss indica i secondi, mm i
minuti, hh l’ora
 Timestamp() – Timestamp#(): funzione che ritorna la data e l’orario

Nota: un mese può esser indicato nel formato letterale attraverso la dicitura MMM. Implica che 04
verrà interpretato come Apr
Preceding Load
Un approccio classico nello script di load è definito come “Preceding Load”.
Consiste nel caricare una tabella utilizzando una sequenza di più istruzioni, con cui, a partire dalla
prima, vengono eseguite diverse trasformazioni quali: carica il dato, modifica il nome della
colonna, esegui un raggruppamento.
L’ordine di esecuzione segue la logica: leggi lo script dall’alto verso il basso, se un’istruzione di
LOAD/SELECT non contiene l’indicazione della fonte del dato allora saltala
Esempio:

// ************** Customers table **************  Commento

Customers:  Nome assegnato alla tabella logica

LOAD  Comando di Load. Non essendovi la

clausola “FROM” verrà eseguito il
comando sottostante prima di
eseguire questo.
Address Vengono caricate solo le colonne
presenti nel comando.
City,
[Company Name],
[Contact Name] as Nome,  Il comando “AS” serve per
rinominare una colonna specifica
Country,
[Customer ID],
[Division ID],
Fax,
Phone,
[Postal Code],
Provincia;

SQL SELECT *  Comando di Select. Essendovi la clausola di

FROM Corso.dbo.Customers;
“FROM” sarà eseguito per primo. Stabilisce il
caricamento dalla sorgente Customers.
La clausola “SQL” determina che il comando sia
eseguito come una query SQL. Il comando “*”
determina di caricare tutte le colonne presenti.
Load con costruzione di un campo misura
È possibile caricare un campo calcolato come nell’esempio seguente.
Da notare che i campi con il nome formato da più parole possono esser indicati racchiudendoli tra
apici (o altri separatori).

NetSales:
LOAD
Key_Sales as Key_Net
,[GrossSales] * [Sales Qty] * (1 - Discount / 100) as NetSales  la Colonna NetSales
sarà formata da un’operazione
aritmetica derivata da altre
colonne presenti nella fonte.
Resident Sales L’operazione sarà eseguita per
ogni riga della tabella. Una
colonna può esser utilizzata e
trasformata più volte,
l’importante è che il nome
finale non sia lo stesso.
WHERE [Sales Qty] > 10;

Load con Aggregazione

È mostrato come caricare un campo colonna formato aggregando più righe tra loro.
In questo caso la tabella è stata raggruppata per chiave primaria Order ID, questa è campo univoco
identificativo nel nostro caso di ogni singolo ordine.
Nell’esempio seguente la tabella risultante sarà formata da due colonne, una indicante la chiave
primaria dell’ordine, Order ID, e l’altra formata dal prodotto delle quantità X prezzo di ogni singolo
ordine.

SELECT
‘Order Details’.’Order ID’,  Il punto sta ad indicare che la
colonna Order ID fa parte della tabella
Order Details
Sum(‘Order Details’.’Unit Price’
* ‘Order Details’.Quantity) as Result  La funzione SUM esegue la somma
algebrica delle due colonne, le quali
sono a loro volta moltiplicate tra loro
FROM ‘Order Details’  Viene eseguita una selezione tra le
due tabelle Order Details ed Orders
, Orders
WHERE Orders.’Order ID’ = ‘Order Details’.’Order ID’  Essendo una selezione tra due
tabelle (Join), viene indicata la logica
per cui le righe di entrambe sono
associate
GROUP BY ‘Order Details’.’Order ID’;
Mapping
Durante il caricamento di una tabella può esser necessario decodificare un campo con dei valori
determinati.
Ed esempio ipotizziamo di avere una tabella formata dagli utenti ed una lista di codici che
identificano la garanzia assicurativa a loro associata.
Possiamo generare automaticamente una nuova colonna che indichi il nome della garanzia a
partire dal codice.

Tabella Utenti:

Codice
Id Utente Nome Garanzia
1 User1 2
2 User2 4
3 User3 1

LOAD
‘ID Utente’
, Nome
, ‘ID Garanzia’
FROM Utenti;

Tabella Garanzia:

ID
Garanzia Garanzia
1 INCENDIO E GARANZIE COMPLEMENTARI
2 DANNI DA ACQUA
3 RICERCA GUASTI
4 EVENTI SPECIALI

In questo esempio la tabella con l’elenco delle garanzie verrà trascritta direttamente nello script.

Garanzie:
Mapping Load * inline  Il comando Inline permette di
definire header e valori della tabella direttamente nello script
[
ID Garanzia | Garanzia  Colonna da decodificare – Colonna
Valore desiderato
1|INCENDIO E GARANZIE COMPLEMENTARI
2|DANNI DA ACQUA
3|RICERCA GUASTI
4|EVENTI SPECIALI
](delimiter is '|');  DELIMITER IS permette di indicare il
delimitatore dei valori per le colonne nel testo inserito (racchiuso da parentesi quadre)
Mapping: tale comando permette di definire la tabella per la mappatura. Una tabella di mapping è
una tabella formata soltanto da due colonne e che verrà usata per la decodifica di un campo
(chiave-valore).
Queste tipologie di tabelle non vengono mostrate nel modello dati e non vengono associate ad
altre tabelle presenti.

Ricarichiamo la tabella degli utenti applicandovi la decodifica.

Utenti:
LOAD  Preceding Load
‘ID Utente’
, Nome as [Nome Utente]  Le parentesi graffe
possono esser un’alternativa all’apice per indicare campi formati da più parole
, ApplyMap('Garanzie', ‘ID Garanzia’) as [Nome Garanzia];  La funzione
ApplyMap esegue la decodifica. Come variabili di ingresso ha:
 Nome della tabella di
mapping: Garanzie
 Colonna nella tabella
di cui verrà eseguita
la decodifica

LOAD
‘ID Utente’
, Nome
, ‘ID Garanzia’
FROM Utenti;

Resident Loading
Ad ogni caricamento Qlik svuota ed elimina tutte le tabelle presenti nel qvf.
Passo dopo passo ognuna di esse verrà caricata per poi avviare il motore associativo e collegare
l’intero data model.
Durante tale caricamento, è possibile richiamare una tabella caricata in una fase precedente,
attraverso il comando Resident.
Esempio:

[Utenti Trasformed]:
LOAD
‘ID Utente’
, Nome
, [Nome Garanzia]
, “Colonna aggiuntiva” as Test  la colonna Test sarà formata da un valore
testuale indicato dai doppi apici (stringa)
RESIDENT Utenti;

Avremmo pertanto nel data model due tabelle: Utenti ed ‘Utenti Trasformed’.
Avendo tali tabelle delle colonne con nomi uguali, l’engine associativo cercherà di collegarle
automaticamente tra loro.
Questo automatismo è da evitare, in quanto è consigliabile che ogni associazione sia guidata da
una colonna Chiave, in maniera da assicurare coerenza ed evitare ridondanza dei dati.
L’ azione più semplice in questo caso, sarà di eliminare la prima tabella in quanto non più utile.

DROP TABLE Utenti;

Concatenate Load
Implicitamente Qlik concatena due tabelle caricate se queste presentano gli stessi identici campi.
Esempio:

LOAD a, b, c from table1.csv;

LOAD a, c, b from table2.csv;

La tabella risultante sarà formata dai campi a, b e c, e conterrà il numero di record somma di
entrambe le tabelle.
Se due tabelle non contengono gli stessi campi identici, si può forzare la concatenazione tramite il
comando “Concatenate”.
Esempio:

LOAD a, b, c from table1.csv;

CONCATENATE LOAD a, c from table2.csv;

La tabella risultante sarà formata dai campi a, b e c, e conterrà il numero di record somma di
entrambe le tabelle.
Il valore del campo b, relativamente alle righe originariamente soltanto nella table2, sarà
valorizzato come vuoto (NULL).
Si può impedire la concatenazione forzata utilizzando il comando NOCONCATENATE.
Esempio:

LOAD a, b, c from table1.csv;

NOCONCATENATE LOAD a, b, c from table2.csv;

Associazioni Tabelle (Join)
Diverse tabelle possono esser combinate tra loro generando delle unioni logiche tra dati in
comune.
L’engine associativo di Qlik esegue tali unioni in maniera automatica alla fine della fase di
caricamento.
Tale processo richiede però accortezza in quanto può causare incrementi notevoli nelle dimensioni
(unione cartesiana) o perdita di dati.
In un’unione cartesiana tra due tabelle, le righe di entrambe sono moltiplicate tra loro generando
una tabella combinata molto più grande e con un’elevata duplicazione dei dati.
Su Qlik avviene un prodotto cartesiano tra le tabelle quanto sono presenti più campi non in
comune.

Le tipologie di Join, coerenti e con dati non ridondanti, hanno le seguenti strutture:

Il comando di JOIN tra due tabelle in Qlik esegue automaticamente una full join tra le due (Outer
Join):

LOAD a, b, c from table1.csv;

JOIN LOAD a, d from table2.csv;  La Join è eseguita con l’ultima tabella caricata in
precedenza (a meno che non sia specificata)

Associazione Keep
L’unione tramite Join tra due tabelle genera una terza tabella formata dall’intersezione
d’entrambe.
Questo può risultare in un processo più lento, critico e pesante dal punto di visto dello spazio
occupato.
Il comando Keep permette di creare le associazioni tra le tabelle senza però generarne una terza,
risultando in un processo più veloce e non eccessivamente pesante.
Ovviamente il modello dati risultante sarà diverso ed andrà gestito tenendo a mente che in questo
caso abbiamo due tabelle separate logicamente associate tra loro.
Inner Join/Keep
Il prefisso inner stabilisce che le associazioni create siano soltanto quelle effettive tra le due
tabelle.
Nell’inner join verrà creata una terza tabella formata solo dai valori comuni tra le due.
Nell’inner Keep le due tabelle saranno ridotte alla loro intersezione comune prima di esser
memorizzate.

Left Join/Keep
Il prefisso left stabilisce di mantenere tutti i dati della prima tabella e soltanto i dati d’intersezione
della seconda.
Right Join/Keep
Il prefisso right stabilisce di mantenere tutti i dati della seconda tabella e soltanto i dati
d’intersezione della prima.

Link Table
In tale sezione verrà incluso lo script per la creazione della link table, o eventualmente per la
creazione di un diverso data model.
La link table (o tabella dei fatti), è una struttura logica contenente tutte le associazioni tra più
tabelle diverse.

Il data model sarà Dimensionale, e non Relazionale nell’insieme delle associazioni.

Un data model Relazionale è caratterizzato da:
 Schemi complessi
 Data Storage efficiente (minor numero di tabelle)
 Schemi facilmente costruibili e gestibili
 Query molto complesse
 Difficoltà d’approccio per gli utenti finali
Un data model Dimensionale è caratterizzato da:
 Schemi semplici
 Minore Normalizzazione (maggiore rischio di ridondanza dell’informazione)
 Schemi complessi da costruire e da gestire
 Query più semplici
 Facilmente comprensibile per gli utenti finali
Il modello dati dimensionale risulta ideale quando è necessario fornire all’utente finale una visione
d’insieme migliore del dato o utilizzare query molto complesse.
Il modello relazionale risulta invece ideale quando la criticità è sulle performance dovute al peso
eccessivo dei dati caricati (esempio ridurre tutto il modello ad un'unica tabella se possibile).

Prima di procedere, bisogna citare la differenza tra dimensioni e fatti.

1. Dimensioni: filtri che ci permettono di raggruppare (e analizzare) i dati
2. Fatti (Metriche): valori numerici che esprimono le variabili o le misure dell’obbiettivo
dell’analisi

Per procedere nella conversione di un modello relazionale in uno dimensionale vi sono i seguenti
passi:
 Scegliere il processo di business desiderato
 Comprenderne il livello di granularità voluto (la granularità indica il livello di dettaglio e la
profondità dell’informazione: singolo record o raggruppamenti – datamart – per tipologie)
 Scegliere le dimensioni da utilizzare per ogni riga dei fatti
 Identificare i fatti che popoleranno ognuna delle tabelle dei fatti

Common Dimensions
Business Dat Produ Stor Promoti Warehou Vend Contra Shipp
Process e ct e on se or ct er
Store Sales x x x x
Store
x x x
Inventory
Store
x x x
Deliveries
Warehouse
x x x x
Inventory
Warehouse
x x x x
Delivery
Purchase
x x x x x x
Orders

Relativamente al processo di business individuato verrà individuata una tabella principale dove
saranno presenti la maggior parte delle informazioni dei fatti e dimensioni per riga. Nel caso in
tabella sarà Purchase Orders.
Molto importante sarà la presenza di Chiavi Primarie identificative di ogni tabella. Una chiave
primaria identifica unicamente una singola riga di una tabella, e nel caso seguente, viene
composta concatenando le dimensioni scelte in precedenza.

Prendiamo la tabella Purchase Orders e trasformiamola nel seguente modo.

Nota: i campi dimensioni sono stati inglobati e concatenati nel campo chiave.
[Purchase Orders]:
LOAD
Date & ‘|’ & Product & ‘|’ & Warehouse & ‘|’ & Vendor & ‘|’ & Contract & ‘|’ & Shipper as
Key_PurchaseOrder  tutte le dimensioni prese in esame vengono concatenate in un
unico campo chiamato Key_...
, Field PO_A
la concatenazione è eseguita tramite il simbolo &
, Field PO_B
il simbolo | è aggiunto come separatore per facilitare la lettura
, Field PO_C;
La tabella risultante non presenterà i singoli campi dimensioni, ma
soltanto il campo Key per ogni riga

LOAD
Date
, Product
, Warehouse
, Vendor
, Contract
, Shipper
, Field PO_A
, Field PO_B
, Field PO_C
FROM ‘Purchase Orders’;

Stessa procedura verrà svolta per le altre tabelle.

Esempio:
Delivery:
LOAD
Date & ‘|’ & Product & ‘|’ & Warehouse & ‘|’ & Vendor & ‘|’ & Contract & ‘|’ & Shipper as
Key_Delivery  la Key per la nuova tabella è formata soltanto dalle dimensioni
effettivamente presenti
, Field D_A
, Field D_B;

LOAD
Date
, Product
, Warehouse
, Vendor
, Field D_A
, Field D_B
FROM Delivery;

Creazione tabella Link composta da una struttura Chiavi - Dimensioni

Link:
DISTINCT LOAD  Il commando
DISTINCT permette di assicurare l’unicità della chiave evitando ridondanze
Key_PurchaseOrder  La chiave della prima
tabella scelta. Verrà collegata automaticamente alla colonna con lo stesso nome sulla tabella
originaria
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 1) as Date  La funzione
SUBFIELD estrae un testo da un testo specifico.
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 2) as Product Input 1: il testo
da cui estrarre
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 3) as Warehouse Input 2: il
separatore
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 4) as Vendor Input 3 –
opzionale: nel caso di estrazione di più testi, indica quale estrarre
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 5) as Contract Utilizzando la
funzione Subfield si possono ricreare le colonne Dimensioni nella link table
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 6) as Shipper
RESIDENT [Purchase Orders];

Il modello dati associa automaticamente la colonna Chiave tra la tabella Link e la Purchase Orders.
Selezionando un valore dimensione sulla link, automaticamente verranno selezionati i campi Field
presenti sulla seconda tabella identificati unicamente per il valore chiave dato dalle stesse
dimensioni selezionate.

Esempio: Se il valore Data corrisponde a 05/01/2010 sulla link, verranno selezionati tutti i
purchase orders con tale valore data presente nella chiave.
Se vengono selezionate tutte le dimensioni sulla tabella link, un unico valore verrà
selezionato sulla tabella purchase orders.
Uniamo alla link table i campi e valori relativi alle altre tabelle come da esempio.

LEFT JOIN DISTINCT LOAD

Key_Delivery
, SUBFIELD(Key_Delivery, ‘|’, 1) as Date
, SUBFIELD(Key_Delivery, ‘|’, 2) as Product
, SUBFIELD(Key_Delivery, ‘|’, 3) as Warehouse
, SUBFIELD(Key_Delivery, ‘|’, 4) as Vendor
RESIDENT Delivery;

Inoltre aggiungiamo alla link una colonna chiamata Key_Delivery, formata con le stesse
combinazioni di dimensioni.
Link:
DISTINCT LOAD
Key_PurchaseOrder
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 1) & ‘|’ & SUBFIELD(Key_ PurchaseOrder, ‘|’, 2)
& ‘|’ & SUBFIELD(Key_ PurchaseOrder, ‘|’, 3) & ‘|’ & SUBFIELD(Key_
PurchaseOrder, ‘|’, 4) as Key_Delivery <- Key_Delivery è formato
secondo la seguente struttura
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 1) as Date
Date | Product | Warehouse | Vendor
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 2) as Product
La struttura è ricavata solo dai campi presi dalla Key_
PurchaseOrder (origine tabella [Purchase Orders])
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 3) as Warehouse
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 4) as Vendor
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 5) as Contract
, SUBFIELD(Key_ PurchaseOrder, ‘|’, 6) as Shipper
RESIDENT [Purchase Orders];

[…]

Nel nuovo modello, qualsiasi selezione fatta su di una dimensione presente nella link, influirà sulle
tabelle associate.
Nel caso visto la tabella iniziale, Purchase Orders, è associata in Join con la tabella delivery.
Di default Qlik esegue un Outer Join, pertanto vengono generate tutte le possibili combinazioni,
incluse righe non associate tra le due tabelle.
Questo può risultare utile quando sono presenti chiavi-valori solo in alcune delle tabelle collegate.
Qualify
Il motore associativo Qlik collega automaticamente due colonne con lo stesso nome presenti su
tabelle diverse.
Questa funzionalità, se non gestita, può portare ad incongruenze e complicazioni nella struttura
finale. Nota: l’associazione verrà eseguita al termine di tutto il processo di caricamento.
Per ovviare a questa problematica, ed evitare l’associazione durante determinate casistiche, di
norma viene indicato il nome della tabella prima di quello della colonna.
Esempio: Delivery.Date non sarà collegato in automatico con [Purchase Order.Date].  Osservare
l’uso specifico delle quadre in caso di nomi formate da più parole

Il comando QUALIFY permette di rinominare le colonne automaticamente con il prefisso del nome
della tabella.
Esempio:

Qualify *;  Indica che da questo momento tutte le tabelle a seguire

avranno nei nomi delle colonne l’aggiunta del prefisso relativo
L’asterico indica che la regola vale per qualsiasi nome
colonna.
Delivery:
LOAD
Date
, Product as Prodotto
, Warehouse
, Vendor
, Field D_A
, Field D_B
FROM Delivery;

Unqualify *;  Indica il termine dell’operazione di qualify su tutte le

colonne. Senza tale dicitura, qualsiasi tabella inserita nello script (anche su sezioni diverse) verrà
qualificata.

Il risultato finale sarà la seguente tabella:

È possibile qualificare soltanto delle colonne specifiche  Qualify Vendor;  Eseguirà la
conversione del nome soltanto per le colonne chiamate Vendor.
In caso si desiri qualificare la maggior parte delle colonne di una tabella, ma non tutte, si può
optare per questo semplice workaround:

Qualify *;  Il comando esegue la qualifica di tutte le colonne

Unqualify Product;  Viene disattivata l’esecuzione della qualifica soltanto per la
colonna Product

[Purchase Orders]:
LOAD
Date
, Product
, Warehouse
, Vendor
, Contract
, Shipper
, Field PO_A
, Field PO_B
, Field PO_C
FROM ‘Purchase Orders’;

Unqualify *;
Caricamento da QVD
Il formato QVD permette di trasferire dati compressi in binario tra applicazioni Qlik.
Tale funzionalità è l’ideale tra applicazioni che condividono dataset in comune, nei processi ETL di
estrazione-trasformazione-visualizzazione del dato, ma anche internamente nei processi di
modellazione.

Il processo di creazione di un qvd parte da una tabella precedentemente caricata nel load e
storicizzata attraverso il comando Store.
Esempio:

Store [Purchase Orders] into [lib://SelfBI/PC\ QVD\QVD 1\PurchaseOrder.qvd] 

La tabella viene memorizzata nel file PurchaseOrder.qvd

Il Path lib://SelfBI/PC\ QVD\QVD 1\ viene indicato a priori nel data connection

Il file qvd può esser richiamato all’interno del loading script nel seguente modo:

[Purchase Orders]:
LOAD
Date
, Product
, Warehouse
, Vendor
, Contract
, Shipper
, Field PO_A
, Field PO_B
, Field PO_C
FROM [lib://SelfBI/PC\ QVD\QVD 1\PurchaseOrder.qvd] 
Viene indicato come origine il file qvd (ed il path corrispondente)
(QVD); <-
La dicitura (QVD) indica all’engine come decomprimere e caricare il file

Un utilizzo appropriato dei qvd consiste nel eseguire trasformazioni complesse tra le tabelle,
ricaricandole direttamente come files compressi in maniera da velocizzare i tempi di loading.
Variabili
Questa sezione conterrà la definizione di tutte le variabili incluse nell’app.
Ogni variabile è formata da un nome (label), ed un valore il quale sarà assegnato alla label.

Tutte le variabili presenti nell’app sono caricate in uno spazio apposito dove è possibile gestirle,
inserirne di nuove o modificarle.
Data la difficoltà di gestione di tale interfaccia diretta, è consigliabile, per la loro gestione,
includere tutte le variabili introdotte all’interno dello script. Ad ogni chiamata di caricamento le
variabili verranno rigenerate.
Le variabili indicate nel load script verranno rigenerate ad ogni caricamento ed inserite nello
“Spazio Variabili”.
Esempio:

Set v_KPI_Red_Bolla = 10;  Definisce una variabile chiamata v_KPI_Red_Bolla,

con valore pari al numero intero 10.

Naming Convention: ogni variabile avrà il prefisso v_[…] per facilitarne l’identificazione (opzionale)
Una variabile può contenere anche un valore testuale:

Set v_Button2 = 'Chiusura Anno';  la stringa del testo è inclusa tra apici.

Una variabile può contenere un’espressione calcolabile. In questo caso entrano in gioco la
seguente valutazione  se o meno lasciare che il valore della variabile venga calcolato prima o
dopo l’assegnazione.
Esistono due modalità di creazione di una variabile: Set e Let
Set: assegna il valore alla variabile senza calcolarlo
Let: calcola l’espressione indicata dalla variabile per poi assegnare il risultato a quest’ultima

Set vVar = 2 + 3;   Il valore 2 + 3 è assegnato direttamente alla

variabile

Let vVar = 2 + 3;  Viene calcolata la somma 2 + 3 = 5, ed

assegnato il risultato alla variabile

Apparentemente non sembrano esserci differenze sensibili nell’uso della forma Set o Let.
Ma questo è errato in quanto possono esser create variabili complesse, dove campi estratti dalle
tabelle vengono utilizzati nei calcoli finali.
In tali casistiche, è importante definire quando il calcolo dell’espressione contenuta nella variabile
andrà ad esser eseguito, ovvero, se prima o dopo l’assegnazione.

Concettualmente richiamare una variabile significa utilizzarne il valore all’interno di un’espressione

voluta.
Si può indicare all’Engine di calcolare il valore di una variabile prima ancora del suo utilizzo
nell’espressione, con il seguente comando: $([Nome Variabile])
 Esempio: $(vVar)

Nei casi visti sopra avremmo:

  Set: $(vVar)  Richiama la variabile vVar del valore pari a 2 + 3,
successivamente esegui tale espressione, il risultato 5 sostituiscilo dove la variabile è
utilizzata
 Let: $(vVar)  Richiama la variabile vVar del valore pari a 5. Essendo un numero intero
il $ non esegue alcuna operazione ulteriore e ritorna direttamente il valore

Definiamo una variabile che contenga un’espressione di conversione data di una colonna
determinata:

Set v_MaxDate = '=Date(Max(Date#(Anno_Mese_Riferimento,''MMM YYYY'')),''MMM YYYY'')';

 Nota: se l’espressione interna alla variabile presenta un carattere apice, useremo i doppi
apici per indicarlo nell’espressione

L’espressione interna alla variabile sarà la seguente:

=Date(Max(Date#(Anno_Mese_Riferimento,'MMM YYYY')),'MMM YYYY')

 i valori presenti nella colonna Anno_Mese_Riferimento sono convertiti nel Type Data
(formato MMM YYYY).
Di questi valori viene presa la data più grande e convertita nel formato MMM YYYY
Tutta l’espressione è contenuta tra apici

La stessa variabile può esser utilizzata successivamente per generare una seconda variabile:

Set v_PrecYear = '=Date(AddYears(v_MaxDate,-1),''MMM YYYY'')';

 la variabile v_MaxDate è utilizzata dalla funzione AddYears

AddYears serve a sommare anni al valore indicato. Prende due input:
 Il valore a cui sommare gli anni
 Il valore di anni da sommare. Se negativo, gli anni saranno sottratti
Il valore risultante sarà formattato come MMM YYYY

Le variabili possono diventare anche delle funzioni: ovvero capaci di prendere un numero di input
e ritornare il risultato voluto.
Come nella programmazione a linea di comando gli input sono definiti dalla notazione $1, $2, ….,
$n
Esempio:

Scopo: vogliamo definire una variabile che sia una funzione capace di tornare, in formato testo, se
una determinata dimensione sia stata selezionata da un utente, e quali campi ha selezionato.
Esempio pratico: $(v_Dimension(‘Prodotto’, Product))
Verranno pertanto utilizzati i seguenti ingressi:
 Nome della dimensione da mostrare a video come label – formato testuale  $1
 Campi selezionati dall’utente relativamente a questa dimensione  $2
 Se nessun campo è stato selezionato nulla verrà visualizzato

Let v_Dimension = 'If(GetSelectedCount($2)>0,'' ''&$1&'': ''&GetFieldSelections($2))';

Possono esser create variabili complesse dove vengono eseguite un numero Enne di
trasformazioni prima dell’utilizzo finale.
Esempio:
varibile v_Trasform da calcolare due volte prima dell’utilizzo.
 Useremo la seguente dicitura $(=$( v_Trasform))  la
doppia dicitura con il $ indica che verrà calcolata per due volte
l’espressione della variabile prima del suo utilizzo