Melhores Práticas para

Construção de Aplicativos
Qlik Sense

Acesse:
Curso Completo de Qlik Sense
do Básico ao Avançado com
Extras de Especialistas
Lista de verificação do aplicativo
A Lista de verificação do aplicativo tem o objetivo de ser uma lista de verificação das melhores
práticas para um único aplicativo Qlik Sense

Este relatório pode ser usado para ajudar a diagnosticar um problema ou simplesmente usado
como uma lista de verificação das melhores práticas. Ele também pode ser usado
internamente como parte de um processo de fluxo de trabalho para garantir que um aplicativo
tenha passado pelas etapas de otimização necessárias antes de entrar em produção.
Sumário
Chaves sintéticas removidas ......................................................................................................... 4
Referências circulares removidas do modelo de dados................................................................ 4
Granularidade apropriada de dados ............................................................................................. 5
QVDs usados sempre que possível................................................................................................ 5
Arquivos QVD otimizados no carregamento ................................................................................. 5
Cargas incrementais alavancadas ................................................................................................. 5
Modelo de floco de neve consolidado .......................................................................................... 6
As tabelas com um pequeno número de campos são desnormalizadas ...................................... 7
Tabelas de pesquisa desnormalizadas (folha) com cargas de mapeamento ................................ 7
Timestamps removidos ou desacoplados do campo de data ....................................................... 7
Campos desnecessários removidos do modelo de dados ............................................................ 7
Tabelas de links evitadas se grandes volumes de dados .............................................................. 8
Dimensões concatenadas quebradas em novos campos.............................................................. 8
Numeração automática usada onde possível ............................................................................... 8
Ilhas de dados evitadas ................................................................................................................. 8
QVDs são armazenados com base em prazos incrementais ......................................................... 8
A função If é evitada sempre que possível.................................................................................... 9
Agr. E Agr. Aninhados são usados minimamente ......................................................................... 9
A Análise de Conjunto é usada sempre que possível .................................................................... 9
Comparações de strings evitadas sempre que possível .............................................................. 10
As condições de cálculo são usadas em objetos que contêm cálculos intensivos...................... 10
As medidas são pré-calculadas no script sempre que possível .................................................. 10
As tabelas têm menos de 15 * colunas e têm condições de cálculo sempre que possível ........ 10
QVFs estrategicamente divididos para lidar com grandes volumes de dados ........................... 11
As folhas não contêm uma quantidade excessiva de objetos .................................................... 11
Sinalizadores numéricos são aproveitados no script para uso na análise de conjunto .............. 12
Itens mestre e / ou variáveis usadas para expressões ................................................................ 12
Desempenho do modelo de dados
Indicadores que podem impactar o desempenho do modelo de dados. Verifique cada um que
foi seguido para este aplicativo.

Chaves sintéticas removidas

O Qlik Sense cria chaves sintéticas quando duas ou mais tabelas de dados têm dois ou mais
campos em comum. Essas chaves são campos anônimos que representam todas as
combinações ocorridas da chave composta.

Se você receber um aviso sobre chaves sintéticas ao carregar dados, deverá revisar a estrutura
de dados no visualizador do modelo de dados. Você deve se perguntar se o modelo de dados
está correto ou não. Às vezes é, mas na maioria das vezes a chave sintética está lá devido a um
erro no script.

Muitas chaves sintéticas costumam ser um sintoma de um modelo de dados incorreto. No

entanto, um sinal claro de um modelo de dados incorreto é se você tiver chaves sintéticas
baseadas em outras chaves sintéticas.

Referências circulares removidas do modelo de dados

Se houver referências circulares ("loops") em uma estrutura de dados, as tabelas são
associadas de forma que haja mais de um caminho de associações entre dois campos.

Este tipo de estrutura de dados deve ser evitado tanto quanto possível, pois pode levar a
ambigüidades na interpretação dos dados.

Três tabelas com referência circular, visto que existe mais de um caminho de associações entre
dois campos.
Granularidade apropriada de dados
Certifique-se de ter carregado os dados necessários para a análise no aplicativo. Por exemplo,
se na maioria dos casos, agregações semanais / mensais / trimestrais forem suficientes, você
pode carregar os dados agregados ou agregar os dados no script de carregamento do Qlik para
economizar memória. Se um usuário precisar visualizar os dados em um nível inferior de
granularidade, você poderá empregar métodos como ODAG ou encadeamento de documentos
para obter detalhes.

