Load

A declaração LOAD carrega campos de um arquivo, de dados definidos no script, de uma tabela de entrada carregada anteriormente, de uma página da Web, do resultado de um comando SELECT subsequente ou gerando dados automaticamente.Também é possível carregar dados de conexões analíticas.

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:

Argumentos
Argumento	Descrição
distinct	Você pode usar distinct como predicado se deseja carregar apenas registros exclusivos. Se houver registros duplicados, a primeira instância será carregada. Se você estiver usando cargas anteriores, precisará colocar distinct na primeira instrução de carga, pois distinct afeta apenas a tabela de destino. Load precedente
fieldlist	fieldlist ::= ( * \| field {, * \| field } ) Uma lista dos campos a serem carregados. O uso de * como lista de campos indica todos os campos da tabela. field ::= ( fieldref \| expression ) [as aliasname ] A definição de campo deve conter sempre um literal, uma referência a um campo existente ou a uma expressão. fieldref ::= ( fieldname \|@fieldnumber \|@startpos:endpos [ I \| U \| R \| B \| T] ) fieldname é um texto idêntico a um nome de campo da tabela. Observe que o nome do campo deverá estar entre aspas duplas ou colchetes se contiver espaços, por exemplo. Às vezes, os nomes de campo não estão explicitamente disponíveis. Assim, uma notação diferente será usada: @fieldnumber representa o número de campo em um arquivo de tabela delimitado. Deve ser um inteiro positivo, precedido de “@”. A numeração sempre inicia no número 1 até o número de campos. @startpos:endpos representa as posições inicial e final de um campo em um arquivo com registros de comprimento fixo. As posições devem ser inteiros positivos. Os dois números devem ser precedidos de "@" e separados por dois-pontos. A numeração sempre inicia no número 1 até o número de posições. No último campo, n é usado como posição final do campo. Se @startpos:endpos for seguido imediatamente pelos caracteres I ou U, os bytes lidos serão interpretados como um inteiro binário assinado (I) ou não assinado (U) (ordem dos bytes da Intel). O número das posições lidas deve ser 1, 2 ou 4. Se @startpos:endpos for imediatamente seguido pelo caractere R, os bytes lidos serão interpretados como um número real binário (ponto flutuante IEEE de 32 ou de 64 bits). O número das posições lidas deve ser 4 ou 8. Se @startpos:endpos for seguido imediatamente pelo caractere B, os bytes lidos serão interpretados como números BCD (Binary Coded Decimal), de acordo com o padrão COMP-3. Qualquer número de bytes pode ser especificado. expression pode ser uma função numérica ou uma função de string baseada em um ou vários outros campos da mesma tabela. Para obter mais informações, consulte a sintaxe das expressões. as é usado para atribuir um novo nome ao campo.
from	from será usado se os dados precisarem ser carregados de um arquivo usando uma pasta. file ::= [ path ] filename format-spec ::= ( fspec-item { , fspec-item } ) Espaço pessoal: [lib://DataFiles/xyz.qvd] Você não pode criar ou referenciar uma hierarquia de pastas ao usar a conexão DataFiles. Por exemplo, o seguinte não possui suporte: [lib://DataFiles/subfolder1/xyz.qvd] Espaço compartilhado: [lib://TeamSharedSpace:DataFiles/xyz.qvd]
from_field	from_field é usado se for necessário carregar dados de um campo anteriormente carregado. fieldassource::=(tablename, fieldname) O campo é o nome de tablename e fieldname carregados anteriormente. format-spec ::= ( fspec-item {, fspec-item } ) A especificação do formato consiste em uma lista de vários itens de especificação de formato, entre colchetes.
inline	inline será usado se os dados precisarem ser digitados no script, e não carregados de um arquivo. data ::= [ text ] Os dados inseridos por uma cláusula inline devem ser colocados entre aspas duplas ou colchetes. O texto entre esses elementos será interpretado da mesma maneira que o conteúdo de um arquivo. Portanto, no local em que uma nova linha for inserida em um arquivo de texto, você também deverá inseri-la no texto de uma cláusula inline, isto é, pressionando a tecla Enter ao digitar o script. O número de colunas é definido pela primeira linha. format-spec ::= ( fspec-item {, fspec-item } ) A especificação do formato consiste em uma lista de vários itens de especificação de formato, entre colchetes.
resident	resident é usado se for necessário carregar dados de uma tabela anteriormente carregada. table label é um rótulo que precede o comando LOAD ou SELECT que criou a tabela original. O rótulo deve ter dois-pontos no final. Carregando dados de uma tabela carregada anteriormente Rótulos da tabela
autogenerate	autogenerate será usado se for necessário gerar os dados automaticamente pelo Qlik Sense. size ::= number Number é um inteiro que indica o número de registros a serem gerados. A lista de campos não deve conter expressões que precisem de dados de uma fonte de dados externa ou de uma tabela carregada anteriormente, a menos que você faça referência a um único valor de campo em uma tabela carregada anteriormente com a função Peek.
where	where é uma cláusula utilizada para declarar se um registro deve ou não ser incluído na seleção. A seleção será incluída se criterion for True. criterion é uma expressão lógica.
while	while é uma cláusula usada para declarar que um registro deve ser lido repetidamente. O mesmo registro será lido se criterion forTrue. Para que possa ser útil, a cláusula while normalmente deve incluir a função IterNo( ). criterion é uma expressão lógica.
group by	group by é uma cláusula usada para definir os campos de agregação (agrupamento) dos dados. Os campos de agregação devem ser incluídos de alguma maneira nas expressões carregadas. Nenhum outro campo diferente desses poderá ser usado fora das funções de agregação nas expressões carregadas. groupbyfieldlist ::= (fieldname { ,fieldname } )
order by	order by é uma cláusula usada para classificar os registros de uma tabela residente antes de seu processamento pela declaração load. A tabela residente pode ser classificada por um ou mais campos, em ordem ascendente ou descendente. A classificação é feita, principalmente, pelo valor numérico e, em seguida, pela ordem nacional de colação. Essa cláusula somente poderá ser usada quando a fonte de dados for uma tabela residente. Os campos de classificação especificam por qual campo a tabela residente é classificada. O campo pode ser especificado por seu nome ou número na tabela residente (o primeiro campo é o número 1). orderbyfieldlist ::= fieldname [ sortorder ] { , fieldname [ sortorder ] } sortorder é asc para ascendente ou desc para descendente. Se nenhuma sortorder for especificada, asc será assumido. fieldname, path, filename e aliasname são strings de texto que indicam o que seus respectivos nomes implicitamente representam. Qualquer campo na tabela de origem pode ser usado como fieldname. No entanto, campos criados por meio da cláusula (aliasname) estão fora de escopo e não podem ser usados dentro de uma mesma declaração load.

Se nenhuma fonte de dados for fornecida por meio de uma cláusula from, inline, resident, from_field, extension ou autogenerate, os dados serão carregados a partir do resultado imediatamente após a instrução SELECT ou LOAD. O comando sucessivo não deverá ter prefixo.

Carregando dados de uma tabela carregada anteriormente

A extensão do arquivo de conexões DataFiles faz distinção entre maiúsculas e minúsculas. Por exemplo: .qvd.

Examples:

Carregue somente três campos específicos de um arquivo delimitado:

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

Renomeie o primeiro campo como A e o segundo campo como B ao carregar um arquivo sem rótulos:

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

Carregue Name como uma concatenação de FirstName, um caractere de espaço e LastName:

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

Carregue Quantity, Price e Value (o produto de Quantity e Price):

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

Carregue somente registros exclusivos, e os registros duplicados serão descarregados:

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

Carregue somente registros onde o campo Litres tiver um valor acima de zero:

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

Carregue uma tabela com dados inline, dois campos nomeados CatID e Category:

LOAD * Inline

[CatID, Category

0,Regular

1,Occasional

2,Permanent];

Carregue uma tabela com dados inline, três campos nomeados UserID, Password e Access:

LOAD * Inline [UserID, Password, Access

A, ABC456, User

B, VIP789, Admin];

Carregue uma tabela com 10 mil linhas. O campo A irá conter o número do registro de leitura (1,2,3,4,5...) e o campo B irá conter um número aleatório entre 0 e 1:

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

Os parênteses após autogenerate são permitidos, mas não obrigatórios.

Primeiro nós carregamos um arquivo de tabela delimitado e o nomeamos tab1:

tab1:

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

Carregue campos da tabela já carregada tab1 como tab2:

tab2:

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

Carregue campos da tabela já carregada tab1, mas somente registros onde A seja maior que B:

tab3:

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

Carregue campos da tabela já carregada tab1 ordenada por A:

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

Carregue campos da tabela já carregada tab1, ordenada pelo primeiro campo e, em seguida, o segundo campo:

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

Carregue campos da tabela já carregada tab1 ordenada por C decrescente e B em ordem crescente e, em seguida, o primeiro campo em ordem decrescente:

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

Carregue o campo Types da tabela carregada anteriormente Characters como A:

LOAD A from_field (Characters, Types);

Carregue A, B e os campos calculados X e Y do Table1 que é carregado na instrução SELECT seguinte:

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

SELECT A,B,C,D from Table1;

Campos de carga agrupados (agregados) por ArtNo:

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

Campos de carga agrupados (agregados) por Week e ArtNo:

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

Nesse exemplo temos um arquivo de entrada Grades.csv que contém as notas para cada aluno condensadas em um campo:

Student,Grades

Mike,5234

John,3345

Pete,1234

Paul,3352

As notas, em uma escala de 1-5, representam as matérias Math, English, Science e History. Podemos separar as notas em valores separados, lendo cada registro várias vezes com uma cláusula while, utilizando a função IterNo( ) como um contador. Em cada leitura, a nota é extraída com a função Mid e armazenada em Grade. A matéria é selecionada usando a função pick e armazenada em Subject. A cláusula final while contém o teste para verificar se todas as notas foram lidas (quatro por aluno, neste caso), o que significa que o registro do próximo aluno deve ser lido.

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));

