Qlik Sense Arquitetura de Dados

CURRÍCULO OFICIAL
Qlik Sense Arquitetura de Dados
Abril de 2018 - Quarta Edição
As informações contidas neste documento, incluindo URLs e outras referências a

sites da Internet estão sujeitos a mudanças sem prévio aviso. A menos que
informado explicitamente, todas as referências a empresas, organizações, produtos e
nomes de domínios, além de endereços de e-mail, logomarcas e eventos são fictícios
e não possuem qualquer vínculo com dados reais. Este documento está coberto
pelas leis de autorias e nenhuma parte ou em todo poderá ser reproduzida,
armazenada, obtida eletronicamente ou transmitida (mecânica ou eletronicamente)
em qualquer que seja o formato, nem tão pouco fotografado, sem a expressa
autorização do fornecedor.
Conteúdo
Introdução...............................................................................................................................6
Fontes de Consulta...................................................................................................................6
Portal da Qlik........................................................................................................................6
Help Online (ou Ajuda Online)..............................................................................................7
Agenda.....................................................................................................................................7
Questões a desenvolver durante o curso.................................................................................8
Estrutura de Arquivos...............................................................................................................8
Instalação do Qlik Sense Desktop.............................................................................................9
Lição 1 - Plano de Projeto........................................................................................................9
Objetivo da lição.......................................................................................................................9
O que é um Plano de Projeto?..................................................................................................9
Plano de Projeto.....................................................................................................................10
Medidas..............................................................................................................................10
Indicadores Chave de Performance....................................................................................10
Dimensões..........................................................................................................................10
Tendências.........................................................................................................................10
Filtros de Seleção...............................................................................................................10
Segurança...........................................................................................................................10
Descrição dos Dados..........................................................................................................10
Laboratório 01 - Plano de Projeto..........................................................................................10
Lição 2 - Estrutura dos Dados e AQL.......................................................................................12
Objetivo da Lição....................................................................................................................12
Estruturas de Dados...............................................................................................................12
Exemplo de Modelo Associativo.............................................................................................12
Origem de Dados para Carga..................................................................................................13
Comandos de Carga de Dados................................................................................................13
Laboratório 02 - Estrutura de Dados......................................................................................15
Lição 3 - Script de Carga.........................................................................................................16
Fontes de Dados.....................................................................................................................16
Criar Conexão OLE DB............................................................................................................16
Passos para criação da Conexão OLE DB................................................................................16
Carregar as Tabelas................................................................................................................18
Analisador de dados...............................................................................................................19
Laboratório 03 - Script de Carga.............................................................................................23
Lição 4 - Preparação de Dados...............................................................................................24
Carga de Dados – Excel – Funcionários..................................................................................24
Carga de Dados – Excel – Escritórios......................................................................................24
Carga de Dados – XML............................................................................................................26
Qualificando Campos.............................................................................................................26
Laboratório 04 - Preparação de Dados...................................................................................28
Lição 5 - Load Resident, Chave Sintética e Função Exists().....................................................28
Load Resident.........................................................................................................................28
Chave Sintética.......................................................................................................................29
Função Exists..........................................................................................................................30
Laboratório 05 - Load Resident, Chave Sintética e Função Exists().........................................30
Lição 6 - Campos Chave.........................................................................................................31
Campos Chave........................................................................................................................31
Frequência..............................................................................................................................31
Qualificador Distinct...............................................................................................................32
Adicionando Contadores........................................................................................................32
Laboratório 06 - Campos Chave.............................................................................................33
Lição 7 - Cálculos, Include e Dimensões de Tempo.................................................................33
Cálculos no Script...................................................................................................................33
Comando Include...................................................................................................................34
Dimensões de Tempo.............................................................................................................34
Derivação de Campos.............................................................................................................34
Declare...............................................................................................................................34
Derive.................................................................................................................................35
Load Inline..............................................................................................................................35
Mapping.................................................................................................................................36
Autogenerate.........................................................................................................................37
Laboratório 07 - Cálculos, Include e Dimensões de Tempo....................................................38
Lição 8 - Tratamento de dados não padronizados..................................................................39
Etapa de Transformação........................................................................................................39
Crosstable...............................................................................................................................42
Generic Load..........................................................................................................................42
Laboratório 08 - Tratamento de dados não padronizados.....................................................44
Lição 9 - Arquivos QVD e QVW..............................................................................................45
Nesta lição, você vai aprender a:............................................................................................45
O que são Arquivos QVD........................................................................................................45
Formato..................................................................................................................................45
Uso.........................................................................................................................................45
Aumentar a velocidade de Carga........................................................................................45
Consolidando dados de vários aplicativos..........................................................................45
Diminuir a carga sobre Servidores de Base de dados.........................................................46
Carga Incremental..............................................................................................................46
Criação de QVD......................................................................................................................46
Criação Manual a partir do Script.......................................................................................46
Criação Automática a partir do Script.................................................................................47
O que são Arquivos QVW.......................................................................................................48
Laboratório 09 - Arquivos QVD...............................................................................................48
Lição 10 - Variáveis................................................................................................................49
Uso de Variáveis.....................................................................................................................49
Lição 11 - Concatenação........................................................................................................51
Concatenação Automática.....................................................................................................51
Concatenação Forçada...........................................................................................................52
Prevenir Concatenação..........................................................................................................53
Concatenação na prática........................................................................................................53
Laboratório 11 - Concatenação..............................................................................................54
Lição 12 - Depuração.............................................................................................................56
Depuração..............................................................................................................................56
Laboratório 13 - Depurar........................................................................................................57
Gabarito dos Laboratórios.....................................................................................................59
Lição 1 - Plano de Projeto.......................................................................................................59
Lição 2 - Estrutura de Dados...................................................................................................59
Lição 3 - Script de Carga.........................................................................................................59
Lição 4 - Preparação de Dados...............................................................................................59
Lição 5 - Load Resident, Chave Sintética e Função Exists().....................................................59
Lição 6 - Campos Chave..........................................................................................................59
Lição 7 - Cálculos, Include e Dimensões de Tempo................................................................59
Lição 8 - Tratamento de dados não padronizados..................................................................59
Lição 9 - Arquivos QVD...........................................................................................................59
Lição 11 - Concatenação.........................................................................................................59
Lição 12 - Depuração..............................................................................................................59
Introdução
Fontes de Consulta
Vamos começar este curso respondendo à seguinte pergunta: onde posso ter acesso a
informações sobre os produtos da Qlik?
Destacamos três fontes de consulta, a seguir:
Portal da Qlik
http://www.qlik.com
Este portal possui várias informações sobre os produtos e a Qlik. O que queremos destacar a
você é a seção Community, que é a comunidade de Usuários e Desenvolvedores dos produtos
da Qlik. Lá há grupos de usuários, fóruns, blogs, projetos para download e artigos técnicos
(PDF). Para ter acesso aos recursos da Community, você deve fazer um cadastro no portal.
Qualquer usuário pode solicitar seu cadastro.
Help Online (ou Ajuda Online)
Este portal, disponível em vários idiomas, inclusive o português, é bem completo. Diferencia-se
por possuir exemplos para a maioria das funções.
Agenda
Durante o Curso Desenvolvedor I, abordaremos os seguintes temas:
• Estrutura de Arquivos
• Instalação do Qlik Sense Desktop
• Plano de Projeto
• Estrutura dos dados e AQL
• Script e Carga
• Preparação de Dados
• Load Residente, Chave Sintética e Função Exists()
• Campos Chave
• Load Inline, Autogenerate e Mapping
• Tratamento de dados não padronizados
• Arquivos QVD e QVW
• Variáveis
• Concatenação
• Depuração
Questões a desenvolver durante o curso
Vamos ver agora algumas questões que serão desenvolvidas em nosso curso.
• Como interpretar um plano de projeto?
• Como acessar dados e integrá-los com dados de outras fontes?
• Quais são algumas das técnicas para desenvolver modelos de dados?
• Que recursos estão disponíveis para visualizar a estrutura de dados em várias
fontes?
• Como e por que criar através do editor de carga e o gerenciador de dados?
• Quais os padrões a adotar para tornar minha aplicação eficiente, compreensível e
de manutenção simples?
• Como tornar uma aplicação segura?
• O que fazer quando tenho um problema?
Estrutura de Arquivos
Para este treinamento, usaremos instaladores e fontes de dados que estão dentro das pastas
conforme o modelo a seguir:
Verifique o diretório Fonte de Dados com os seguintes arquivos:

Verifique se na pasta Qlik Sense Arquitetura de Dados contém o arquivo: QWT BI Plano de
Projeto.doc
Instalação do Qlik Sense Desktop

Para este treinamento, usaremos instaladores da versão Qlik Sense Desktop February 2018.
Requisitos:
Windows 7 64bits ou superior e não pode ser versões Server.
8GB RAM e 500MB de espaço livre em disco (dependendo do volume de dados, talvez precise
mais).
Na pasta instaladores, execute o arquivo Qlik_Sense_Desktop_setup.exe e siga as instruções.
A instalação é simples como qualquer outro software que já tenha instalado em seu
computador.
Se desejar, pode executar a instalação do Qlik ODBC Connector Package x64, um excelente
recurso, disponibilizados pela Qlik, para obter drives de diferentes fontes de dados.
Lição 1 - Plano de Projeto

Objetivo da lição
Nesta lição, você vai aprender a:
• Necessidade de fazer um planejamento antes de começar a desenvolver o projeto.
• Apresentar um modelo de plano de projeto
O que é um Plano de Projeto?

Um plano de projeto é um documento guia com a finalidade de orientar o caminho a ser
seguido durante o curso para alcançar um objetivo.
Temos observado que projetos construídos sem um planejamento inicial passam por
constantes mudanças durante seu ciclo de vida, causando problemas como:
• Carga de dados desnecessários;
• Tempo de desenvolvimento perdido;
• Problemas no modelo de dados associados, como chaves sintéticas e referências
circulares.
Apresentamos neste curso um modelo de plano de projeto, denominado Plano de Projeto
QWT, que possui as seguintes características:
• O projeto não está configurado com gráficos, responsabilidades etc.
• Ele existe para ajudar a definir um objetivo a ser completado durante este curso.
• Vamos utilizar o plano de projeto como um guia para desenvolver o script de carga
necessário para disponibilizar uma aplicação.
• O nome do arquivo com a definição do plano de projeto é QWT BI Plano de
Projeto.doc.
Plano de Projeto
Veja agora as seções do Plano de Projeto QWT.
Medidas
Aqui encontraremos algumas das expressões que serão necessárias na aplicação.
Alguns desses cálculos serão usados no arquivo de carga, outros serão usados nos objetos
(gráficos, texto, filtros, tabelas) que compõem a interface com o usuário.
Indicadores Chave de Performance