O Qlik pode manipular uma grande quantidade de dados na memória, mas nem sempre é
necessário fazer isso.

QVDs usados sempre que possível

UMA QVD (dados QlikView)file é um arquivo que contém uma tabela de dados exportados do
Qlik Sense .QVDé um formato nativo do Qlik e só pode ser gravado e lido pelo Qlik Sense ou
QlikView . O formato do arquivo é otimizado para velocidade ao ler dados de um script, mas
ainda é muito compacto. Lendo dados de umQVD arquivo é tipicamente 10-100 vezes mais
rápido do que ler de outras fontes de dados.

QVDos arquivos podem ser lidos em dois modos: padrão (rápido) e otimizado (mais rápido). O
modo selecionado é determinado automaticamente pelo mecanismo de script.

Arquivos QVD otimizados no carregamento

As cargas otimizadas do QVD são muito eficientes e rápidas, e são o resultado do
carregamento do QVD diretamente, sem qualquer transformação. No entanto, há uma única
exceção: a cláusula WHERE EXISTS () . Essa cláusula ainda permitirá que o QVD seja carregado
com eficiência.

Portanto, em vez de usar uma cláusula como WHERE Country = 'US' , considere primeiro o
carregamento de uma tabela embutida com quaisquer valores e, em seguida, o uso de uma
função exists () em relação a esses valores.

Cargas incrementais alavancadas

Se seu aplicativo contiver uma grande quantidade de dados de fontes de banco de dados que
são continuamente atualizados, recarregar todo o conjunto de dados pode ser demorado.
Nesse caso, você deseja carregar registros novos ou alterados do banco de dados. Todos os
outros dados já devem estar disponíveis no aplicativo. Carga incremental usandoQVD arquivos,
torna isso possível.

O processo básico é descrito abaixo:

Carregue dados novos ou atualizados da tabela de origem do banco de dados.

Este é um processo lento, mas apenas um número limitado de registros é carregado.

Carregue os dados que já estão disponíveis no aplicativo do QVD Arquivo.

Muitos registros são carregados, mas este é um processo muito mais rápido.

Crie um novo QVD Arquivo.

Este é o arquivo que você usará na próxima vez que fizer um carregamento incremental.

Repita o procedimento para cada tabela carregada.

Modelo de floco de neve consolidado

Em geral, a maneira como você carrega dados no aplicativo pode ser explicada pelo processo
de extração, transformação e carregamento:
• Extrair
A primeira etapa é extrair dados do sistema de fonte de dados. Em um script, você usa
as instruções SELECT ou LOAD para definir isso. As diferenças entre essas afirmações
são:

o SELECT é usado para selecionar dados de umODBC fonte de dados ou OLE

DBfornecedor. O SELECT SQLdeclaração é avaliada pelo provedor de dados,
não pelo Qlik Sense .
o LOAD é usado para carregar dados de um arquivo, de dados definidos no
script, de uma tabela carregada anteriormente, de uma página da web, do
resultado de uma instrução SELECT subsequente ou gerando dados
automaticamente.
• Transformar
O estágio de transformação envolve a manipulação dos dados usando funções de
script e regras para derivar a estrutura do modelo de dados desejada. As operações
típicas são:

o Calculando novos valores

o Traduzindo valores codificados
o Renomeando campos
o Juntando mesas
o Valores agregados
o Pivotando
o Data de validade
• Carga
Na etapa final, você executa o script para carregar o modelo de dados que definiu no
aplicativo.
Seu objetivo deve ser criar um modelo de dados que permita o manuseio eficiente dos dados
no Qlik Sense . Normalmente, isso significa que você deve ter como objetivo um esquema em
estrela ou em floco de neve razoavelmente normalizado sem nenhuma referência circular, ou
seja, um modelo em que cada entidade é mantida em uma tabela separada. Em outras
palavras, um modelo de dados típico seria assim:

• uma tabela de fatos central contendo as chaves para as dimensões e os números

usados para calcular as medidas (como número de unidades, valores de vendas e
valores de orçamento).
• tabelas circundantes contendo as dimensões com todos os seus atributos (como
produtos, clientes, categorias, calendário e fornecedores).