O resultado é uma tabela que contém estes dados:

Resulting data table

Os seguintes dados de amostra são usados.

Valores: Carregue Rand() como A, Rand() como B, Rand() como C AutoGenerate(50);

Carregando dados usando uma função

Nestes exemplos, partimos do princípio de que temos um plug-in de conexão analítica P que contém uma função Calculate(Parameter1, Parameter2). A função retorna a tabela Resultados, que contém os campos Field1 e Field2.

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

Carregue todos os campos retornados ao enviar os campos A e C para a função.

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

Carregue apenas o campo Field1 ao enviar os campos A e C para a função.

Load * Extension P.Calculate( Values );

Carregue todos os campos retornados ao enviar os campos A e B para a função. Como campos não estão especificados, A e B são usados, pois são os primeiros na ordem da tabela.

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

Carregue todos os campos que são retornados ao enviar o campo C a ambos os parâmetros da função.

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

Carregue todos os campos que são retornados ao enviar o campo A forçado como uma string e B forçado como um número para a função.

Carregando dados ao avaliar um script

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

Carregue a tabela retornada pelo script q ao enviar os valores de A e B.

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

Carregue a tabela retornada pelo script armazenado na variável My_R_Script ao enviar os valores de A e B.

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

Carregue a tabela retornada pelo script armazenado na variável My_R_Script ao enviar os valores de B renomeados como D, A e C. Usar * envia os campos restantes não referenciados.