Esta seção inclui Indicadores Chave de Performance que podem ser mostrados através de
objetos na aplicação.
Dimensões
Esta seção inclui a lista de algumas das dimensões chave a serem utilizadas durante o
desenvolvimento dessa aplicação.
Tendências
Disponibiliza uma importante lista das dimensões que trabalham com campos “tempo” que
serão necessários para uma análise histórica dos dados.
Filtros de Seleção
Inclui uma lista de campos necessários para executar seleções e filtros sobre os dados
carregados na aplicação.
Segurança
Contém as necessidades referentes à segurança de acesso a uma aplicação.
Descrição dos Dados

Disponibiliza localização e descrição dos campos para cada fonte de dados.
Nesta lição você aprendeu o que é um plano de projeto e qual a importância de fazer um
planejamento antes de começar a desenvolver o projeto. O que você achou? Está fácil,
concorda? Vamos dar andamento aos nossos estudos!
Vamos praticar um pouco? Exercite o que você aprendeu aqui!
Laboratório 01 - Plano de Projeto

1. Faça um pequeno esboço de um projeto que você pretende desenvolver para a
empresa que você trabalha ou para um cliente seu utilizando o modelo do Plano de
Projeto QWT.
2. Com suas palavras, explique o que é um Plano de Projeto.
3. Relacione as colunas em relação às seções do Plano de Projeto QWT.
(A) Medidas
(B) Indicadores Chave de Performance
(C) Dimensões
(D) Tendências
(E) Filtros de Seleção
(F) Segurança
(G) Descrição dos Dados
( ) Esta seção inclui a lista de algumas das dimensões chave a serem utilizadas
durante o desenvolvimento dessa aplicação.
( ) Alguns desses cálculos serão usados no arquivo de carga, outros serão usados nos
objetos (gráficos, texto, filtros, tabelas) que compõem a interface com o usuário.
( ) Disponibiliza uma importante lista das dimensões que trabalham com campos
“tempo” que serão necessários para uma análise histórica dos dados.
( ) Inclui uma lista de campos necessários para executar seleções e filtros sobre os
dados carregados na aplicação.
( ) Disponibiliza localização e descrição dos campos para cada fonte de dados.
( ) Contém as necessidades referentes à segurança de acesso a uma aplicação.
( ) Esta seção inclui Indicadores Chave de Performance que podem ser mostrados
através de objetos na aplicação.
Lição 2 - Estrutura dos Dados e AQL
Objetivo da Lição
• Conhecer as Estruturas de Dados que podem ser fontes de dados para aplicação.
• Conhecer a maneira de como trazer esses dados para os projetos.
Estruturas de Dados
Existem várias classificações técnicas para Dados, como SGBD, Bancos Transacionais, Sistemas
de Arquivos, entre outros. Para um fácil entendimento para este curso, podemos classificar os
dados (fontes para projetos) em dois grupos:
• Bases de dados relacionais
o Microsoft SQL Server, Microsoft Access, Oracle, DB2, Sybase, Informix,
Teradata, entre outros.
• Arquivos delimitados, fixos ou padronizados
o Estrutura de dados comum para alimentar aplicações são arquivos de texto
(csv, skv), planilhas no formato Excel e padrões XML, HTML, KML.
Uma vez que os dados foram carregados para o projeto, temos as seguintes definições:
• Cada coluna de uma tabela, que é carregada, torna-se um campo na base de dados
associativa (também referenciada como base de dados AQL).
• Campos que aparecem em mais de uma tabela e tenham mesma identificação
serão automaticamente associados.
• Cada campo pode ser apresentado na forma de filtros na aplicação.
• Quando uma seleção é feita em um campo ou gráfico, a pesquisa é feita através de
toda a base de dados associativa por conexões lógicas. Como resultado desta
pesquisa, os valores associados com sua seleção serão identificados.
Exemplo de Modelo Associativo

Origem de Dados para Carga
A lista a seguir mostra os tipos e origens de dados para as aplicações. Veja:
• O resultado de uma consulta SQL, usando qualquer conector compatível com a origem
• Arquivos delimitados (csv, txt, tab, qvo, mem, skv, prn, log)
• Arquivos de registro fixo (fix, dat)
• Arquivos de formato AS/400 (dif)
• Documentos QlikView (qvw)
• Qlik Data (qvd)
• Qlik Data eXchange (qvx)
• Excel (xls, xlw, xlsx, xlsm)
• HTML (html, htm, php)
• XML (xml)
• KML (kml)
• REST
• DropBox
Comandos de Carga de Dados

Os comandos a seguir são usados para conexão ao banco de dados e para seleção de tabelas.
• Connect: comando para conectar ao Banco de Dados, utilizando ODBC ou OLE DB.
• Select: comando SQL para selecionar dados de uma Tabela. O comando Connect
deve ter sido executado antes do Select.
• Load: comando para seleção de dados.
• As: comando para renomear campos.
Não é necessário decorar sintaxe de string de conexão ao banco ou comando Select. Existe um
assistente para montar essas linhas de código.
Exemplos de Connect:
ODBC CONNECT TO [SQLDATA;database=SQL1] (UserId is sa, Password is admin);
ODBC CONNECT TO [MS AccessDatabase;DBQ=data\sampledata.mdb];
ODBC CONNECT TO [COSQL01;DATABASE=SALESDATA;Trusted_Connection=Yes];
LIB CONNECT TO ‘OLEDB-QWT’;
Exemplos de Select:
SQL SELECT * FROM CLIENTES;
SQL SELECT DISTINCT I.AddressID, Name, Address,

