Load

L'istruzione LOAD carica i campi da un file, dai dati definiti nello script, da una tabella caricata in precedenza, da una pagina Web, dal risultato di un'istruzione SELECT seguente o dalla generazione automatica di dati.È anche possibile caricare dati da connessioni di analisi.

Syntax:

LOAD [ distinct ] fieldlist

[( from file [ format-spec ] |

from_field fieldassource [format-spec]|

inline data [ format-spec ] |

resident table-label |

autogenerate size ) |extension pluginname.functionname([script] tabledescription)]

[ where criterion | while criterion ]

[ group by groupbyfieldlist ]

[order by orderbyfieldlist ]

Arguments:

Argomenti
Argomento	Descrizione
distinct	È possibile utilizzare distinct come predicato se si desidera caricare solo record univoci. Se ci sono record duplicati, verrà caricata la prima istanza. Se si utilizza l'istruzione preceding LOAD, è necessario inserire distinct nella prima istruzione LOAD, dal momento che distinct ha effetto solo sulla tabella di destinazione. Preceding load
fieldlist	fieldlist ::= ( * \| field {, * \| field } ) Un elenco di campi da caricare. L'utilizzo del carattere * come elenco dei campi indica tutti i campi della tabella. field ::= ( fieldref \| expression ) [as aliasname ] La definizione di campo deve sempre contenere un valore letterale, un riferimento a un campo esistente o un'espressione. fieldref ::= ( fieldname \|@fieldnumber \|@startpos:endpos [ I \| U \| R \| B \| T] ) fieldname è un testo che è identico al nome di un campo nella tabella. Tenere presente che il nome di campo deve essere racchiuso da virgolette doppie o parentesi quadre se, ad esempio, contiene spazi. Talvolta i nomi dei campi non sono disponibili in modo esplicito. Verrà quindi utilizzata una notazione differente: @fieldnumber rappresenta il numero di campo di un file tabellare delimitato. Deve essere un intero positivo preceduto da "@". La numerazione viene sempre eseguita partendo da 1 fino al numero di campi presenti. @startpos:endpos rappresenta le posizioni di inizio e di fine di un campo in un file con record a lunghezza fissa. Le posizioni devono essere entrambe numeri interi positivi. I due valori numerici devono essere preceduti dal simbolo "@" e separati da due punti. La numerazione viene sempre eseguita partendo da 1 fino al numero di posizioni presenti. Nell'ultimo campo n viene utilizzato come posizione finale. Se @startpos:endpos è seguito immediatamente dal carattere I o U, i byte letti verranno interpretati come un valore intero binario con segno (I) o senza segno (U), in base all'ordine dei byte Intel. Il numero di posizioni lette deve essere 1, 2 o 4. Se @startpos:endpos è immediatamente seguito dal carattere R, la lettura dei byte verrà interpretata come un numero binario reale (a virgola mobile a 32 bit o a 64 bit conforme allo standard IEEE). Il numero di posizioni lette deve essere 4 o 8. Se @startpos:endpos è immediatamente seguito dal carattere B, la lettura dei byte sarà interpretata come numeri BCD (Binary Coded Decimal), in base allo standard COMP-3. Può essere specificato un numero di byte qualsiasi. expression può essere una funzione numerica o una funzione stringa basata su uno o molti altri campi della stessa tabella. Per ulteriori informazioni, vedere la sintassi delle espressioni. as viene utilizzato per assegnare un nuovo nome al campo.
from	from viene utilizzato se i dati devono essere caricati da un file mediante una cartella. file ::= [ path ] filename format-spec ::= ( fspec-item { , fspec-item } ) Spazio personale: [lib://DataFiles/xyz.qvd] Non è possibile creare o fare riferimento a una gerarchia di cartelle quando si utilizza la connessione DataFiles. Ad esempio, non è supportato un percorso come il seguente: [lib://DataFiles/subfolder1/xyz.qvd] Spazio condiviso: [lib://TeamSharedSpace:DataFiles/xyz.qvd]
from_field	from_field viene utilizzato nel caso in cui i dati devono essere caricati da un campo caricato in precedenza. fieldassource::=(tablename, fieldname) Il campo è il nome del valore di tablename e fieldname caricato in precedenza. format-spec ::= ( fspec-item {, fspec-item } ) La specifica del formato è costituita da un elenco di più voci di specifica del formato, racchiuse tra parentesi.
inline	inline viene utilizzato quando i dati devono essere immessi direttamente nello script e non caricati da un file. data ::= [ text ] I dati immessi mediante una clausola inline devono essere racchiusi tra virgolette doppie o tra parentesi quadre. Il testo tra parentesi o virgolette viene interpretato allo stesso modo del contenuto di un file. Pertanto, quando si desidera modificare o immettere una nuova riga in un file di testo, è necessario eseguire questa operazione anche nel testo di una clausola inline, ad esempio premendo il tasto INVIO mentre si digita lo script. Il numero di colonne è definito nella prima riga. format-spec ::= ( fspec-item {, fspec-item } ) La specifica del formato è costituita da un elenco di più voci di specifica del formato, racchiuse tra parentesi.
resident	resident viene usato se i dati devono essere caricati da una tabella caricata in precedenza. table label è un'etichetta che precede le istruzioni LOAD o SELECT che hanno creato la tabella originale. L'etichetta dovrà essere indicata con i due punti finali. Caricamento di dati da una tabella caricata in precedenza Etichette di tabella
autogenerate	autogenerate viene utilizzato se i dati devono essere automaticamente generati da Qlik Sense. size ::= number Number è un numero intero e indica il numero di record che da generare. L'elenco di campi non deve contenere espressioni che richiedono dati provenienti da una sorgente dati esterna o da una tabella caricata in precedenza, a meno che non si faccia riferimento a un singolo valore di campo in una tabella caricata in precedenza con la funzione Peek.
where	where è una clausola utilizzata per dichiarare se un record deve essere incluso o meno nella selezione. La selezione viene inclusa se criterion è True. criterion è un'espressione logica.
while	while è una clausola che specifica se un record deve essere letto ripetutamente. Viene letto lo stesso record finché criterion è True. Per risultare utile, una clausola while deve generalmente includere la funzione IterNo( ). criterion è un'espressione logica.
group by	group by è una clausola usata per definire su quali campi devono essere aggregati (raggruppati) i dati. I campi di aggregazione devono essere inclusi in qualche modo nelle espressioni caricate. Nessun altro campo tranne i campi di aggregazione può essere usato al di fuori delle funzioni di aggregazione nelle espressioni caricate. groupbyfieldlist ::= (fieldname { ,fieldname } )
order by	order by è una clausola utilizzata per ordinare i record di una tabella residente prima che vengano elaborati da un’istruzione load. La tabella residente può essere ordinata su uno o più campi, in modo crescente o decrescente. L’ordinamento viene eseguito innanzitutto in base ai valori numerici e secondariamente in base all'ordine di confronto nazionale. Questa clausola può essere utilizzata solamente quando la sorgente dati è una tabella residente. I campi di ordinamento specificano il campo in base al quale viene ordinata la tabella residente. Il campo può essere specificato da un nome o dal suo numero nella tabella residente (il primo campo è il numero 1). orderbyfieldlist ::= fieldname [ sortorder ] { , fieldname [ sortorder ] } sortorder è asc per crescente o desc per decrescente. Se sortorder non è specificato, viene utilizzato asc. fieldname, path, filename e aliasname sono stringhe di testo che rappresentano ciò che implica il loro rispettivo nome. Qualsiasi campo presente nella tabella sorgente può essere utilizzato come fieldname. Tuttavia, i campi creati mediante la clausola as (aliasname) non appartengono all'ambito e non possono essere utilizzati all'interno della stessa istruzione load.

Se non viene specificata alcuna sorgente dati mediante una clausola from, inline, resident, from_field, extension o autogenerate, i dati verranno caricati dal risultato dell'istruzione SELECT o LOAD immediatamente successiva. L’istruzione successiva non dovrà avere un prefisso.

Caricamento di dati da una tabella caricata in precedenza

All'estensione file delle connessioni DataFiles si applica la distinzione tra maiuscole e minuscole. Ad esempio: .qvd.

Examples:

Caricare solo tre campi specifici da un file delimitato:

LOAD FirstName, LastName, Number from [lib://DataFiles/data1.csv];

Assegnare il nome A al primo campo e il nome B al secondo campo durante il caricamento di un file senza etichette:

LOAD @1 as A, @2 as B from [lib://DataFiles/data3.txt] (ansi, txt, delimiter is '\t', no labels);

Caricare Name come concatenazione di FirstName, uno spazio e LastName:

LOAD FirstName&' '&LastName as Name from [lib://DataFiles/data1.csv];

Caricare Quantity, Price e Value (il prodotto di Quantity e Price):

LOAD Quantity, Price, Quantity*Price as Value from [lib://DataFiles/data1.csv];

Caricare solo i record univoci mentre i record duplicati verranno eliminati:

LOAD distinct FirstName, LastName, Number from [lib://DataFiles/data1.csv];

Caricare solo i record in cui il campo Litres presenta un valore superiore a zero:

LOAD * from [lib://DataFiles/Consumption.csv] where Litres>0;

Caricare una tabella con dati inline, due campi denominati CatID e Category:

LOAD * Inline

[CatID, Category

0,Regular

1,Occasional

2,Permanent];

Caricare una tabella con dati inline, tre campi denominati UserID, Password e Access:

LOAD * Inline [UserID, Password, Access

A, ABC456, User

B, VIP789, Admin];

Caricare una tabella con 10.000 righe. Il campo A conterrà il numero del record di lettura (1,2,3,4,5...), mentre il campo B conterrà un numero casuale compreso tra 0 e 1:

LOAD RecNo( ) as A, rand( ) as B autogenerate(10000);

La parentesi dopo autogenerate è consentita, ma non obbligatoria.

Come prima cosa carichiamo un file tabella delimitato assegnandogli il nome tab1:

tab1:

SELECT A,B,C,D from [lib://DataFiles/data1.csv];

Caricare i campi dalla tabella tab1 già caricata come tab2:

tab2:

LOAD A,B,month(C),A*B+D as E resident tab1;

Caricare i campi dalla tabella già caricata tab1, ma solo record in cui A è maggiore di B:

tab3:

LOAD A,A+B+C resident tab1 where A>B;

Caricare i campi dalla tabella già caricata tab1 ordinata in base a A:

LOAD A,B*C as E resident tab1 order by A;

Caricare campi dalla tabella tab1 già caricata, ordinata in base al primo campo, quindi in base al secondo campo:

LOAD A,B*C as E resident tab1 order by 1,2;

Caricare i campi dalla tabella tab1 già caricata, ordinata in ordine decrescente in base a C, quindi in ordine crescente in base a B e quindi in base al primo campo in ordine decrescente:

LOAD A,B*C as E resident tab1 order by C desc, B asc, 1 desc;

Caricare il campo Types da tabelle caricate in precedenza Characters come A:

LOAD A from_field (Characters, Types);

Caricare A, B e i campi calcolati X e Y dalla tabella Table1, caricata nell'istruzione SELECT successiva:

LOAD A, B, if(C>0,'positive','negative') as X, weekday(D) as Y;

SELECT A,B,C,D from Table1;

Caricare i campi raggruppati (aggregati) in base a ArtNo:

LOAD ArtNo, round(Sum(TransAmount),0.05) as ArtNoTotal from table.csv group by ArtNo;

Caricare i campi raggruppati (aggregati) in base a Week e ArtNo:

LOAD Week, ArtNo, round(Avg(TransAmount),0.05) as WeekArtNoAverages from table.csv group by Week, ArtNo;

In questo esempio è presente un file di input Grades.csv contenente i voti per ciascuno studente raccolti in un singolo campo:

Student,Grades

Mike,5234

John,3345

Pete,1234

Paul,3352

I voti, in una scala da 1 a 5 , rappresentano le materie Math, English, Science e History. È possibile suddividere i voti in valori separati leggendo i record più volte con una clausola while, utilizzando la funzione IterNo( ) come contatore. Durante ciascuna lettura, il voto viene estratto con la funzione Mid e memorizzato in Grade, mentre la materia viene selezionata utilizzando la funzione pick e memorizzata in Subject. La clausola finale while contiene il test per verificare che siano stati letti tutti i voti (in questo caso quattro per studente), il che significa che deve essere letto il record dello studente successivo.

MyTab:

LOAD Student,

mid(Grades,IterNo( ),1) as Grade,

pick(IterNo( ), 'Math', 'English', 'Science', 'History') as Subject from [lib://DataFiles/Grades.csv]

while IsNum(mid(Grades,IterNo(),1));

Il risultato è una tabella contenente i seguenti dati:

Resulting data table

Sono utilizzati i dati campione seguenti.

Values: Load Rand() as A, Rand() as B, Rand() as C AutoGenerate(50);

Caricamento di dati mediante una funzione

In questi esempi si suppone di avere un plug-in di connessione di analisi denominato P contenente una funzione personalizzata Calculate(Parameter1, Parameter2). La funzione restituisce la tabella Results contenente i campi Field1 e Field2.

Load * Extension P.Calculate( Values{A, C} );

Carica tutti i campi restituiti quando si inviano i campi A e C alla funzione.

Load Field1 Extension P.Calculate( Values{A, C} );

Carica solo il campo Field1 quando si inviano i campi A e C alla funzione.

Load * Extension P.Calculate( Values );

Carica tutti i campi restituiti quando si inviano i campi A e B alla funzione. Dal momento che i campi non sono specificati, vengono utilizzati A e B, ossia i primi nell'ordine nella tabella.

Load * Extension P.Calculate( Values {C, C});

Carica tutti i campi restituiti quando si invia il campo C a entrambi i parametri della funzione.

Load * Extension P.Calculate( Values {String(A), Mixed(B)});

Carica tutti i campi restituiti quando si invia il campo A forzato come stringa e il campo B forzato come numerico alla funzione.

Caricamento di dati mediante valutazione di uno script

Load A as A_echo, B as B_echo Extension R.ScriptEval( 'q;', Values{A, B} );

Carica la tabella restituita dallo script q quando si inviano i valori di A e B.

Load * Extension R.ScriptEval( '$(My_R_Script)', Values{A, B} );

Carica la tabella restituita dallo script memorizzata nella variabile My_R_Script quando si inviano i valori di A e B.

Load * Extension R.ScriptEval( '$(My_R_Script)', Values{B as D, *} );

Carica la tabella restituita dallo script memorizzato nella variabile My_R_Script quando si inviano i valori di B rinominato in D, A e C. L'uso dell'asterisco (*) consente di inviare i rimanenti campi senza riferimento.

Hai trovato utile questa pagina?

Se riscontri problemi con questa pagina o con il suo contenuto – un errore di battitura, un passaggio mancante o un errore tecnico – facci sapere come possiamo migliorare!

Invia feedback