As tabelas com um pequeno número de campos são

desnormalizadas
Normalmente, se você tiver um pequeno número de campos em uma tabela dimensional, é
vantajoso unir esses campos ao fato e, assim, potencialmente fornecer a você a capacidade de
eliminar a chave. Sempre sugerido no caso de dois campos (uma tabela de pesquisa). Não
existe uma regra padrão para isso (além de dois campos), mas considere fazer alguns testes
para ver se há um aumento / diminuição de desempenho.

Tabelas de pesquisa desnormalizadas (folha) com cargas de

mapeamento
Evite utilizar Join, Utilize ApplyMap()

Timestamps removidos ou desacoplados do campo de data

Os campos de data podem preencher espaço quando o carimbo de data / hora está presente
por meio de valores maiores e exclusividade potencialmente desnecessária por meio de
valores de carimbo de data / hora distintos.

Ao trabalhar com datas, se o timestamp não for necessário para sua análise, você pode
removê-lo usando Date (Floor (YourDateField)) . Se você quiser o carimbo de data / hora, pode
opcionalmente desacoplá-lo da própria data. Você pode usar a mesma função Floor () e, em
seguida, criar um novo campo com o carimbo de data / hora extraído usando algo ao longo das
linhas de: Time (Frac (Timestamp # (YourDateField, 'MM / DD / YYYY h: mm: ss TT' )))

Campos desnecessários removidos do modelo de dados

É vital que você carregue apenas os campos necessários em seu modelo de dados. Tente evitar
o uso de SELECT * .

Há duas coisas a verificar: 1. Este campo é necessário para minha análise? 2. Agora que
carreguei todos os meus campos e dei tempo para os usuários alavancarem o aplicativo, quais
campos estão realmente sendo usados?
Esses processos envolvem revisões técnicas e de negócios e podem ser acelerados usando uma
ferramenta como o Analisador de Documentos de Rob Wunderlich , que relatará quais campos
são usados / não usados em um aplicativo depois de implantado.

Tabelas de links evitadas se grandes volumes de dados

Há muito debate entre quando usar tabelas de links ou quando concatenar tabelas. Em geral,
parece que a maioria das pessoas concorda em usar tabelas de links sempre que possível; no
entanto, ao lidar com grandes volumes de dados, as tabelas concatenadas podem superar as
tabelas de links.

Dimensões concatenadas quebradas em novos campos

No mesmo vão que lidar com datas e carimbos de data / hora, se você puder, é mais eficiente
separar dimensões concatenadas em campos separados. Fazendo isso, você reduzirá a
quantidade de ocorrências exclusivas de valores em seus campos.

Numeração automática usada onde possível

Esta instrução cria um valor inteiro exclusivo para cada valor avaliado distinto em um campo
encontrado durante a execução do script.

Você também pode usar a função autonumber-script function dentro de uma instrução LOAD ,
mas isso tem algumas limitações quando você deseja usar uma carga otimizada. Você pode
criar uma carga otimizada carregando os dados de um arquivo QVD primeiro e, em seguida,
usando a instrução autonumber para converter valores em chaves de símbolo.

Ilhas de dados evitadas

As ilhas de dados podem ser incrivelmente úteis, mas quase sempre afetam negativamente o
desempenho - às vezes muito. Considere o uso de variáveis se estiver criando ilhas para
valores de seleção.

QVDs são armazenados com base em prazos incrementais

É considerada uma prática recomendada armazenar QVDs em segmentos, por exemplo,
mensalmente. Dessa forma, você não acaba com arquivos QVD monolíticos, e esses QVDs
mensais menores podem então suportar muitos aplicativos diferentes que podem não precisar
de todos os dados.
Desempenho da Interface
Indicadores que podem impactar o desempenho no front-end. Verifique cada um que foi
seguido para este aplicativo.

A função If é evitada sempre que possível

Sugere-se que if () seja evitado sempre que possível, já que if () opera no nível de registro. Se
você tiver 1k registros em uma agregação, ele avaliará essa condição if () 1k vezes. Você pode
ver como isso pode começar a se espalhar rapidamente conforme você começa a aninhar
essas instruções. Sempre que possível, use a análise de conjunto em vez de uma instrução if (),
pois o filtro de análise de conjunto é aplicado antes da agregação, resultando em uma resposta
muito mais rápida. Essas respostas também podem ser armazenadas em cache por meio de
análise de conjunto, onde como if () não é.

É claro que existem alguns cenários onde if () não pode ser evitado, mas use-os com
moderação e considere o potencial de outras funções e modificações no modelo de dados
para que possam ser evitados ou simplificados.

Agr. E Agr. Aninhados são usados minimamente

A função Aggr (), embora incrivelmente valiosa e poderosa, nem sempre deve ser usada. Aggr
() é uma função de alto custo e, quando usada incorretamente (como em uma tabela com
dimensões que variam das dimensões dentro da função Aggr ()), você pode realmente acabar
com resultados incorretos.

A Análise de Conjunto é usada sempre que possível

A análise de conjunto oferece uma maneira de definir um conjunto (ou grupo) de valores de
dados que é diferente do conjunto normal definido pelas seleções atuais.

Normalmente, quando você faz uma seleção, as funções de agregação, como Sum , Max , Min ,
Avg e Count agregam sobre as seleções que você fez: as seleções atuais. Suas seleções definem
automaticamente o conjunto de dados a ser agregado. Com a análise de conjuntos, você pode
definir um grupo independente das seleções atuais. Isso pode ser útil se você deseja mostrar
um valor específico, por exemplo, a participação de mercado de um produto em todas as
regiões, independentemente das seleções atuais.

A análise de conjuntos também é poderosa ao fazer diferentes tipos de comparações, como

quais são os produtos mais vendidos em comparação com produtos mal vendidos ou este ano
em relação ao ano passado.

Vamos imaginar um exemplo em que você comece a trabalhar em um aplicativo selecionando

o ano de 2010 em um painel de filtro. As agregações são baseadas nessa seleção e as
visualizações mostram apenas os valores para aquele ano. Quando você faz novas seleções, as
visualizações são atualizadas de acordo. As agregações são feitas sobre o conjunto de registros
possíveis definidos pelas seleções atuais. Com a análise de conjuntos, você pode definir um
conjunto que seja de seu interesse e não dependa das seleções.

Comparações de strings evitadas sempre que possível

As comparações de strings não são tão eficientes quanto a análise de conjuntos. Os exemplos
são: Match (), MixMatch (), WildMatch, Pick, etc. Use-os apenas quando necessário, por
exemplo, no script de carregamento como parte de uma instrução WHERE . Evite-os no front-
end quando possível e, em vez disso, crie sinalizadores no script ou use a análise de conjunto.

As condições de cálculo são usadas em objetos que contêm

cálculos intensivos
É comum ter visualizações no Qlik Sense com o potencial de ter muitos registros sem nenhuma
seleção. Para evitar a possibilidade de criar hipercubos muito grandes, é considerada uma
prática recomendada adicionar condições de cálculo aos objetos para que eles sejam
renderizados somente após determinadas seleções terem sido feitas, renderizando assim um
hipercubo menor.

Um exemplo disso poderia ser algo como GetSelectedCount ([Country]) = 1 OR

GetPossibleCount ([Country]) = 1 . Nesse cenário, um usuário deve ter selecionado um único
país ou ter feito outras seleções até o ponto em que apenas um único país seja possível para a
visualização ser renderizada.

As medidas são pré-calculadas no script sempre que possível

Qualquer medida que esteja no nível mais baixo de granularidade do modelo de dados
provavelmente deve ser calculada no script. Por exemplo, se no mesmo registro de uma tabela
você tiver Vendas e Custo , poderá derivar a margem calculando Vendas - Custo AS Margem .
Isso evita que o cálculo seja feito desnecessariamente no front-end.

Opcionalmente, você pode agregar outros valores com antecedência para salvar o cálculo no
front-end, se souber que eles não variam na seleção ou estão vinculados a um nível diferente
de granulação.

As tabelas têm menos de 15 * colunas e têm condições de cálculo

sempre que possível
O número 15 neste caso é completamente arbitrário - é uma linha grosseira do que alguns
considerariam uma mesa larga se maior que. Se suas tabelas consistirem em muitos registros,
considere aproveitar as condições de cálculo no objeto de tabela para que ele seja renderizado
somente depois que certas seleções ou critérios forem atendidos. Se sua tabela for muito
ampla, considere a criação de várias tabelas menores que mostram condicionalmente, usando
métodos para mostrar colunas condicionalmente ou simplesmente mantenha suas tabelas
limitadas a apenas os campos necessários para sua análise.
QVFs estrategicamente divididos para lidar com grandes volumes
de dados
Ao lidar com grandes volumes de dados, há muitas estratégias ao projetar a arquitetura de
seus aplicativos. Aqui estão três estratégias:

Segmentação: Segmentando QVDs e QVFs por timeframes ou outra dimensionalidade como

região. Você pode ter um QVF que visualize os dois anos mais recentes, depois outro que
visualize os anos anteriores, e um QVF grande que contenha todos os dados que são usados
apenas quando necessário por um pequeno subconjunto de usuários. Outra abordagem pode
ser ter vários aplicativos focados em regiões diferentes, para que o usuário não abra um
aplicativo com dados que não lhes interessa ou que tenham o direito de ver (dados que não
podem ser vistos por meio de acesso de seção ainda afetam a memória ) Com esse método, o
aplicativo mais leve (dados mais recentes) será usado pela maioria dos usuários,
economizando memória, pois é tudo o que eles normalmente precisam.

ODAG: ODAG significa geração de aplicativo sob demanda e é um método em que você tem
dois aplicativos: 1. um carrinho de compras (dados agregados), 2. um aplicativo de modelo
vazio para exibir detalhes. O fluxo de trabalho é tal que um usuário deve primeiro fazer
seleções no aplicativo de carrinho de compras (este critério é totalmente personalizável) e,
uma vez que um limite for atingido, um script LOAD personalizado é criado, o que preenche o
aplicativo de modelo com todos os detalhes solicitados .

Encadeamento de Documentos: O encadeamento de documentos é onde você tem um

aplicativo agregado que normalmente é suficiente para o usuário, mas quando o usuário
precisa dos detalhes, as seleções podem ser passadas do aplicativo agregado para o aplicativo
de detalhes para que eles possam visualizar um nível inferior de granularidade. Isso mantém
uma baixa pegada de usuário no aplicativo de detalhes, reduzindo assim a memória de todos
que carregam detalhes desnecessários.

As folhas não contêm uma quantidade excessiva de objetos

Depois que um usuário navega para uma pasta, os objetos são calculados. Em seguida, toda
vez que um usuário fizer uma seleção naquela planilha, cada objeto será recalculado se o
estado atual não existir no cache. Se você tiver uma planilha com uma grande quantidade de
objetos, o usuário terá que esperar que todos esses objetos calculem em quase todas as
seleções, o que pode colocar uma carga significativa no motor se for um grande aplicativo e,
portanto, resultar em potencialmente tempos de cálculo demorados. É considerada uma
prática recomendada não tentar ferver o oceano em uma única folha, mas seguir o conceito
DAR (Painel / Análise / Relatório) para desenvolver um fluxo limpo e mínimo (ou necessário)
em seu aplicativo. Isso ajuda a aumentar a adoção e a compreensão do aplicativo e,
frequentemente, ajuda o desempenho.
Sinalizadores numéricos são aproveitados no script para uso na
análise de conjunto
Usar a análise de conjunto com sinalizadores pode ser significativamente mais eficiente do que
usar comparações ou multiplicação de strings. Veja o artigo abaixo para comparações de
cálculos.

Itens mestre e / ou variáveis usadas para expressões

Não é apenas uma prática recomendada usar os itens principais de um ponto de vista de
autoatendimento (habilitando arrastar e soltar de métricas controladas), mas também garantir
que as expressões sejam armazenadas em cache. Por exemplo, Sum (Sales) é diferente de SUM
(Sales), que é diferente de Sum (Sales) e assim por diante. As expressões são armazenadas em
cache de grafia e maiúsculas e minúsculas - e precisam corresponder literalmente para serem
reutilizadas. Aproveitar os itens mestres (ou potencialmente usar variáveis - talvez até
variáveis em itens mestres) garante que as expressões usadas pelos usuários serão todas iguais
e, portanto, armazenadas em cache.

Acesse:
Curso Completo de Qlik Sense
do Básico ao Avançado com
Extras de Especialistas