FROM [Invoice] I, [Address] A
WHERE I.InvoiceType is not null and I.InvoiceDate >= ‘2001-01-01’
and I.AddressID = A.AddressID;
Exemplos de Load:
Load *
from c:\userfiles\data2.txt (ansi, txt, delimiter is ‘\t’, embedded labels);
Load
RecNo() as A,
rand() as B
Autogenerate(10000);
Load
A,
B,
A*B+D as E
Resident tab1;
Load *
Inline [
CatID, Category
0, Regular
1,Occasional
2,Permanent];
Exemplos de Saídas de Dados:
// QVD
STORE Categorias$
INTO [lib://Dados/Categorias.qvd] (qvd);
// QVX
STORE Categorias$
INTO [lib://Dados/Categorias.qvx] (qvx);
// CSV (Com ponto e vírgula)
STORE Categorias$
INTO [lib://Dados/Categorias.csv]
(txt, delimiter is ';');
// TAB
STORE Categorias$
INTO [lib://Dados/Categorias.tab]
(txt, delimiter is '\t');
Exemplos de Comentários
REM - Transforma em comentário tudo que estiver entre ele até o

próximo ponto e vírgula;
// Transforma em comentário
// tudo que estiverem na mesma linha.
/*
Transforma em comentário tudo que estiver entre estes símbolos.
*/
Exemplos de Condicional
IF $(vUltimaCarga) = TODAY()-7 THEN

TRACE Verdadeiro;
ELSEIF $(vCargaAtual) = TODAY() THEN
TRACE Verdaderiro;
ELSE
TRACE Falso;
ENDIF;
Exemplos de Laço de Repetição
FOR x = 1 TO NOOFROWS('Tabela')
LET vCampo = FIELDVALUE('Campo',$(x));
TRACE $(vCampo);
NEXT
FOR EACH vPlan IN 'Plan1','Plan2','Plan3'

TRACE $(vPlan);
NEXT
SET a = 1;
DO WHILE a<10
TRACE $(a);
LET a = a+1;
LOOP
Nesta segunda lição, você conheceu as estruturas de Dados que podem ser fontes de dados
para Projetos, aprendeu sobre a origem e os comandos de Dados para Carga, viu as Fontes de
Dados Você conseguiu compreender todo o conteúdo estudado até aqui? Vamos prosseguir!
Vamos praticar? Exercite o que você aprendeu aqui!
Laboratório 02 - Estrutura de Dados

1. Liste pelo menos cinco tipos de Origens de Dados que podem ser carregados em
Projetos.
2. Explique como faz para conectar nos diferentes tipos de Bancos de Dados (Oracle,
SQL Server, DB2 etc.).
3. Relacione as colunas em relação aos comandos usados para conexão ao banco de
dados e tabelas.
(A) Connect
(B) Select
(C) Load
(D) As
( ) Comando SQL para selecionar dados de uma Tabela. O comando Connect deve ter
sido executado antes.
( ) Comando para conectar ao Banco de Dados, utilizando ODBC ou OLE DB.
( ) Comando para renomear campos.
( ) Comando para seleção de dados.
Lição 3 - Script de Carga
Objetivo da Lição
• Carregar as tabelas que serão utilizadas no treinamento.
• Fazer o tratamento inicial dos dados.
Fontes de Dados
Veja que a imagem a seguir nos mostra que não importa de onde vieram os dados depois da
leitura. Dados são dados e são trata-os sem distinção.
Criar Conexão OLE DB

Para este curso, usaremos um banco de dados do Access, denominado QWT.mdb.
Para que possamos ter acesso a esse banco de dados, utilizaremos uma conexão OLE DB aos
dados fonte.
Passos para criação da Conexão OLE DB

Vamos ver agora o passo a passo para a criação da conexão OLE DB após a criação de uma
aplicação.
1. Crie um novo aplicativo com o nome de Qlik Sense Arquitetura de Dados.
Ou clicar: (Diálogo Bem-vindo)

“Crie um novo aplicativo”
2. Vá em Adicionar dados e verá a tela inicial do assistente.
3. Clique na opção OLE DB em Conectar-se a uma nova fonte de dados.

4. Selecione o Provedor Microsoft Jet 4.0 OLE DB Provider(32-bits), informe o caminho
da fonte de dados, teste a conexão, dê o nome de QWT e clique em criar.
Carregar as Tabelas
Agora vamos ver os passos para carregar as primeiras tabelas na aplicação.
• Selecione todos os campos nas tabelas DetalhesPedidos e Pedidos, marcando-as
cada uma conforme abaixo.
• Pode-se visualizar os dados de cada tabela ao clicar no nome correspondente ao
lado esquerdo.
• Clique em Adicionar dados.
Analisador de dados
Vamos agora analisar as duas tabelas
Ao clicar sobre a tabela de Pedidos, aparece uma recomendação de associação com a tabela
DetalhesPedidos na cor verde, isso quer dizer que é altamente recomendável fazer essa
associação, para isso, arraste a bolha de Pedidos para cima da bolha de DetalhesPedidos e
solte.
No exemplo abaixo, selecionamos a tabela de Pedidos e clicamos no ícone editar.
Podemos criar novos campos calculados, alterar o tipo e renomear os campos...

Ao clicar em Adicionar campo e em seguida Campo calculado, aparecer a opção conforme tela
abaixo, onde você tem disponível diversas opções como funções, campos existentes e
operadores para a criação do campo calculado.
Ao clicar na barra de ferramentas localizado acima dos nomes dos

campos (Ilustrado em laranja ao lado), podemos criar intervalos de
compartimentos de campos numéricos, gerando agrupamento de
dados, exemplo: Ao selecionar o campo frete, informamos em quantos
compartimentos queremos agrupar e é gerado automaticamente um
intervalo a partir dos dados, ao clicar em Criar compartimentos gera o
campo agrupado.
Agora vamos adicionar outras tabelas na aplicação.
• Para adicionar mais dados, clique em no Gerenciador de dados.

• Selecione todos os campos nas tabelas Categorias, Clientes, DetalhesPedidos,
Pedidos, Produtos e Transportadoras marcando-as cada uma conforme abaixo,
precisamos deixar selecionado as tabelas carregadas anteriormente.
Como podemos ver, precisamos fazer as associações entre as tabelas

Ao clicar sobre a tabela de categoria, aparece algumas recomendações de associação com a
tabela Produtos na cor verde, isso quer dizer que é altamente recomendável fazer essa
associação, mas também aparece na tabela Pedido e Transportadora na cor laranja, isso quer
dizer que são recomendações médias, precisam ser analisadas melhor se deve ser feito ou não
a associação.
Ao arrastar a tabela de categorias para realizar associação com DetalhesPedidos, aparece uma
realce em vermelho que quer dizer associação não recomendada.
Após realizar todas as associações o modelo de dados deve ficar nesse modelo
Nesse momento que os dados estão sendo incorporado ao Qlik Sense
Nesta lição você aprendeu carregar as tabelas que serão utilizadas no treinamento e a fazer o
tratamento inicial dos dados. Ainda restou alguma dúvida? Lembre-se de prosseguir somente
se tudo estiver muito claro para você!
Exercite o que você aprendeu aqui!
Laboratório 03 - Script de Carga

1. Para fixar bem o processo de conexão ao banco de dados e carregamento de tabelas,
crie uma outra aplicação:
a) Faça a conexão com o banco de dados através de OLE DB.
b) Carregue as tabelas.
c) Avalie todos os pares e avisos.
2. Complete as lacunas com a alternativa correta.
O analisador de dados é usado para __________ os dados seguindo as regras de negócio e
evitando a geração de possíveis problemas de __________ inválidas e associações entre
dados que não tem relação entre eles.
a. modelar; chaves
b. inserir; informações
c. documentar; dados
d. documentar; informações
e. explicar; chaves
Lição 4 - Preparação de Dados
Objetivo da Lição
• Carregar dados de outras fontes.
• Simular problemas no script que podem ocorrer durante o trabalho no dia a dia,
bem como opções para a solução desses problemas.
Carga de Dados – Excel – Funcionários

Até aqui carregamos dados através de uma conexão OLE DB. A partir de agora, vamos carregar
dados de outras fontes, como Excel (xls) e arquivo XML.
Vamos fazer a carga da tabela Funcionários e da tabela Escritórios. Ambas estão no arquivo
FuncionariosEscritorios.xls.
Ao abrir o arquivo Excel, você pode observar que existem duas planilhas:
• Funcionarios: Identifica os Funcionários.
• Escritorios: Identifica os Escritórios onde os Funcionários trabalham.
O campo chave nessa tabela é FuncID, que permitirá associar essa informação aos demais
dados já carregados.
Carga de Dados – Excel – Escritórios

A tabela de Escritórios está no mesmo arquivo do Excel FuncionariosEscritorios.xls, mas na
pasta Escritórios, como já citamos.
O campo chave nessa tabela é Escritorio e os valores desse campo serão associados ao do
campo Escritorio na tabela Funcionarios.
Arraste e solte o arquivo FuncionariosEscritórios.xls, na aplicação e o assistente de carga será
exibido.
Marque a planilha Funcionarios$ e mude o rótulo de FuncID para FuncionarioID, também

marque a planilha Escritorios$ e clique em Adicionar dados.
Entre outros avisos, a associação de Pedidos -

Funcionarios$ está correta, mas tem um alerta
importante, pois pode não ser a melhor associação. Já a
associação entre Escritorios$ - Funcionarios$ é 100%
válida.
Carga de Dados – XML
Os dados sobre os Fornecedores da empresa serão extraídos de um arquivo XML com o nome
Fornecedores.XML
Vamos utilizar o editor de carga de dados para fazer a carga desse arquivo, crie uma seção
para organizar melhor o código.
Carregue os dados e observe que ocorre a mensagem alertando para a Referência Circular.
Uma referência circular é um sinal de um modelo de dados incorreto, no qual dois campos
semelhantes, que têm interpretações ligeiramente diferentes, são tratados como um só.
Quando o indexador descobre a referência circular durante a execução do script, as tabelas
são parcialmente desconectadas.
Sempre que ocorrer uma referência circular, você deve se perguntar: - Eu consigo resolver isso
renomeando campos? Se sua resposta for sim, significa que os nomes dos campos iguais que
causaram a referência circular referem-se a dados que não deveriam estar associados, ou seja,
refletem informações distintas, apesar de ter o mesmo nome.
Entretanto, se realmente existir a necessidade de os dados estarem associados, você não
poderá renomear os campos. A solução será trabalhar de modo diferente a modelagem dos
dados, implementando um modelo estrela, utilizando uma tabela de ligação, por exemplo. No
entanto, essa técnica para implementar um modelo estrela utilizando uma tabela de ligação
será visto em outro curso.
Qualificando Campos
Outra forma de resolver Referência Circular, você não deve mudar o nome dos campos
manualmente, utilize a técnica de Qualificar os campos da tabela lida. Qualificar campos
significa identificar os campos acrescentando o nome da tabela antes do nome dos campos.
Insira as linhas de código abaixo, antes do comando de carregamento da tabela Fornecedores.
*;
Qualify
Unqualify FornecedorID;
Como o campo FornecedorID é usado para associar a outra tabela, não deverá utilizar o
qualificador da tabela.
Isso é especificado usando o comando.
Após a tabela Fornecedores ter sido carregada, temos de adicionar o seguinte comando para
que os outros campos carregados posteriormente não utilizem o qualificador de tabela:
Unqualify *;
A figura a seguir mostra como ficará o bloco inteiro de leitura da tabela Fornecedores. Veja:
Qualify *;
Fornecedores:
LOAD FornecedorID,
NomeEmpresa,
NomeContato,
Endereco,
Cidade,
CodigoPostal,
Pais,
Fone,
Fax
FROM [lib://Fonte de Dados/Fornecedores.xml]
(XmlSimple, table is [Records/Record/Row]);
Unqualify *;
Após todos os ajustes o modelo de dados deve ficar como na figura abaixo:
Nesta lição você aprendeu a carregar dados de outras fontes e a simular problemas no script
que podem ocorrer durante o trabalho no dia a dia, bem como opções para a solução desses
problemas. Vamos adiante!
Laboratório 04 - Preparação de Dados
1. Aplique o comando Qualify para todos os campos da tabela Categorias. Tome o
cuidado, no entanto, para manter a associação de Categorias com Produtos, depois
remova esse comando para darmos seguimento ao curso.
2. O que significa qualificar campos?
Lição 5 - Load Resident, Chave Sintética e Função Exists()

Objetivo da Lição
• Criar uma tabela de dados diretamente no script através do Load Resident.
• Simular problemas no script que podem ocorrer durante o trabalho no dia a dia,
bem como opções para a solução desses problemas.
• Entender o que são e como podemos evitar o uso de chaves sintéticas.
• Função Exists para condicionar o preenchimento de tabelas.
Load Resident
Agora você vai aprender a criar uma tabela usando como base uma tabela previamente
carregada (Resident).
Vai aprender também a segmentar o script de carga em diferentes seções, para facilitar a
leitura e a manutenção.
Siga os passos:
• Abra o Editor de carga de dados.
• Adicione uma nova seção clicando no ícone Criar nova seção. Use Vendedores
como nome dessa nova aba.
• Adicione um comando de carga para uma nova tabela, mas, dessa vez, em vez de
usar o Assistente para criar o código, digite o código abaixo:
/* Tabela Vendedores */
Vendedores:
LOAD FuncionarioID,
Sobrenome,
[Primeiro Nome],
Titulo as TituloVendedor
Resident Funcionarios$;
Agora queremos limitar a carga dos registros dos empregados para somente aqueles que
podemos identificar como pessoal de vendas.
• Para isso, você precisa fazer outra alteração no código do script:
• Primeiro, remova o ponto e vírgula (;) localizado após Resident Funcionarios$.
Depois, adicione a condição Where após o comando Resident, como a seguir:
Left(Titulo,3) = 'Sal'
Where
or Titulo = 'President';
Chave Sintética
É indesejável que tenhamos várias chaves comuns através das tabelas da estrutura de dados.
Essa situação pode levar o indexador a usar chaves complexas (chaves sintéticas) ao gerar a
estrutura de dados.
Chaves sintéticas é um tipo de recurso pesado, e geralmente o uso desse tipo de recurso pode
tornar lento o processo de cálculo e, em casos extremos, sobrecarregar uma aplicação.
Também tornam um documento difícil de entender e manter.
Quando você criou a tabela que gera o campo TituloVendedor, inadvertidamente foi criada
uma chave sintética entre as tabelas Funcionários e Vendedores.
A chave sintética é gerada em uma nova tabela, que pode ser identificada no Visualizador do
modelo de dados.
Como podemos ver, existe uma tabela para chave sintética composta pelos campos Primeiro
Nome, Sobrenome e FuncionarioID.
Neste caso, não existe razão para que você utilize os campos nome como uma chave adicional
entre essas tabelas, já que o campo FuncionarioID já serve para esse propósito.
Para corrigir essa situação, você utilizará a técnica de mudar os nomes dos campos
novamente.
Mude o nome dos campos que não necessite como campos chave.
Na leitura da tabela Vendedores, vamos renomear os campos conforme abaixo:
Vendedores:
LOAD FuncionarioID,
[Primeiro Nome] & ' ' & Sobrenome as Vendedor,
Titulo as TituloVendedor
Resident Funcionarios$
Where Left(Titulo,3) = 'Sal'
or Titulo = 'President';
Após carregar os dados, você poderá confirmar que a chave sintética não mais existe. Você
pode confirmar isso usando o visualizador de tabelas novamente (Visualizador do modelo de
dados).
Função Exists
Você utilizou um método simples que permitiu identificar os Vendedores em um conjunto de
Funcionários. Para este caso específico, foi adequado, mas podemos chegar ao mesmo
resultado usando uma solução mais interessante e mais confiável.
Agora, você definirá que os vendedores são aqueles que estão incluídos nos nossos dados de
vendas. Serão considerados vendedores aqueles que forem identificados no campo
FuncionarioID na tabela Pedidos.
Para começar, vamos criar um campo com o nome FuncionarioVendedor para identificar os
vendedores com segurança.
Utilize a linha de comando abaixo para a tabela Pedidos, imediatamente após o campo
FuncionarioID.
FuncionarioID,
FuncionarioID as FuncionarioVendedor,
Modifique a clausula Where na tabela Vendedores utilizando a função Exists().
Vendedores:
LOAD FuncionarioID,
[Primeiro Nome] & ' ' & Sobrenome as Vendedor,
Título as TituloVendedor
Resident Funcionarios$
Where Exists(FuncionarioVendedor,FuncionarioID);
A condição na cláusula Where verifica se existem dados carregados que sejam equivalentes
aos valores do campo FuncionarioVendedor .
Como o nome indica, a função Exists() pode ser utilizada para verificar se um valor específico
existe em um dado campo dos dados carregados até esse momento.
Lembre-se de cuidar com a ordem com que você define a sequência de comandos, já que os
campos de referência devem ser alimentados antes da verificação de valores.
Neste exemplo, a tabela Pedidos tem de ser carregada antes da tabela Vendedores para que
essa condição funcione de forma apropriada. Após completar essas modificações, carregue os
dados para ser verificada a funcionalidade.
Nesta lição, você aprendeu a criar uma tabela de dados diretamente no editor de carga de
dados através do Load Resident, entendeu o que são e como podemos evitar o uso de chaves
sintéticas e viu a Função Exists, que serve para condicionar o preenchimento de tabelas.
Lembre-se: em caso de dúvida, retorne ao conteúdo e faça uma revisão dos pontos que achar
necessário.
Laboratório 05 - Load Resident, Chave Sintética e Função
Exists()
1. Faça uma nova aplicação utilizado os dados desse curso e crie uma seção no editor de
carga de dados com o nome “Produtos Vendidos”. Crie uma tabela com os seguintes
campos:
• ProdutoID,
o PedidoID (Renomear para Pedido) e
o PrecoUnitario (Renomear para ValorUnitario)
Use as Funções Resident e Exists para criar essa nova tabela.
2. Complete a frase a seguir:
A frequência de um campo está associada ao __________, ou seja, é o número de
vezes que um valor aparece no conjunto de __________.
a. dado; campos
b. valor; obras
c. valor; dados
d. número; dados
Lição 6 - Campos Chave

Objetivo da Lição
• Conhecer os problemas de cálculo de frequência (contagem) sobre campos chave.
• Saber técnicas para evitar esses problemas.
Campos Chave
Campos chave são aqueles que são comuns em duas ou mais tabelas (campos associados).
Frequência
A frequência de um campo está associada ao valor, ou seja, é o número de vezes que um valor
aparece no conjunto de dados.
O problema de calcular a frequência em um campo chave é que o indexador não saberá qual
tabela utilizar para contar a incidência dos dados.
 Supondo que temos uma tabela chamada Pedidos com 1.000 diferentes números de
pedidos (PedidoID).
 Temos também uma tabela com nome PedidosExternos, que contém 200 números de
pedidos.
 Esses números também são encontrados na tabela Pedidos.
 As duas tabelas são associadas através do campo em comum PedidoID.
O problema está quando queremos saber exatamente o número de pedidos únicos.
O correto é 1.000, 200 ou 1.200?
Com base nas informações que temos, sabemos que é correto responder que existem 1.000
pedidos únicos, mas isso não é tão claro assim no modelo associativo.
Se olhássemos as propriedades do campo no modelo, seria exibido 1.200 valores não nulos e
1.000 valores totais distintos.
Também é importante saber que será impossível usar, nos gráficos e itens mestres, funções
para calcular frequência de campos associados.
Qualificador Distinct
Para calcular corretamente a frequência de um campo chave, o uso do Distinct garante que
contaremos somente uma vez a incidência de cada valor possível do campo. Por exemplo: se
queremos saber quantos Pedidos únicos existem:
Em vez de utilizarmos a expressão: Count(PedidoID), adicionamos o Distinct da seguinte
maneira: Count(DISTINCT PedidoID).
Adicionando Contadores
Uma solução relativamente simples para o problema dos campos chave e o cálculo de
frequência de dados é carregar o campo que queremos calcular a frequência uma vez mais
com outro nome.
Esse problema pode ser resolvido da seguinte forma:
/* Exemplo */
[Pedidos]:
LOAD [PedidoID],
[PedidoID] as CodigoPedido,
...
Em geral, é boa prática evitar o uso de campos chave em listas e expressões. Campos chave
devem ser usados para ligar tabelas, e não para mostrar dados em uma aplicação.
Agora o novo campo (não associado) pode ser utilizado em um filtro, que mostrará a
frequência ou o gráfico com funções para calcular frequência.
O novo nome de campo pode facilmente ser tratado ao atribuirmos uma outra identificação
por forma a não confundir os usuários.
Observe a tabela abaixo e os resultados apresentados:
Vendedor Produto ClienteID Quantidade
Frank Roll Lace Shoes 51 3
Frank Roll Lace Shoes 82 3
Joan Callins Casual Boots 84 4
Lennart Skoglund Casual Boots 14 3
Rob Carsson Lace Shoes 89 3
Tom Lindwall Lace Shoes 24 6

Expressões Resultados
Count(Vendedor) 5
Count(Distinct Vendedor) 5
Count(Produto) 2
Count(Distinct Produto) 2
Count(Quantidade) 6
Count(Distinct Quantidade) 3
NumericCount(Quantidade) 6
Sum(Quantidade) 22
Nesta lição, você aprendeu a identificar os problemas de cálculo de frequência (contagem)

sobre campos chave e conheceu técnicas para evitar esses problemas. Até aqui tudo certo?
Então vamos prosseguir!
Vamos praticar!
Laboratório 06 - Campos Chave

1. Modifique o script na sua aplicação para incluir um campo com nome CodigoProduto,
com base no campo ProdutoID na tabela Produtos e carregue os dados.
2. Crie uma tabela dinâmica, com:
Dimensões:
NomeProduto e NomeCategoria, nessa ordem.
Expressões:
Count(ProdutoID), Count(Distinct ProdutoID) e Count(CodigoProduto)
3. Mostre somas parciais por NomeProduto e NomeCategoria
4. Duplique o campo PedidoID com o nome CodigoPedido em Pedidos e carregue os
dados.
5. Crie uma tabela dinâmica, com:
Dimensões:
NomeCategoria e NomeProduto, nessa ordem.
Expressões:
Count(PedidoID), Count(Distinct PedidoID) e Count(CodigoPedido)
6. Mostre somas parciais por NomeCategoria e NomeProduto.
7. Explique com suas palavras o que são campos chave.
Lição 7 - Cálculos, Include e Dimensões de Tempo

Objetivo da Lição
• Fazer cálculos diretamente do script.
• Embutir código a partir de arquivos externos a aplicação.
• Utilizar técnicas diferentes para criar as dimensões de tempo como: Declare e
Derive, Load Inline, criando dados no script, Autogenerate criando registros
automaticamente e usando tabelas mapeadas (Mapping).
Cálculos no Script
É possível usar diversos operadores e funções no script para efetuar os mais variados cálculos,
tanto diretamente no Load quanto para definições de variáveis.
Vamos criar a medida Venda Líquida na memória, com dados da tabela Detalhes Pedidos
fazendo os cálculos conforme script abaixo.
[DetalhesPedidos]:
LOAD [Desconto],
[PedidoID],
[PrecoUnitario],
[ProdutoID],
[Quantidade],
[PrecoUnitario]*[Quantidade]*(1-[Desconto]) as VendaLiquida;
SQL SELECT `Desconto`,
`PedidoID`,
`PrecoUnitario`,
`ProdutoID`,
`Quantidade`
FROM `DetalhesPedidos`;
Comando Include
É possível fazer a inclusão de partes de script usando a função include, isso é particularmente
útil para reaproveitamento de código, para versionamento e fácil migração de aplicações entre
ambientes de teste, homologação e produção.
Vamos incluir, após a carga das planilhas, o pedaço de script que está no arquivo Email.txt a
nossa aplicação.
$(Include=[lib://Fonte de Dados/Email.txt]);
Dimensões de Tempo
Existem dimensões de tempo previstas no Plano de Projeto, precisamos criar Ano, Mês, Dia,
Trimestre e Mês Ano.
Para criar Ano, Mês, Dia e Mês Ano, vamos usar um novo recurso chamado Campos
Derivados, que possibilita criar campo e definições de grupo.
O Trimestre, vamos usar uma tabela Inline, depois iremos recriar a mesma tabela usando o
Autogenerate.
Derivação de Campos
Declare
É usado para criar campo e definições de grupo, em que você pode definir as relações entre
campos ou funções. Um conjunto de definições de campo pode ser usado para gerar campos
derivados automaticamente, o que pode ser usado como dimensões. Você pode usar o
comando Declare para definir uma nova definição de campo ou criar uma definição de campo
com base em uma definição já existente.
Sintaxe:
definition_name:
Declare [Field[s]] Definition [Tagged tag_list ]
[Parameters parameter_list ]
Fields field_list;
Derive
É usado para gerar campos derivados com base em uma definição de campo criada com um
comando Declare. Você pode especificar a partir de quais campos de dados derivar os campos
ou derivá-los explicitamente ou implicitamente com base em tags de campos.
Sintaxe:
Derive [Field[s]] From [Field[s]] field_list Using definition;
Derive [Field[s]] From Explicit [Tag[s]] tag_list Using definition;
Derive [Field[s]] From Implicit [Tag[s]] Using definition;
• Criação de Calendários
• Criação de Campo de valores com base em um parâmetro.
• Utilização de medidas de calendários com YTD (year to date), MTD (month to date)
• Uso do Eixo contínuo num gráfico de análise temporal
Load Inline
Em alguns casos, pode ser interessante inserir dados diretamente através do script.
Geralmente fazemos isso para criar tabelas de Tipos, Status ou para resolver questões onde na
tabela aparecem códigos como:
1 = Significa Ativo
2 = Significa Inativo
Se sabemos que o usuário não conhece o significado desses códigos, podemos criar uma tabela
associada com a descrição desses códigos. Isso é feito com a ajuda do comando Load Inline.
Inclua o script abaixo logo após a declaração do Derive que fizemos anteriormente.
Trimestres:
Load * Inline [
Mês, Trimestre
1, T1
2, T1
3, T1
4, T2
5, T2
6, T2
7, T3
8, T3
9, T3
10, T4
11, T4
12, T4
];
Observe que o comando Load Inline contém os nomes dos campos e dados entre colchetes.
Observe também que os nomes dos campos estão localizados na primeira linha, e que os
valores estão separados por vírgulas.
A tabela assim inserida associa números dos meses ao trimestre correspondente. Quando o
script é executado, o novo campo Trimestre é gerado.
Mapping
A tabela Trimestres é útil, já que executa a ligação do mês ao respectivo trimestre. Entretanto,
o campo se torna um campo chave quando associado e isso provavelmente causará problemas
mais tarde. Existem algumas soluções para isso, como você verá a seguir.
O objetivo agora é trazer o campo Trimestre para dentro da tabela Pedidos. Para isso, você vai
usar o recurso Mapping Table (Tabelas Mapeadas).
O prefixo Mapping é utilizado em um comando Load ou Select para criar uma Mapping Table.
Tabelas lidas através de Mapping Load ou Mapping Select serão armazenadas em área de
memória separada e usada somente como Mapping Table durante a execução do script.
Após a execução do script, elas serão automaticamente eliminadas.
Mapping Table tem duas colunas:
• A primeira contém valor de comparação;
• A segunda, o resultado da comparação.
As duas colunas têm de receber nomes, mas os nomes são irrelevantes no modelo de dados.
Os nomes dessas colunas não definem ligação com nomes de campos em tabelas “normais”,
ou seja, pode ter o mesmo nome que outros campos em outras tabelas na memória ou que
serão carregadas.
Quando tabelas mapeadas são usadas para mapear um valor de campo ou expressão, aquele
valor será comparado com um valor na primeira coluna.
Se encontrado, o valor original será substituído por um valor correspondente na segunda
coluna da tabela Mapping. Caso contrário, não haverá substituição.
Sintaxe: Mapping ( load statement | select statement )
Agora, modifique o comando Load da tabela Trimestres em um comando de carregamento
Mapping, como a seguir:
Trimestres:
Mapping Load * Inline [
Mês, Trimestre
1, T1
2, T1
3, T1
4, T2
5, T2
6, T2
7, T3
8, T3
9, T3
10, T4
11, T4
12, T4
];
Ao realizar a carga novamente, poderá observar que a tabela Trimestres e seus campos não se
encontram mais disponíveis, já que tabelas Mapping só existem durante o processo de carga.
Entretanto, podemos usar a tabela Trimestres no nosso script, mas lembre- se: desde que seja
utilizado após essa definição no script. Para isso, utilizaremos a função ApplyMap().
Sintaxe: ApplyMap(‘mapname’,expr, [,defaultexpr])
Essa função identifica qualquer definição em uma tabela Mapping, previamente carregada.
Mapname é o nome do mapa previamente carregada por um comando Mapping Load ou
Mapping Select. Observe que o nome obrigatoriamente deve estar entre aspas simples.
Expr é a expressão ou somente o campo que o resultado deve ser mapeado.
Defaultexpr é uma definição opcional, que será usada como valor padrão, caso não exista
valor associado a expr. Se um valor padrão não é indicado, o valor de expr retorna tal como ele
é.
Vamos adicionar uma função ApplyMap() para a tabela Pedidos, com base no valor numérico
do campo Mês. Essa função refere-se à tabela Trimestres.
A função deverá ficar como a seguir:
[Pedidos]:
LOAD [ClienteID],
[DataPedido],
ApplyMap('Trimestres', Month([DataPedido])) as Trimestre,
[Frete],
[FuncionarioID],
[FuncionarioID] as FuncionarioVendedor,
[PedidoID],
[PedidoID] as CodigoPedido,
[TransportadorID];
SQL SELECT `ClienteID`,
`DataPedido`,
`Frete`,
`FuncionarioID`,
`PedidoID`,
`TransportadorID`
FROM `Pedidos`;
Carregue os dados e veja o resultado.
Autogenerate
Outra forma de gerar dados é utilizar o comando Autogenerate no script de carga.
Quando você especifica Autogenerate no script de carga, isso automaticamente irá gerar um
determinado número de registros.
Somente constantes e funções sem parâmetros são permitidas na utilização do Autogenerate.
Frequentemente, as funções RecNo() ou RowNo() são utilizadas para gerar um identificador
(número único) para cada linha.
Faça alteração no script conforme abaixo.
Trimestres:
Mapping Load RowNo() as Mês,
'T' & Ceil(RowNo()/3) as Trimestre
Autogenerate(12);
O Autogenerate(12) especifica que será criada uma tabela com 12 linhas.
A função RowNo() irá retornar o número da linha que está sendo criada na tabela lógica,
iniciando com 1.
A função Ceil() vai arredondar o número indicado para o próximo inteiro superior.
O caractere & é usado para concatenação.
Ficou fácil? Lembre-se: qualquer dificuldade que sinta, você deve retornar ao conteúdo, para
depois seguir adiante!
Vamos exercitar! Realize as atividades referentes à Lição 7.
Laboratório 07 - Cálculos, Include e Dimensões de Tempo

1. Use o Mapping na tabela Transportadoras e aplique esse mapeamento para a tabela
de Pedidos. Assim, os nomes das transportadoras estarão presentes diretamente na
tabela Pedidos.
2. Crie um item mestre dimensão, com o campo derivado DataPedido.Cal.Mês Ano, dê o
nome de Mês Ano Pedido e faça um item mestre medida, com a soma do campo
VendaLiquida, dê o nome de Venda Líquida e uma tag Vlr Venda.
3. Faça um gráfico de linhas com os Itens Mestres: Mês Ano Pedido e Venda Líquida.
4. Quais são as formas de gerar dados diretamente no script de carga?
Lição 8 - Tratamento de dados não padronizados

Objetivo da Lição
• Ler dados de arquivos não padronizados, contendo cabeçalho, rodapé, linhas
vazias, linhas de totais e células mescladas.
Etapa de Transformação
Você pode observar que todos os dados que foram carregados até aqui estavam
razoavelmente estruturados e puderam ser carregados através dos comandos Select ou Load.
Entretanto, nem todos os dados estão tão formatados para serem carregados.
Nesta parte do curso, vamos explorar algumas opções disponíveis para carregar dados em
formatos não padronizados.
Um arquivo Excel (Orcamento.xls) contendo dados financeiros pode ser encontrado no
diretório Fonte de Dados.
Esse arquivo contém dados em duas planilhas:
• Os dados existentes na primeira planilha podem ser facilmente carregados sem
qualquer manipulação.
• Na segunda planilha, entretanto, os dados são apresentados em um formato
frequentemente encontrado nas organizações.
Abra o arquivo Orcamento.xls que se encontra no diretório Fonte de Dados e veja a planilha
Orcamento.
Esse formato de dados apresenta alguns desafios, mas pelo menos já podemos verificar que
uma carga irá gerar campos para cada ano, em vez de valores anuais em cada campo Ano,
como seria desejável em nossa aplicação.
Agora que você conheceu os desafios para alcançar dados padronizados, siga os passos:
Arraste o arquivo Orçamento.xls para a aplicação e mude o tamanho do cabeçalho para 1.
• Observe os campos Escritório e Linhas de Totais, teremos que tratar isso
diretamente no script, clique em Adicionar dados
• Selecione a opção tabela no gerenciador
• Clique no ícone editar da tabela de Orçamento$
• Clique no botão Não girar e selecione as colunas de ano
• Clique em Aplicar não giro e depois renomear os campos para Ano Orçamento e
Montante
• Carregue os dados
Temos uma nova seção que foi gerada automaticamente, desbloqueie e altere o script
conforme abaixo, depois, carregue os dados.
[Orcamento$]:
CROSSTABLE ([Ano Orçamento],[Montante],2)
LOAD [Escritorio],
[Metrica],
[2007],
[2008],
[2009],
[2010]
FROM [lib://Fonte de Dados/Orcamento.xls]
(biff, embedded labels, header is 1 lines, table is Orcamento$
,filters( Replace(1, top, StrCnd(null))));
Importante:
Replace: Preenche a célula com o valor superior (top) se estiver vazia (null).
Observe que o campo Escritorio, agora está preenchido corretamente, porém, ao final, existem
duas linhas que não deveriam estar lá, vamos elimina-las.
Altere o script conforme abaixo:
[Orcamento$]:
CROSSTABLE ([Ano Orçamento],[Montante],2)
LOAD [Escritorio],
[Metrica],
[2007],
[2008],
[2009],
[2010]
FROM [lib://Fonte de Dados/Orcamento.xls]
(biff, embedded labels, header is 1 lines, table is Orcamento$
,filters( Replace(1, top, StrCnd(null))))
where IsNum(Escritorio);
Crosstable
Agora você está pronto para trabalhar com os campos qualificadores.
Um campo qualificador é simplesmente um campo normal, com dados em uma coluna.
Um campo qualificador será mantido como está em uma carga de tabela cruzada.
• Neste caso, os campos Escritorio e Metrica são campos qualificadores. Informe
então que serão dois campos qualificadores.
Na carga de tabela cruzada, todos os campos qualificadores, obrigatoriamente, devem estar
posicionados antes dos atributos e dos dados.
• Vamos usar o nome Ano Orçamento para identificar o campo de Atributo e o
nome Montante para identificar o campo de Dados.
Observe no modelo de dados, que o campo Montante contém todos os valores para
Orçamento e Real, mas preferimos ter esses valores em campos diferentes.
Para isso, necessitamos implementar um outro tipo de carregamento.
Generic Load
O prefixo Generic é usado para a descompactação e o carregamento de uma base de dados
genérica.
As tabelas carregadas por um comando Generic não são concatenadas automaticamente.
Observe que a coluna Montante contém todos os valores, na metrica contém a associação de
cada valor, porém, pode ser necessário ter cada Métrica em uma coluna separada
Logo abaixo da carga do Orçamento$ com o comando CrossTable que você fez a pouco, inclua
o script abaixo.
[Orcamento/Real]:
Generic Load
Escritorio &'|'& [Ano Orçamento] as %Key,
Metrica,
Montante
Resident [Orcamento$];
DROP TABLE [Orcamento$];
Importante:
Metrica e Montante.
Obrigatoriamente o penúltimo campo deve conter a informação genérica e o último campo o
valor propriamente.
O resultado no modelo será conforme a imagem abaixo:
Como as tabelas carregadas através do comando Generic Load, vamos utilizar o script abaixo
para ter apenas uma no final do script com todos os campos.
1º Passo – carregar uma nova tabela com o campo chave

(Lembre-se que estamos lendo residente de Orçamento$)
TabelaCombinada:
LOAD
distinct Escritorio &'|'& [Ano Orçamento] as %Key
Resident [Orcamento$];
DROP TABLE [Orcamento$];
2º Passo – colocar os nomes da tabela em uma lista

SET vListaTabelas = ;
FOR vNumeroTabela = 0 TO NoOfTables()
LET vNomeTabela = TableName(vNumeroTabela);
IF Subfield(vNomeTabela,'.',1)='Orcamento/Real' THEN
LET vListaTabelas = vListaTabelas
& If(Len(vListaTabelas)>0,',')
& Chr(39) & vNomeTabela & Chr(39);
END IF
NEXT vNumeroTabela
3º Passo – Carregar as tabelas e fazer a junção entre elas
FOR EACH vNomeTabela IN $(vListaTabelas)
LEFT JOIN (TabelaCombinada)
LOAD
*,
SubField(%Key,'|',1) as %Escritorio,
SubField(%Key,'|',2) as [Ano Orçamento]
RESIDENT [$(vNomeTabela)];
DROP TABLE [$(vNomeTabela)];

NEXT vNomeTabela
Drop Field %Key;
Ao final da execução teremos a tabela combinada conforme abaixo:
Nesta lição, você aprendeu a ler dados de arquivos não padronizados, contendo cabeçalho,
rodapé, linhas vazias, linhas de totais e células mescladas. Ficou tudo claro até aqui? Ótimo,
vamos prosseguir!
Vamos praticar? Realize as atividades referentes à Lição 8.
Laboratório 08 - Tratamento de dados não padronizados

1. Na pasta Exercícios, existe um arquivo do Excel (tab01-IBGE.xls). É um dos arquivos
disponíveis no site do IBGE e mostra um ranking dos 100 maiores municípios
brasileiros em relação ao PIB (Produto Interno Bruto), dados de 2011.
2. Crie uma nova aplicação com o nome 100 Maiores Municípios Brasileiro, lendo
esse arquivo e extraindo somente os campos:
o Cidade/Estado
o Valor do PIB
3. Use os recursos da etapa de transformação para não ler linhas e colunas
desnecessárias
Lição 9 - Arquivos QVD e QVW
Objetivo da Lição
• Utilizar o poderoso recurso de geração de arquivos de alta performance.
• Entender os benefícios e as diferentes técnicas de trabalhar com QVD.
O que são Arquivos QVD

Um arquivo QVD (QlikView Data) é um arquivo que contém uma tabela de dados exportada
dos produtos da Qlik. O QVD está em um formato nativo e só pode ser gravado e lido por esses
produtos. O formato de arquivo é otimizado para agilização na leitura de dados de um script,
ao mesmo tempo, é muito compacto. A leitura de dados de um arquivo QVD é geralmente de
10 a 100 vezes mais rápida do que a leitura de outras fontes de dados.
Formato
O arquivo QVD é uma tentativa de selar o compromisso do desempenho ideal dos produtos
Qlik na leitura e gravação de arquivos e da representação compacta.
Um arquivo QVD contém exatamente uma tabela. Em termos conceituais, é muito semelhante
a qualquer arquivo de tipo csv, dif, biff ou fix, e consiste em três partes:
• Um cabeçalho XML composto de modo apropriado (com o conjunto de caracteres
UTF-8), que descreve os campos da tabela, o layout das informações subsequentes
e alguns outros metadados.
• Tabelas de símbolos em um formato com bytes.
• Dados da tabela em um formato com bits.
Uso
Veja agora para que são usados arquivos QVD.
Aumentar a velocidade de Carga

Ao armazenar (buffering) dados com baixo nível de alterações ou sem alterações em arquivos
QVD, a execução do script de carga pode tornar-se consideravelmente mais rápida quando
trabalha com grandes conjuntos de dados.
Quando desenvolve aplicações, geralmente é necessário executar o script repetidamente. Ao
utilizar dados armazenados em situações de repetição de carga, o arquivo QVD permite reduzir
significativamente o tempo de espera mesmo em se tratado de conjuntos de dados de menor
dimensão.
Consolidando dados de vários aplicativos.

Com o comando de script binary, é possível carregar dados de um único aplicativo em outro
aplicativo, mas com os arquivos QVD, um script é capaz de combinar dados de vários
aplicativos. Isso possibilita que os aplicativos consolidem dados semelhantes de diferentes
unidades de negócios, por exemplo.
Diminuir a carga sobre Servidores de Base de dados.
O volume de dados lidos de fontes de dados externas pode também ser bastante reduzido.
Isso reduz a carga de trabalho dos bancos de dados externos e o tráfego de rede. Além disso,
quando vários scripts compartilham os mesmos dados, basta carregá-los uma vez do banco de
dados de origem em um arquivo QVD. Os outros aplicativos podem usar os mesmos dados por
meio desse arquivo QVD.
Carga Incremental
Em muitos casos comuns, a funcionalidade QVD pode ser usada para a carga incremental, para
carregar apenas novos registros de um banco de dados crescente.
Criação de QVD
Os arquivos QVD podem ser criados:
• Manual a partir do script.
• Buffer, criação automática a partir do script.
Em seguida, você poderá ver uma descrição melhor cada uma das técnicas de criação de QVD.
Criação Manual a partir do Script

Um arquivo QVD pode ser criado por um comando Store no script. Esse é o comando que
criará um arquivo QVD nomeado explicitamente.
Sintaxe:
• A <tabela> é uma tabela rotulada e já carregada do script.
• O <nome_do_arquivo> é interpretado de modo semelhante aos nomes nos
comandos load, ou seja, os comandos directory se aplicam. Os campos da lista de
campos podem ser renomeados usando a sintaxe As.
Exemplos:
Store Clientes
into [lib://Fonte de Dados/Clientes.qvd] (qvd);
Store Produtos
into [lib://Fonte de Dados/Produtos.csv] (txt, delimiter is ',');
Store [FuncionarioID],[Primeiro Nome] as Nome,[Escritorio]

From [Funcionarios$]
into [lig://Fonte de Dados/Funcionarios.skv] (txt, delimiter is ';');
Ao incluir um comando Store, nenhuma alteração pode ser notada na sua aplicação e também
que nenhuma nova tabela ou campo passou a existir.
O comando adicionado ao script não tem um efeito além de executar mais um comando.
Uma vez que esse script é executado, um novo arquivo de dados pode ser lido para a nossa
aplicação ou mesmo qualquer outra aplicação com acesso à pasta onde está armazenado o
arquivo.
Para fazer a carga de um arquivo QVD, basta arrastar ele para a aplicação ou qualquer outra
forma válida de carga de arquivos de dados na aplicação.
Criação Automática a partir do Script
Os arquivos QVD podem ser criados e mantidos automaticamente usando o prefixo buffer.
Esse prefixo pode ser usado com a maioria dos comandos Load e/ou Select no script. Ele indica
se um arquivo QVD será usado para armazenar em cache/buffer o resultado do comando.
O nome atribuído ao arquivo QVD é calculado e normalmente armazenado em:
C:\ProgramData\Qlik\Sense\Engine\Buffers
(Instalação do servidor)
ou
C:\Users\%username%\Documents\Qlik\Sense\Buffers
(Qlik Sense Desktop)
Sintaxe:
Buffer [(option [ , option])] ( loadstatement | selectstatement )
option::= incremental | stale [after] amount [(days | hours)]
Em que option é uma das seguintes:

Incremental
Permite a leitura apenas de parte de um arquivo subjacente. O tamanho anterior do arquivo é
armazenado no cabeçalho XML no arquivo QVD. Isso é útil principalmente em arquivos de log.
Todos os registros carregados anteriormente são lidos no arquivo QVD, ao passo que os novos
registros subsequentes são lidos na fonte original, por fim, é criado um arquivo QVD
atualizado.
Stale [After] amount [ (days | hours) ]
É geralmente usada com fontes de bancos de dados em que não há data/hora simples nos
dados originais. Especifica-se por quanto tempo os dados capturados no último QVD poderão
ser utilizados.
Exemplo:
[Clientes]:
Buffer (Stale After 7 Days)
SQL SELECT `Cidade`,
`ClienteID`,
`CodigoPostal`,
`Endereco`,
`Estado`,
`Fax`,
`Fone`,
`NomeContato`,
`NomeEmpresa`,
`Pais`
FROM Clientes;
Vamos agora revisar o comando de carga da tabela Clientes para usar o método automático de
geração de arquivo QVD.
Sabemos pelo nosso plano de projeto que os dados da tabela Clientes é atualizada
semanalmente, então temos necessidade de ler e atualizar os dados a cada sete dias.
Vamos modificar então o nosso script de carga para adicionar o prefixo buffer ao nosso
comando original de carga para Clientes.
Agora adicione o prefixo Buffer (Stale After 7 Days) ao comando de carga para Clientes similar
ao exemplo a cima.
O que são Arquivos QVW

Um arquivo QVW (QlikView Worksheet) pode ser carregado com o comando Binary, só
podemos carregar dados de uma única aplicação QlikView em outra, de uma única aplicação
QlikView em uma aplicação Qlik Sense ou de uma aplicação Qlik Sense em outra do mesmo
Qlik Sense, porém nesse último caso, o comando Binary será em um arquivo QVF, equivalente
o QVW.
Somente um comando Binary é permitido e obrigatoriamente é o primeiro comando
executado pelo script. Quando executado, o script carrega os dados do arquivo
correspondente, no entanto, sem usar a configuração do layout.
Exemplos:
Binary Lib://MyData/customer.qvw;
Binary customer.qvf;
Binary c:\qv\customer.qvw;
Nesta lição você aprendeu a utilizar Arquivos QVD e QVW, que é um poderoso recurso dos
produtos da Qlik. Você entendeu também os benefícios e as diferentes técnicas de trabalhar
com QVD.
Vamos exercitar! Realize as atividades referentes à Lição 9.
Laboratório 09 - Arquivos QVD

1. Modifique o script da sua aplicação para usar o buffer nas tabelas Pedidos e
DetalhesPedidos utilizando a especificação Stale. Utilize o prazo de uma semana
para determinar a frequência com que essas tabelas necessitam de novas cargas.
2. Crie uma nova aplicação e faça uma carga binária de arquivo QVW ou QVF de sua
escolha.
3. Assinale apenas as alternativas que são usados arquivos QVD.
 ) Diminuir a carga sobre Servidores de Base de dados.
 ) Carga Incremental.
 ) Diminuir a velocidade de Carga.
 ) Aumentar a velocidade de Carga.
 ) Aumentar a carga sobre Servidores de Base de dados.
Lição 10 - Variáveis
Objetivo da Lição
• Conhecer os benefícios do uso de variáveis nas aplicações Qlik.
Uso de Variáveis
É importante conceber seus scripts de carga para que sejam flexíveis e simples de manter.
Uma das formas de se alcançar esse objetivo é o uso de variáveis.
Podem ser atribuídas com uma constante (número ou texto), ou pode ser atribuído um valor
através de uma expressão.
Utilize o comando Set para atribuir um valor diretamente, e o comando Let para atribuir um
valor através de uma expressão.
A utilização de nomes de variáveis únicas e que permitam uma fácil identificação também é
considerada uma boa prática.
Variáveis definidas no script de carga estão disponíveis na interface para o usuário. Neste caso,
vamos atribuir um valor ao ano.
Siga os passos:
• Na primeira seção do script, geralmente com o nome de Main, inclua o código
abaixo, preferencialmente na última linha dessa seção (É uma boa prática usar
essa seção apenas para definições de variáveis).
SET vAnoCarga = 2007;
• No script onde fizemos a carga da tabela Pedidos, precisamos editar a cláusula

Where.
[Pedidos]:
LOAD
ClienteID,
DataPedido,
Frete,
FuncionarioID,
PedidoID,
TransportadorID;
SQL SELECT *
FROM `Pedidos`
where year(`DataPedido`) >= $(vAnoCarga);
Será alimentado o valor de vAnoCarga quando for executado. Neste caso, o valor
será 2007.
• Não deverá haver modificações nos valores dos campos após essa nova versão do
script ser executada.
Ao criar uma variável no script não é permitido a alteração no layout
Como fazemos para resolver isso, comentamos a declaração da variável e recarregamos o

script, conforme abaixo:
Vejam que agora a variável vAnoCarga está comentado (//).
Em vez de exigir uma alteração todos os anos para manter esse script, você pode definir um
valor para a variável usando a data de sistema para alimentar esse valor.
Já que essa atribuição irá requerer uma expressão, devemos modificar o nosso comando Set
por um comando Let.
• Modifique o comando que define a variável vAnoCarga para o comando Let
conforme abaixo.
LET vAnoCarga = Year(Today())-4;
Esse comando utilizará o ano atual definido no sistema (a data de execução do

script) e subtrair 4 para obter um período de ano anterior que possui informações
para análise.
Nesta lição você conheceu e aprendeu a aplicar o uso de variáveis. Lembre-se, em caso de
dúvidas retome o conteúdo, para depois seguir seu estudo com tranquilidade.
Lição 11 - Concatenação
Objetivo da Lição
• Conhecer esse poderoso recurso de união de dados, verificando os casos onde a
concatenação se dará automaticamente.
• Forçar ou prevenir (evitar) a concatenação.
Concatenação Automática
Se os nomes e o número de campos das duas tabelas são exatamente iguais,
automaticamente, será concatenado o resultado dos diferentes comandos Load ou Select em
uma tabela.
Exemplos:
LOAD a, b, c from table1.csv;
LOAD a, c, b from table2.csv;
LOAD c, b, a from table3.csv;
A tabela lógica resultante terá os campos a, b e c.
O número de registros é a somatória do número de registros da tabela 1, tabela 2 e tabela 3.
As figuras a seguir exemplificam como se aplica a concatenação automática:

Tabela 1, primeira tabela lida
A B C
A1 B1 C1
A2 B2 C2
A3 B3 C3
Tabela 2, segunda tabela lida

A C B
A10 C10 B10
A11 C11 B11
Tabela resultante
A B C
A1 B1 C1
A2 B2 C2
A3 B3 C3
A10 B10 C10
A11 B11 C11
Observe que o rótulo da tabela resultante será o mesmo da primeira tabela lida.
Importante:
• A quantidade e os nomes dos campos devem ser exatamente os mesmos.
• Independente da ordem dos dois comandos e dos campos, o resultado será o
mesmo.
Concatenação Forçada
Mesmo se duas ou mais tabelas não tenham exatamente o mesmo conjunto de campos, ainda
será possível forçar a concatenação das duas tabelas. Isso é feito usando o prefixo concatenate
no script, que concatena uma tabela a outra nomeada ou à última tabela lógica criada
anteriormente.
Exemplo 1:
Concatenate LOAD a, c from table2.csv;
Concatenate LOAD b, a from table3.csv;
A tabela lógica resultante tem os campos a, b e c.
O número de registros na tabela resultante é a soma do número de registros na tabela 1,
tabela 2 e na tabela 3.
O valor do campo b nos registros vindos da tabela 2 e o do campo c na tabela 3 é NULL.
As figuras a seguir exemplificam como se aplica a concatenação automática:

Tabela 1, primeira tabela lida
A B C
A1 B1 C1
A2 B2 C2
A3 B3 C3
Tabela 2, segunda tabela lida

A C
A10 C10
A11 C11
Tabela resultante
A B C
A1 B1 C1
A2 B2 C2
A3 B3 C3
A10 - C10
A11 - C11
Importante:
• A quantidade e os nomes dos campos podem ser diferentes.
• A menos que o nome de uma tabela carregada anteriormente seja especificado no
comando concatenate, o prefixo concatenate utilizará a última tabela criada
anteriormente.
• Dessa forma, a ordem dos dois comandos é muito importante.
Prevenir Concatenação
Se duas tabelas têm o mesmo conjunto de campos, isso levaria a que elas fossem
automaticamente concatenadas.
Podemos prevenir essa situação com o prefixo Noconcatenate.
A utilização desse recurso previne a concatenação de qualquer tabela lógica com o mesmo
conjunto de campos:
Sintaxe:
NoConcatenate( loadstatement | selectstatement )
Exemplo:
NoConcatenate LOAD a, c, b from table2.csv;
NoConcatenate LOAD c, b, a from table3.csv;
Será gerada três tabelas interna resultante com os campos a, b e c.
O número de registros será correspondente a origem em cada tabela.
Será gerada uma chave sintética entre as três tabelas, ou seja, haverá quatro tabelas no
modelo de dados
Importante:
• A quantidade e os nomes dos campos devem ser exatamente os mesmos, se
forem diferentes não há o que ser evitado, logo o NoConcatenate não deve ser
usado.
• A concatenação será evitada independentemente de onde a definição da tabela
carregada anteriormente esteja.
• Dessa forma, a ordem dos dois comandos é muito importante.
Concatenação na prática
Nos nossos dados, temos disponível um conjunto adicional de colaboradores que não existiam
no arquivo FuncionariosEscritorios.xls.
Para inserir esses dados, vamos modificar nosso script de carga. Siga os passos:
• Localize o script de carga onde fizemos a carga da planilha Funcionários do arquivo
do Excel FuncionariosEscritorios.xls.
• Modifique a cláusula From conforme abaixo.
[Funcionarios$]:
LOAD [FuncID] AS [FuncionarioID],
[Sobrenome],
[Primeiro Nome],
[Titulo],
[Data Admissao],
[Escritorio],
[Ramal],
[Reporta a],
[Salario Anual]
FROM [lib://Fonte de Dados/Funcionarios*.xls]
(biff, embedded labels, table is Funcionarios$);
• Carregue os dados e observe no visualizador de tabelas, que como os dados
tinham exatamente a mesma estrutura, as duas tabelas foram automaticamente
concatenadas, mesmo estando em pastas de trabalho diferentes.
Nesta lição você conheceu a concatenação e verificou os casos onde ela se dará
automaticamente. Aprendeu também a forçar ou prevenir (evitar) a concatenação. Está tudo
certo até aqui? Vamos prosseguir.
Vamos praticar? Realize as atividades referentes à Lição 11.
Laboratório 11 - Concatenação
1. Crie uma nova aplicação e dê o nome de Concatenação.
a. Abra o Excel, LibreOffice ou Google Docs, como preferir, e crie um arquivo
Produtos1.xls com os seguintes dados:
Código Nome Categoria Valor
1 Arroz Alimento 4
2 Feijão Alimento 5
3 Camisa Vestuário 20
b. Altere os dados conforme abaixo e salve como Produtos2.xls.
Código Nome Categoria Valor
4 Bermuda Vestuário 10
5 Macarrão Alimento 3
6 Sapato Calçados 30
c. Altere os dados conforme abaixo e salve como Produtos3.xls.
Código Nome Valor
7 Refrigerante 4
8 Cerveja 200
9 Picanha 5
* Observe que este último arquivo está sem a coluna Categoria.
d. Arraste o primeiro arquivo Produtos1.xls para a aplicação, deixe todos os

campos marcados e carregue os dados.
e. Carregue os dados e crie uma pasta, na aplicação, com uma lista para cada
campo e também um objeto tabela com todos os campos.
f. Arraste o segundo arquivo Produtos2.xls, deixe todos os campos marcados
e carregue os dados.
g. Verifique os dados nas listas e na tabela, verifique também o Visualizador
do Modelo de Dados.
h. Arraste também o terceiro arquivo Produtos3.xls para a aplicação, deixe
todos os campos marcados e carregue os dados.
i. Verifique que na aplicação os dados foram carregados corretamente, mas
veja como ficou o Visualizador do Modelo de Dados.
j. Vá ao Editor de Carga de Dados, desbloqueie a seção que foi gerada
automaticamente e acrescente o prefixo Concatenate antes do Load do
arquivo Produtos3.xls.
k. Depois de carregar os dados, veja como ficou o visualizador de modelo de
dados.
2. Observe a seguinte explicação e assinale a que conceito corresponde.

Se duas ou mais tabelas não têm exatamente o mesmo número de campos, ainda
é possível forçar a concatenação das duas tabelas. Isso é feito com o prefixo
concatenate no script, que concatenará uma tabela com outra com outro nome ou
com uma tabela lógica previamente criada.
 ) Concatenação automática.
 ) Prevenir concatenação.
 ) Concatenação de campos.
 ) Concatenação forçada.
 ) Concatenação de tabelas.
Lição 12 - Depuração
Objetivo da Lição
• Conhecer os recursos do Depurador de Script para saber utilizá-lo para localizar
problemas no script.
Depuração
Você pode usar os utilitários de depuração no editor de script de carga para percorrer a
execução do seu script usando pontos de interrupção, podendo assim inspecionar os valores,
variáveis e a saída da execução do script.
É possível selecionar se você deseja ver uma ou todas as Saídas, Variáveis e Pontos de
interrupção.
Importante:
Você não pode criar conexões, editar conexões, selecionar dados, salvar o script ou
carregar dados enquanto estiver executando no modo de depuração, isto é, desde
quando começou a execução da depuração até que o script seja executado ou a
execução termine.
Para entrar no modo de depuração, basta clicar no ícone que está ao lado direito, Mostrar
Painel de Depuração.
3 1 2
5 6 7
A imagem mostra ao centro o script (1).
A posição da execução é marcada por uma linha laranja (2).
É possível definir pontos de interrupção clicando no número da linha, à esquerda de um
comando (3).
Após clicar no número da linha, o ponto de interrupção é marcado por um o ícone laranja (3).
Um quadrado sobre o script (4) mostra o comando que está prestes a ser executado no modo
incremento ou que está sendo executado no modo executar.
A aba Saída (5) mostra o status e possíveis mensagens de erro, basicamente as mesmas
informações que no diálogo de progresso do script.
A aba Variáveis (6) mostra todas as variáveis e respectivos valores, as variáveis alteradas são
mostradas em ordem de alteração da mais recente a mais antiga mudança.
A aba Pontos de Interrupção (7) mostra todas as pausas incluídas no script, suas respectivas
seções e opções de desativar ou excluir os pontos.
A depuração pode ser executada de forma incremental, direta ou interrompida a qualquer
momento.
Nesta lição, você conheceu os recursos do Depurador de Script, para saber utilizá-lo para
localizar problemas no script.
Hora de atividade! Realize as atividades referentes à Lição 13.
Laboratório 13 - Depurar
1. Usando a imagem a cima, que mostra a tela de depuração, preencha corretamente
as opções abaixo com os números possíveis.
 ) Exibe todas as variáveis e respectivos valores.
 ) Ao clicar no número da linha, é criado um ponto de interrupção.
 ) Script de carga de dados.
 ) Exibe o status e possíveis mensagens de erros.
 ) Exibe todos os pontos de interrupção com opções de desativar ou
remover o ponto.
Gabarito dos Laboratórios
Lição 1 - Plano de Projeto
2. Um plano de projeto é um documento guia com a finalidade de orientar o caminho a ser seguido
durante o curso para alcançar um objetivo.
3. C, A, D, E, G, D, B.
Lição 2 - Estrutura de Dados

3. B, A, D, C
Lição 3 - Script de Carga

2. A
Lição 4 - Preparação de Dados

2. Qualificar campos significa identificar os campos concatenando o nome da tabela com o nome dos
campos.
Lição 5 - Load Resident, Chave Sintética e Função Exists()

2. C
Lição 6 - Campos Chave

7. Campos chave são aqueles que são comuns em duas ou mais tabelas (campos associados).
Lição 7 - Cálculos, Include e Dimensões de Tempo

4. Utilizando o comando Autogenerate no script de carga ou o Load Inline.
Lição 8 - Tratamento de dados não padronizados

5. A
Lição 9 - Arquivos QVD

3. Diminuir a carga sobre Servidores de Base de dados; Carga Incremental; Aumentar a velocidade de
Carga.
Lição 11 - Concatenação
2. Concatenação forçada.
Lição 12 - Depuração
1. 6; 3; 1; 5; 7.

Qlik Sense Arquitetura de Dados - Apostila 2018-04

Enviado por

Direitos autorais:

Formatos disponíveis

Qlik Sense Arquitetura de Dados - Apostila 2018-04

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Qlik Sense Arquitetura de Dados - Apostila 2018-04

Enviado por

Direitos autorais:

Formatos disponíveis

CURRÍCULO OFICIAL

Abril de 2018 - Quarta Edição

As informações contidas neste documento, incluindo URLs e outras referências a

Verifique o diretório Fonte de Dados com os seguintes arquivos:

Instalação do Qlik Sense Desktop

Na pasta instaladores, execute o arquivo Qlik_Sense_Desktop_setup.exe e siga as instruções.

Lição 1 - Plano de Projeto

O que é um Plano de Projeto?

Indicadores Chave de Performance

Descrição dos Dados

Laboratório 01 - Plano de Projeto

Exemplo de Modelo Associativo

Comandos de Carga de Dados

ODBC CONNECT TO [MS AccessDatabase;DBQ=data\sampledata.mdb];

ODBC CONNECT TO [COSQL01;DATABASE=SALESDATA;Trusted_Connection=Yes];

LIB CONNECT TO ‘OLEDB-QWT’;

SQL SELECT DISTINCT I.AddressID, Name, Address,

Exemplos de Saídas de Dados:

REM - Transforma em comentário tudo que estiver entre ele até o

IF $(vUltimaCarga) = TODAY()-7 THEN

FOR EACH vPlan IN 'Plan1','Plan2','Plan3'

Laboratório 02 - Estrutura de Dados

Criar Conexão OLE DB

Passos para criação da Conexão OLE DB

Ou clicar: (Diálogo Bem-vindo)

2. Vá em Adicionar dados e verá a tela inicial do assistente.

3. Clique na opção OLE DB em Conectar-se a uma nova fonte de dados.

Podemos criar novos campos calculados, alterar o tipo e renomear os campos...

Ao clicar na barra de ferramentas localizado acima dos nomes dos

• Para adicionar mais dados, clique em no Gerenciador de dados.

Como podemos ver, precisamos fazer as associações entre as tabelas

Laboratório 03 - Script de Carga

Carga de Dados – Excel – Funcionários

Carga de Dados – Excel – Escritórios

Marque a planilha Funcionarios$ e mude o rótulo de FuncID para FuncionarioID, também

Entre outros avisos, a associação de Pedidos -

Lição 5 - Load Resident, Chave Sintética e Função Exists()

Modifique a clausula Where na tabela Vendedores utilizando a função Exists().

Lição 6 - Campos Chave

Vendedor Produto ClienteID Quantidade

Frank Roll Lace Shoes 51 3

Frank Roll Lace Shoes 82 3

Joan Callins Casual Boots 84 4

Lennart Skoglund Casual Boots 14 3

Rob Carsson Lace Shoes 89 3

Tom Lindwall Lace Shoes 24 6

Nesta lição, você aprendeu a identificar os problemas de cálculo de frequência (contagem)

Laboratório 06 - Campos Chave

Lição 7 - Cálculos, Include e Dimensões de Tempo

Laboratório 07 - Cálculos, Include e Dimensões de Tempo

Lição 8 - Tratamento de dados não padronizados

• Clique no ícone editar da tabela de Orçamento$

• Clique no botão Não girar e selecione as colunas de ano

Altere o script conforme abaixo:

1º Passo – carregar uma nova tabela com o campo chave

2º Passo – colocar os nomes da tabela em uma lista

DROP TABLE [$(vNomeTabela)];

Ao final da execução teremos a tabela combinada conforme abaixo:

Laboratório 08 - Tratamento de dados não padronizados