Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL

Prévia do material em texto

Manual de Treinamento de Introdução
ao ECL (Parte 2) - ETL com ECL
Equipe de Treinamento HPCC
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Equipe de Treinamento HPCC
Copyright © 2020 HPCC Systems. All rights reserved
Sua opinião e comentários sobre este documento são muito bem-vindos e podem ser enviados por e-mail para <docfeedback@hpccsystem-
s.com> Inclua Feedback sobre a documentação no título do email e faça referência ao nome do documento, número de página e número da
versão atual no texto da mensagem.
LexisNexis e o logotipo Knowledge Burst são marcas comerciais registradas da Reed Elsevier Properties Inc., usadas sob licença. Os demais
produtos, logotipos e serviços podem ser marcas comerciais ou registradas de suas respectivas empresas. Todos os nomes e dados de exemplo
usados neste manual são fictícios. Qualquer semelhança com pessoas reais, vivas ou mortas, é mera coincidência.
1 de fevereiro de 2020 Versão 7.6.0
© 2020 HPCC Systems. All rights reserved
2
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Visão Geral ........................................................................................................................................ 5
Introdução .................................................................................................................................. 5
Convenções de Documentação ...................................................................................................... 9
Definir e organizar seus dados ............................................................................................................. 10
Exercício 1: Organize suas definições de dados .............................................................................. 10
Relatórios de tabulação ....................................................................................................................... 12
TABLE .................................................................................................................................... 13
Relatórios Cross-Tab ................................................................................................................ 15
Exemplo de tabulação funcional ................................................................................................... 18
Exercício 2a ............................................................................................................................. 19
Exercício 2b ............................................................................................................................. 19
Mais relatórios de avaliação de dados ................................................................................................... 21
DISTRIBUTE "Randômico" ........................................................................................................ 22
HASH32 .................................................................................................................................. 25
Exercício 3a ............................................................................................................................. 26
Exercício 3b ............................................................................................................................. 27
Padrões dos Dados .................................................................................................................... 28
Visualização ............................................................................................................................. 32
Exercício 3c ............................................................................................................................. 37
Exercício 3d ............................................................................................................................. 38
Transformações simples ...................................................................................................................... 39
Estrutura TRANSFORM ............................................................................................................. 39
PROJECT ................................................................................................................................ 42
Exemplo funcional de PROJECT ................................................................................................. 46
ITERATE ................................................................................................................................. 48
Exemplo funcional ITERATE ...................................................................................................... 50
PERSIST .................................................................................................................................. 52
Estrutura SERVICE ................................................................................................................... 53
Node ....................................................................................................................................... 55
Nodes ...................................................................................................................................... 56
Exercício 4a ............................................................................................................................. 57
Exercício 4b ............................................................................................................................. 58
Padronização de dados ....................................................................................................................... 59
SIZEOF ................................................................................................................................... 60
Exercício 5a ............................................................................................................................. 62
Exercício 5b ............................................................................................................................. 63
Criando tabelas lookup ....................................................................................................................... 64
ROLLUP .................................................................................................................................. 65
Exemplo de ROLLUP funcional .................................................................................................. 69
Exercício 6a ............................................................................................................................. 71
Exercício 6b ............................................................................................................................. 71
Juntando arquivos .............................................................................................................................. 72
JOIN ....................................................................................................................................... 73
Exemplo de JOIN funcional ........................................................................................................ 82
INTFORMAT ........................................................................................................................... 85
Exercício 7a ............................................................................................................................. 86
Exercício 7b ............................................................................................................................. 87
Exercício 7c ............................................................................................................................. 88
Soluções para exercícios de laboratório .................................................................................................89
Exercício 1 ............................................................................................................................... 89
Exercício 1 (continuação) ........................................................................................................... 90
Exercício 2a ............................................................................................................................. 91
Exercício 2b ............................................................................................................................. 91
Exercício 3a ............................................................................................................................. 92
© 2020 HPCC Systems. All rights reserved
3
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Exercício 3b ............................................................................................................................. 92
Exercício 3c ............................................................................................................................. 92
Exercício 3d ............................................................................................................................. 93
Exercício 4a ............................................................................................................................. 94
Exercício 4b ............................................................................................................................. 95
Exercício 5a ............................................................................................................................. 96
Exercício 5b ............................................................................................................................. 97
Exercício 6a ............................................................................................................................. 98
Exercício 6b ............................................................................................................................. 99
Exercício 7a ............................................................................................................................ 100
Exercício 7a (continuação) ........................................................................................................ 101
Exercício 7b ............................................................................................................................ 102
Exercício 7c ............................................................................................................................ 103
© 2020 HPCC Systems. All rights reserved
4
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Visão Geral
Visão Geral
Introdução
Bem-vindo ao curso de Introdução ao ECL (parte 2) - o processo de Extração, Transformação e Carregamento (ETL).
Este curso contém um conjunto de exercícios práticos, usando os recursos avançados de manipulação de dados da
ECL e do HPCC Systems (High Performance Computing Cluster) da LexisNexis, com foco específico na Refinaria
de Dados (THOR).
Esses exercícios são agrupados por áreas de tópicos avançados, focadas em funções ou recursos específicos da lin-
guagem ECL. Uma revisão e discussão aprofundadas das funções ECL utilizadas precederão cada conjunto de exer-
cícios.
O que é THOR?
Thor (o Cluster de Refinaria de Dados) é a parte do HPCC Systems responsável por consumir grandes quantidades
de dados, transformar, vincular e indexá-los. Ele funciona como um sistema de arquivos distribuído com poder de
processamento paralelo espalhado por vários nós. Um cluster pode escalar de um único nó para milhares de nós. O
termo THOR refere-se ao mítico deus nórdico do trovão, com o grande martelo usado como simbolo para esmagar
grandes quantidades de dados brutos em informações úteis. Esse processo de "martelar os dados" é mais conhecido
como Processo de Extração, Transformação e Carregamento ou ETL (Extract, Transform and Load).
Visão Geral do Processo ETL
Nesse momento, você deve saber que a ECL (Enterprise Control Language) é uma linguagem centrada em dados pro-
jetada e usada apenas com o HPCC Systems (High Performance Computer Cluster). Ele foi projetado especificamente
para gerenciamento de dados e processamento de consultas. A linguagem é declarativa; você define quais dados pre-
cisa por meio de uma variedade de definições e cria as ações de ECL executadas sobre elas.
Tudo começa com sua fonte de dados, que é movida e armazenada no HPCC por meio da Refinaria de Dados THOR.
Arquivos de dados e índices adicionais são produzidos e manipulados no processo ETL. Esse processo de ETL pode
variar com base no conteúdo e tipo de construção necessário, e no número e tipos de fontes.
A extração envolve a importação e a limpeza de dados brutos de várias fontes.
O principal objetivo da fase de extração é converter os dados em formatos utilizáveis, adequados ao processamento de
transformação de dados no HPCC. Outra parte da fase de extração envolve a análise dos dados extraídos para verificar
se os dados atendem a um padrão ou estrutura esperado. Caso contrário, parte ou todos os dados podem ser rejeitados.
A transformação envolve a combinação e a coleta de informações de várias fontes.
• Mapeamento de campos de origem para layouts de registros comuns usados nos dados.
• Divisão ou combinação de arquivos, registros ou campos de origem para corresponder ao layout necessário.
• Padronização e limpeza de campos de pesquisa vitais, como nomes, endereços, datas, etc.
• Avaliação dos prazos atuais e históricos de informações vitais para identificação cronológica e localização dos su-
jeitos.
© 2020 HPCC Systems. All rights reserved
5
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Visão Geral
• Análise estatística e outras análises diretas dos dados para determinar e manter a qualidade à medida que novas fontes
e atualizações são incluídas.
O processo de transformação geralmente requer várias etapas, incluindo, entre outras:
1. Mapear e converter dados do campo de origem em layouts de registros comuns, dependendo de sua finalidade.
Alguns exemplos incluem:
• Combinar vários registros em um único (desnormalizar) ou dividir registros únicos em vários registros filho rela-
cionados (normalizar).
• Traduzir códigos em descrições e/ou vice-versa.
• Divisão de nomes conjuntivos.
• Reformatação e validação de campos de data.
• Identificar e anexar IDs internos a pessoas, empresas e outras entidades, para vinculá-los entre datasets.
2. Aplique regras de duplicação e combinação a cada dataset de origem e aos datasets de construção comuns, conforme
necessário:
• Dependendo do tipo de fonte, os datasets são processados. Todos os novos registros serão simplesmente adicionados,
os registros existentes podem precisar ser atualizados ou os registros existentes podem ter que ser substituídos.
• As duplicatas podem ter que ser identificadas e excluídas ou combinadas com os dados existentes, possivelmente
expandindo o período válido dos dados.
• Vincular registros entre si, se aplicável, fornecendo linhas de tempo de atividade ou status.
Carregamento envolve a produção de índices para entrega de dados ao cliente (ou usuário final).
O processo de carregamento envolve a construção de índices e a implantação de dados e consultas em um cluster
ROXIE.
• Criar um índice é principalmente uma operação de classificação, e é por isso que o THOR é usado para esse processo.
• Os índices criados no THOR são geralmente usados em um cluster ROXIE para atender a consultas interativas e para
acessar rapidamente um registro específico necessário para uma consulta individual.
• Os índices criados no THOR também podem ser usados no THOR/ECL Agent.
OBSERVAÇÃO: Nesta aula, focaremos inteiramente as fases de Extração e Transformação do ETL. O processo de
carregamento é abordado nos cursos Roxie básico e avançado, mais adiante nestasérie.
ECL em ETL - 4 Objetivos Principais
Ao iniciar qualquer processo ETL, há quatro (4) objetivos principais pelos quais você deve sempre se esforçar.
1. Entenda (conheça) seus dados.
Comece a conhecer seus dados, definindo-os primeiro após o spraying. Em seguida, use os relatórios de tabulação
cruzada ("agrupados por" TABLE) para obter contagens de população de campos, determinar a cardinalidade (exclu-
sividade) dos valores dos campos-chave (a função COUNT por valor exclusivo) para descobrir possíveis desvios,
© 2020 HPCC Systems. All rights reserved
6
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Visão Geral
obtenha valores numéricos MAX e MIN para identificar valores reais, intervalos de valores de campo e valores fora
do esperado, além de outros problemas possíveis com os dados. Use essas informações para desenvolver estratégias
para distribuição uniforme em todos os nós, compactação de dados e arquitetura.
2. Opere apenas com os dados necessários.
As seguintes técnicas garantirão esse segundo objetivo:
• Atribua IDs de registro exclusivos a todos os dados de entrada
Use PROJECT (dataset, COUNTER) ou a posição inicial do arquivo (FILEPOS) para criá-los.
• Limpe e padronize os dados conforme apropriado
Elementos comuns de padronização são nomes, endereços, datas, horas etc.
• Use projeções verticais (“vertical slice” TABLE)
Essa técnica permite trabalhar apenas com os campos que você realmente precisa.
• Use projeções horizontais (filtros de registro)
Essa técnica permite selecionar apenas os registros relevantes para o problema. A filtragem também permite excluir
registros com valores NULL nos campos-chave e filtrar dados inválidos ou irrelevantes, a menos que possam ser
limpos.
3. Transforme dados no menor formato de armazenamento
• Em relação à representação numérica, o tipo UNSIGNED é o melhor. Use INTEGER apenas se forem necessários
valores com sinais e, para todos os números, selecione o menor tamanho apropriado para o intervalo de valores.
• Os valores de hash são uma ótima técnica para testar a unicidade de valores. O COUNT do DEDUP dos campos
com hash deve ser igual ao COUNT dos valores de hash e sempre use um tamanho de hash apropriado: 32-bit (HASH,
HASH32), 64-bit (HASH64), e 128-bit (HASHMD5).
• Use tabelas de Lookup sempre que possível. Os valores "padrão" de STRING´s podem ser reduzidos para números
inteiros representativos e recuperados na saída.
4. Use estratégias que otimizam seu processo ETL
• Use o ECL Watch como um Profiler de execução para verificar as contagens de registros e a distribuição/viés de
uma etapa para outra. Você também pode usá-lo para verificar o tempo dos subgrafos para identificar os "pontos de
acesso" onde a eficiência da execução pode potencialmente ser melhorada.
• Mantenha seus dados desduplicados durante todo o processo, especialmente após JOINs. Isso minimiza qualquer
efeito de crescimento descontrolado de etapa para etapa que aumentará o tempo de processamento e poderá causar
distribuição desigual. Use DEDUP, ALL [um hash dedup] ou SORT e DEDUP.
• Mantenha suas distribuições entre nós, mesmo durante todo o processo. Se algum viés se desenvolver em uma etapa
por causa da natureza dos dados, use DISTRIBUTE novamente para garantir a eficiência nas etapas subsequentes.
• Use GROUP sempre que possível. Sequências complexas de operações (SORT, DEDUP, ITERATE, ROLLUP etc.)
são mais eficientes quando todos os dados estão na memória. Use a opção GROUP ALL ou SORT nos dados antes
do agrupamento.
© 2020 HPCC Systems. All rights reserved
7
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Visão Geral
• Use operações do tipo LOCAL na maioria das vezes. LOCAL pode ser usado na maioria das operações, incluindo
GROUP e TABLE
• Use a opção LOOKUP ou ALL sempre que possível. As opções LOOKUP e ALL em um JOIN carregam todos os
registros do arquivo de pesquisa em cada nó, portanto, é implicitamente uma operação LOCAL
• Aplique PERSIST em etapas intermediárias/conjuntos de registros. Isso facilitará a depuração de um novo processo e
minimizará o tempo de reexecução à medida que partes de um processo forem desenvolvidas, além de fornecer alguma
capacidade de recuperação de falhas no sistema
• Use OUTPUT(,NAMED) para os principais valores intermediários. Esses valores são armazenados na unidade de
trabalho e podem ser analisados para identificar possíveis problemas.
© 2020 HPCC Systems. All rights reserved
8
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Visão Geral
Convenções de Documentação
Linguagem ECL
Embora o ECL não faça distinção entre maiúsculas e minúsculas, as palavras-chave reservadas do ECL e as funções
built-in deste documento são sempre exibidas com todos os caracteres EM CAIXA ALTA (ALL CAPS) para dar
destaque e facilitar a identificação.
Nomes
Atributos e nomes de conjunto de registros são sempre exibidos no código de exemplo usando caracteres maiúsculos
e minúsculos. Palavras fundidas podem ser usadas para identificar explicitamente a finalidade nos exemplos.
Código de Exemplo
Todos os códigos de exemplo neste documento aparecem com a seguinte fonte:
 MyDefinitionName := COUNT(People);
 // MyDefinitionName is a user-defined Definition
 // COUNT is a built-in ECL function
 // People is the name of a dataset
Ações
Nas seções do tutorial, haverá ações explícitas a serem executadas. Tudo isso é mostrado com um marcador para
diferenciar as etapas da ação do texto explicativo, conforme mostrado aqui:
• As ações do teclado e mouse são todas mostradas em caixa baixa, tais como: CLIQUE DUAS VEZES ou pressione
a tecla ENTER .
• Os itens na tela a serem selecionados são mostrados em negrito, como: pressione o botão OK para retornar
Trechos da Linguagem ECL
Este manual contém discussões sobre vários recursos específicos da ECL usados nos exercícios. Esta informação foi
extraída do livro Referência a Linguagem ECL. No entanto, nem todas as informações contidas nesse documento foram
colocadas neste. Isso significa que você ainda precisa ler o Referência a Linguagem ECL para obter uma discussão
completa sobre qualquer recurso da ECL.
No caso de qualquer conflito identficado entre este documento e a Referência a Linguagem ECL, agora ou em
qualquer versão futura, a autoridade dominante é a Referência a Linguagem ECL.
© 2020 HPCC Systems. All rights reserved
9
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Definir e organizar seus dados
Definir e organizar seus dados
Exercício 1: Organize suas definições
de dados
Especificação do exercício:
Neste primeiro exercício de laboratório, organizaremos as definições RECORD e DATASET em módulos comuns a
serem usados no restante deste curso. Use o arquivo ECL das definições Persons e Accounts que criamos na aula
Introdução ao ECL como ponto de partida.
Requisitos:
1. Crie um novo arquivo de definição EXPORT chamado File_Persons.
2. Crie um novo arquivo de definição EXPORT chamado File_Accounts.
3. No arquivo de definição File_Persons, crie uma estrutura MODULE para conter as definições de RECORD e
DATASET de Persons (Dica: você pode copiar seu trabalho do arquivo de definição Persons que você criou na classe
Introdução ao ECL).
• Crie as seguintes definições de EXPORTAÇÃO na estrutura do módulo para cada definição Persons, respectiva-
mente:
Layout - para a definição RECORD de Persons
File - para a definição DATASET de Persons
4. No arquivo de definição File_Accounts, crie uma estrutura modular para conter as definições de RECORD e
DATASET Accounts (Dica: você pode copiar seu trabalho do arquivo de definição Accounts que você criou no curso
de Introdução ao ECL).
• Crie as seguintes definições de EXPORTAÇÃO na estrutura módular para cada definição de Accounts, respectiva-
mente:
Layout - para a definição de registros de Accounts
File - para a definição de dataset de Accounts
Comparação do resultado
Teste todas as suas novas definições EXPORTADas em uma nova janela do Buildere verifique se os resultados estão
corretos e razoáveis. Correto e razoável significa que as consultas são executadas sem erros e os dados na janela ECL
IDE Results parecem corretos.
Exemplo:
IMPORT TrainingYourName;
TrainingYourName.File_Persons.File;
TrainingYourName.File_Accounts.File;
© 2020 HPCC Systems. All rights reserved
10
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Definir e organizar seus dados
Isso encerra o Exercício 1!
© 2020 HPCC Systems. All rights reserved
11
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
Relatórios de tabulação
© 2020 HPCC Systems. All rights reserved
12
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
TABLE
TABLE(recordset, format [, expression [,FEW | MANY] [, UNSORTED]] [, LOCAL] [, KEYED ] [, MERGE
] [, SKEW(limit[, target] ) [, THRESHOLD(size) ] ] [, UNORDERED | ORDERED( bool ) ] [, STABLE |
UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
recordset O conjunto para processamento. Pode ser o nome de um dataset ou de um recordset derivado
de algumas condições de filtro, ou qualquer expressão que resulte em um recordset derivado.
format Uma definição de estrutura RECORD que define o tipo, o nome e a fonte de dados para cada
campo.
expression Opcional. Especifica uma cláusula "agrupar por". É possível ter mais de uma expressão separada
por vírgula para criar uma cláusula de "agrupar por" lógica e única. Se a expressão for um campo
do recordset, então há um registro de grupo único na tabela resultante para cada valor distinto
da expressão. Do contrário, a expressão é uma expressão de tipo LEFT/RIGHT no modo de
DEDUP.
FEW Opcional. Indica que a expressão resultará em menos de 10.000 grupos distintos. Isso permite
otimização para gerar um resultado significativamente mais rápido.
MANY Opcional. Indica que a expressão resultará em vários grupos distintos.
UNSORTED Opcional. Especifica que você não se importa com a ordem dos grupos. Isso permite otimização
para gerar um resultado significativamente mais rápido.
LOCAL Opcional. Especifica que a operação é realizada em cada nó de supercomputador de forma in-
dependente, sem exigir interação com todos os outros nós para obter dados; a operação mantém
a distribuição de qualquer operação DISTRIBUTE anterior.
KEYED Opcional. Especifica que a atividade faz parte de uma operação de leitura de índice, a qual
permite que o otimizador gere o código ideal para a operação.
MERGE Opcional. Especifica que os resultados são agregados em cada nó e depois os intermediários
agregados são novamente agregados globalmente. Esse é um método seguro de agregação que
se destaca especialmente bem se os dados adjacentes tiverem sido distorcidos. Se souber que o
número de grupos será baixo, então FEW será ainda mais rápido, evitando a classificação local
dos dados subjacentes.
SKEW Indica que você sabe que os dados não serão espalhados uniformemente entre os nós (serão
distorcidos e você opta por substituir o padrão especificando seu próprio valor limite para per-
mitir que a tarefa continue, apesar da distorção).
limit Um valor entre zero (0) e um (1,0 = 100%) indicando a porcentagem máxima de distorção a ser
permitida antes que a tarefa falhe (a distorção padrão é 1,0 / <número de escravos no cluster>).
target Opcional. Um valor entre zero (0) e um (1,0 = 100%) indicando a porcentagem máxima de
distorção desejada a ser permitida (a distorção padrão é 1,0 / <número de escravos no cluster>).
THRESHOLD Indica o tamanho mínimo de uma única parte antes que o limite SKEW seja aplicado.
size Um valor inteiro indicando o número mínimo de bytes para uma parte única. O padrão é 1.
UNORDERED Opcional. Especifica que a ordem do registro de resultado não é importante.
ORDERED Especifica a importância da ordem do registro de resultado.
bool Quando for “False” (Falso), especifica que a ordem do registro de resultado não é importante.
Quando for “True’ (Verdadeiro), especifica a ordem padrão do registro de resultado.
STABLE Opcional. Especifica que a ordem do registro de entrada é importante.
UNSTABLE Opcional. Especifica que a ordem do registro de entrada não é importante.
© 2020 HPCC Systems. All rights reserved
13
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
PARALLEL Opcional. Tenta avaliar essa atividade em paralelo.
numthreads Opcional. Tenta avaliar essa atividade usando os numthreads threads.
ALGORITHM Opcional. Substitui o algoritmo usado para essa atividade.
name O algoritmo a ser usado para essa atividade. Precisa fazer parte da lista de algoritmos com-
patíveis com as opções STABLE e UNSTABLE da função SORT.
Return: TABLE retorna uma nova tabela.
A função TABLE é similar a OUTPUT, mas, em vez de gravar registros em um arquivo, ela salva esses registros
em uma nova tabela (um novo dataset no supercomputador) na memória. A nova tabela é temporária e existe apenas
enquanto a consulta específica que a invocou está em execução.
A nova tabela herda a lógica implícita que o recordset possui (se aplicável), exceto caso a expressão opcional seja
usada para realizar a agregação. Isso significa que o registro primário está disponível ao processar registros de tabela
e que você também pode acessar o conjunto de registros secundários de cada registro de tabela. Há duas formas de
usar TABLE: a forma de "fatia vertical" e a de "relatório de referência cruzada".
Para a forma de "fatia vertical", não há um parâmetro de expressão especificado. O número de registros no recordset
de entrada é igual ao número de registros produzidos.
Para a forma de "relatório de referência cruzada", normalmente há um parâmetro de expressão e, o mais importante,
a estrutura RECORD do formato de resultado contém, no mínimo, um campo que usa uma função agregada com a
palavra-chave GROUP como seu primeiro parâmetro. O número de registros produzidos é igual ao número de valores
distintos da expressão.
Exemplo:
//"vertical slice" form:
MyFormat := RECORD
STRING25 Lname := Person.per_last_name;
Person.per_first_name;
STRING5 NewField := '';
END;
PersonTable := TABLE(Person,MyFormat);
// adding a new field is one use of this form of TABLE
//"CrossTab Report" form:
rec := RECORD
Person.per_st;
StCnt := COUNT(GROUP);
END
Mytable := TABLE(Person,rec,per_st,FEW);
// group persons by state in Mytable to produce a
 crosstab
Ver também: OUTPUT, GROUP, DATASET, Estrutura RECORD
© 2020 HPCC Systems. All rights reserved
14
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
Relatórios Cross-Tab
Relatórios de cross-tab são uma maneira bastante útil de descobrir informações estatísticas sobre os dados com os quais
você trabalha. Eles podem ser facilmente produzidos usando a função TABLE e as funções agregadas (COUNT, SUM,
MIN, MAX, AVE, VARIANCE, COVARIANCE, CORRELATION). O recordset resultante contém um único registro
para cada valor único dos campos "agrupar por" especificados na função TABLE, juntamente com as estatísticas
geradas com as funções agregadas.
Os parâmetros “agrupado por” da função TABLE são usados e duplicados como o primeiro conjunto de campos na
estrutura RECORD, seguidos por qualquer número de acionamentos de função agregados, tudo isso usando a palavra-
chave GROUP como substituto para o recordset exigido pelo primeiro parâmetro de cada uma das funções agregadas.
A palavra-chave GROUP especifica a realização de uma operação agregada no grupo e é o segredo para criar um
relatório de cross-tab. Isso cria uma tabela de resultados contendo uma linha única para cada valor único dos parâmetros
"agrupar por".
Uma CrossTab Simples
O código de exemplo abaixo (contido no arquivo CrossTab..ECL) produz um resultado de State/CountAccts com con-
tas do dataset secundário aninhado criado pelo código GenData.ECL (consulte o artigo Criando Dados de Exemplo ):
IMPORT $;
Person := $.DeclareData.PersonAccounts;
CountAccts:= COUNT(Person.Accounts);
MyReportFormat1 := RECORD
 State := Person.State;
 A1 := CountAccts;
 GroupCount := COUNT(GROUP);
END;
RepTable1 := TABLE(Person,MyReportFormat1,State,CountAccts );
OUTPUT(RepTable1);
/* The result set would look something like this:
 State A1 GroupCount
 AK 1 7
 AK 2 3
 AL 1 42
 AL 2 54
 AR 1 103
 AR 2 89
 AR 3 2 */ 
Pequenas modificações permitirão a produção de algumas estatísticas mais sofisticadas, como:
MyReportFormat2 := RECORD
 State{cardinality(56)} := Person.State;
 A1 := CountAccts;
 GroupCount := COUNT(GROUP);
 MaleCount := COUNT(GROUP,Person.Gender = 'M');
 FemaleCount := COUNT(GROUP,Person.Gender = 'F');
 END;
RepTable2 := TABLE(Person,MyReportFormat2,State,CountAccts );
OUTPUT(RepTable2);
© 2020 HPCC Systems. All rights reserved
15
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
Isso adiciona um detalhamento à contagem homens e mulheres em cada categoria, usando o segundo parâmetro op-
cional para COUNT (disponível para uso apenas em estruturas RECORD onde seu primeiro parâmetro é a palavra-
chave GROUP ).
A adição de {cardinality(56)} à definição State é uma dica para o otimizador de que há exatamente 56 valores possíveis
nesse campo, permitindo que ele selecione o melhor algoritmo para produzir o resultado da maneira mais rápida
possível.
As possibilidades são infinitas quanto ao tipo de estatísticas que podem ser geradas em relação a qualquer conjunto
de dados.
Um exemplo mais complexo
Como um exemplo levemente mais complexo, o código a seguir produz uma tabela de resultado de uma cross-tab
com o saldo médio de uma transação em um cartão bancário, média elevada do crédito em uma transação com cartão
bancário e o saldo total médio em cartões bancários, tabulados por estado e sexo.
Esse código demonstra o uso de atributos agregados separados como os parâmetros de valor para a função agregada
na cross-tab.
IsValidType(STRING1 PassedType) := PassedType IN ['O', 'R', 'I'];
IsRevolv := Person.Accounts.AcctType = 'R' OR 
 (~IsValidType(Person.Accounts.AcctType) AND 
 Person.Accounts.Account[1] IN ['4', '5', '6']);
SetBankIndCodes := ['BB', 'ON', 'FS', 'FC'];
IsBank := Person.Accounts.IndustryCode IN SetBankIndCodes;
IsBankCard := IsBank AND IsRevolv;
AvgBal := AVE(Person.Accounts(isBankCard),Balance);
TotBal := SUM(Person.Accounts(isBankCard),Balance);
AvgHC := AVE(Person.Accounts(isBankCard),HighCredit);
R1 := RECORD
 person.state;
 person.gender;
 Number := COUNT(GROUP);
 AverageBal := AVE(GROUP,AvgBal);
 AverageTotalBal := AVE(GROUP,TotBal);
 AverageHC := AVE(GROUP,AvgHC);
END;
T1 := TABLE(person, R1, state, gender);
OUTPUT(T1);
Um Exemplo Estatístico
O exemplo a seguir demonstra as funções VARIANCE, COVARIANCE e CORRELATION para analisar pontos de
grade. Ele também mostra a técnica de inserir a cross-tab em uma MACRO, acionando essa MACRO para gerar um
resultado específico em um determinado dataset.
pointRec := { REAL x, REAL y };
analyze( ds ) := MACRO
 #uniquename(rec)
 %rec% := RECORD
© 2020 HPCC Systems. All rights reserved
16
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
 c := COUNT(GROUP),
 sx := SUM(GROUP, ds.x),
 sy := SUM(GROUP, ds.y),
 sxx := SUM(GROUP, ds.x * ds.x),
 sxy := SUM(GROUP, ds.x * ds.y),
 syy := SUM(GROUP, ds.y * ds.y),
 varx := VARIANCE(GROUP, ds.x);
 vary := VARIANCE(GROUP, ds.y);
 varxy := COVARIANCE(GROUP, ds.x, ds.y);
 rc := CORRELATION(GROUP, ds.x, ds.y) ;
 END; 
 #uniquename(stats)
 %stats% := TABLE(ds,%rec% );
 OUTPUT(%stats%);
 OUTPUT(%stats%, { varx - (sxx-sx*sx/c)/c,
 vary - (syy-sy*sy/c)/c,
 varxy - (sxy-sx*sy/c)/c,
 rc - (varxy/SQRT(varx*vary)) });
 OUTPUT(%stats%, { 'bestFit: y='+(STRING)((sy-sx*varxy/varx)/c)+' 
 + '+(STRING)(varxy/varx)+'x' });
ENDMACRO;
ds1 := DATASET([{1,1},{2,2},{3,3},{4,4},{5,5},{6,6}], pointRec);
ds2 := DATASET([{1.93896e+009, 2.04482e+009},
 {1.77971e+009, 8.54858e+008},
 {2.96181e+009, 1.24848e+009},
 {2.7744e+009, 1.26357e+009},
 {1.14416e+009, 4.3429e+008},
 {3.38728e+009, 1.30238e+009},
 {3.19538e+009, 1.71177e+009} ], pointRec);
ds3 := DATASET([{1, 1.00039},
 {2, 2.07702},
 {3, 2.86158},
 {4, 3.87114},
 {5, 5.12417},
 {6, 6.20283} ], pointRec);
analyze(ds1);
analyze(ds2);
analyze(ds3); 
© 2020 HPCC Systems. All rights reserved
17
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
Exemplo de tabulação funcional
Relatórios de tabulação
Abra BWR_Training_Examples.Crosstab_Example em uma janela ECL e envie esta consulta:
MyRec := RECORD
 STRING1 Value1;
 STRING1 Value2;
 INTEGER1 Value3;
END;
SomeFile := DATASET([{'C','G',1},
 {'C','C',2},
 {'A','X',3},
 {'B','G',4},
 {'A','B',5}],MyRec);
MyOutRec := RECORD
 SomeFile.Value1;
 GrpCount := COUNT(GROUP);
 GrpSum := SUM(GROUP,SomeFile.Value3);
END;
MyTable := TABLE(SomeFile,MyOutRec,Value1);
OUTPUT(MyTable);
/* MyTable result set is:
Rec# Value1 GrpCount GrpSum
 1 C 2 3
 2 A 2 8
 3 B 1 4
*/
/*
//Example 2:
r := RECORD
 ThorFile.people_thor.lastname;
 ThorFile.people_thor.gender;
 GrpCnt := COUNT(GROUP);
 MaxLen := MAX(GROUP,LENGTH(TRIM(ThorFile.people_thor.firstname)));
END;
tbl := TABLE(ThorFile.people_thor,r,lastname,gender);
output(tbl);
/**/
© 2020 HPCC Systems. All rights reserved
18
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
Exercício 2a
Especificação do exercício:
Crie um relatório cross-tab que conte o número de valores distintos contidos no campo Gender do arquivo Persons.
Requisitos:
1. O arquivo de definição EXPORT a ser criado para este exercício é: XTAB_Persons_Gender.
2. Use a qualificação IMPORT $ conforme descrito na documentação sobre IMPORTação no PDF Referência a Lin-
guagem ECL .
Melhores práticas
O texto que antecede este exercício possui um bom código de exemplo semelhante ao que você precisará fazer.
Comparação do resultado
Use uma janela do Builder para executar uma consulta de saída simples e verifique se o resultado é:
 N 20508
 M 384182
 F 404988
 U 31722
Exercício 2b
Especificação do exercício:
Crie um relatório cross-tab que determine os valores máximo e mínimo contidos no campo High Credit do arquivo
Accounts.
Requisitos:
1. O arquivo de definição EXPORT a ser criado para este exercício é: XTAB_Accounts_HighCredit_MaxMin
2. Use a qualificação IMPORT $ conforme descrito na documentação sobre IMPORTação no PDF Referência a Lin-
guagem ECL.
Melhores práticas
Use o arquivo inteiro como a cláusula agrupar por.
Comparação do resultado
Use uma janela Builder para executar uma consulta OUTPUT simples e verifique se o resultado é:
© 2020 HPCC Systems. All rights reserved
19
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Relatórios de tabulação
 MIN Value MAX Value
 0 9999999
© 2020 HPCC Systems. All rights reserved
20
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Mais relatórios de avaliação de dados
© 2020 HPCC Systems. All rights reserved
21
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
DISTRIBUTE "Randômico"
DISTRIBUTE(recordset [, UNORDERED | ORDERED( bool ) ] [, STABLE | UNSTABLE ] [, PARALLEL [ (
numthreads ) ] ] [, ALGORITHM( name ) ] )
DISTRIBUTE(recordset, expression [, MERGE( sorts ) ] [, UNORDERED | ORDERED(bool ) ] [, STABLE |
UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
DISTRIBUTE(recordset, index [, joincondition ] [, UNORDERED | ORDERED( bool ) ] [, STABLE |
UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
DISTRIBUTE(recordset, SKEW( maxskew [, skewlimit ] ) [, UNORDERED | ORDERED( bool ) ] [, STABLE |
UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
recordset O conjunto de registros a ser distribuído.
expression Uma expressão inteira que especifica como distribuir o conjunto de registros, geralmente usando
uma das funções HASH para fins de eficiência.
MERGE Especifica que os dados são redistribuídos, mantendo a ordem de classificação local em cada nó.
sorts As expressões de classificação pelas quais os dados foram localmente classificados.
index O nome da definição de um atributo INDEX , que fornece a distribuição adequada.
joincondition Opcional. Uma expressão lógica que especifica como vincular os registros ao conjunto de reg-
istros e índice. As palavras-chave LEFT e RIGHT podem ser usadas como qualificadores de
dataset nos campos do recordset e do índice.
SKEW Especifica os valores de distorção de dados permitidos.
maxskew Um número de ponto flutuante no intervalo de zero (0,0) a um (1,0) especificando a distorção
mínima a ser permitida (0,1=10%).
skewlimit Opcional. Um número de ponto flutuante no intervalo de zero (0,0) a um (1,0) especificando a
distorção máxima a ser permitida (0,1=10%).
UNORDERED Opcional. Especifica que a ordem do registro de resultado não é importante.
ORDERED Especifica a importância da ordem do registro de resultado.
bool Quando for “False” (Falso), especifica que a ordem do registro de resultado não é importante.
Quando for “True’ (Verdadeiro), especifica a ordem padrão do registro de resultado.
STABLE Opcional. Especifica que a ordem do registro de entrada é importante.
UNSTABLE Opcional. Especifica que a ordem do registro de entrada não é importante.
PARALLEL Opcional. Tenta avaliar essa atividade em paralelo.
numthreads Opcional. Tenta avaliar essa atividade usando os numthreads threads
ALGORITHM Opcional. Substitui o algoritmo usado para essa atividade.
name O algoritmo a ser usado para essa atividade. Precisa fazer parte da lista de algoritmos compatíveis
com as opções STABLE e UNSTABLE da função SORT.
Return: DISTRIBUTE retorna um conjunto de registros.
A função DISTRIBUTE redistribui registros do recordset para todos os nós do cluster.
“Random” DISTRIBUTE
DISTRIBUTE(recordset )
© 2020 HPCC Systems. All rights reserved
22
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Esta forma redistribui o recordset "aleatoriamente" para que não haja distorção de dados entre os nós, porém sem
as desvantagens que a função RANDOM() poderia introduzir. Isso é funcionalmente equivalente a distribuição do
registro inteiro através de uma hash.
Expressão DISTRIBUTE
DISTRIBUTE(recordset, expression )
Esta forma redistribui o recordset com base na expressão especificada, normalmente uma das funções HASH . Somente
os 32 bits inferiores do valor da expressão são usados; portanto, HASH ou HASH32 são a escolha ideal. Os registros
para os quais a expressão apresenta o mesmo resultado que estão no mesmo nó. DISTRIBUTE executa implicitamente
uma operação de módulo se o valor da expressão não estiver no intervalo do número de nós disponíveis.
Se a opção MERGE for especificada, o recordset precisa ter sido classificado localmente pelas expressões sort . Isso
evita uma reclassificação.
DISTRIBUTE baseado em Index
DISTRIBUTE(recordset, index [, joincondition ] )
Esta forma redistribui o recordset com base na distribuição existente do index especificado, onde a ligação entre os
dois é determinada pela joincondition. Os registros para os quais a joincondition é true (verdadeira) terminarão no
mesmo nó.
DISTRIBUTE baseado em Skew
DISTRIBUTE(recordset, SKEW( maxskew [, skewlimit ] ) )
Esta forma redistribui o recordset , mas apenas se for necessário. A finalidade desta forma é substituir o uso de
DISTRIBUTE(recordset,RANDOM()) para apenas obter uma distribuição relativamente uniforme dos dados entre os
nós. Esta forma sempre tentará minimizar a quantidade de dados redistribuídos entre os nós.
A distorção de um dataset é calculada da seguinte forma:
MAX(ABS(AvgPartSize-PartSize[node])/AvgPartSize)
Se a distorção do recordset for menor do que a do maxskew , então DISTRIBUTE será não operacional. Se o limite de
distorção for especificado e se a distorção em qualquer nó exceder esse limite, a tarefa falhará e exibirá uma mensagem
de erro (especificando o número do primeiro nó que excedeu o limite); caso contrário, os dados são redistribuídos para
garantir que os dados sejam distribuídos com menor distorção que maxskew.
Exemplo:
MySet1 := DISTRIBUTE(Person); //"random" distribution - no skew
MySet2 := DISTRIBUTE(Person,HASH32(Person.per_ssn));
 //all people with the same SSN end up on the same node
 //INDEX example:
mainRecord := RECORD
 INTEGER8 sequence;
 STRING20 forename; 
 STRING20 surname;
 UNSIGNED8 filepos{virtual(fileposition)};
END;
mainTable := DATASET('~keyed.d00',mainRecord,THOR);
nameKey := INDEX(mainTable, {surname,forename,filepos}, 'name.idx');
incTable := DATASET('~inc.d00',mainRecord,THOR);
x := DISTRIBUTE(incTable, nameKey,
© 2020 HPCC Systems. All rights reserved
23
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
 LEFT.surname = RIGHT.surname AND
 LEFT.forename = RIGHT.forename);
OUTPUT(x);
//SKEW example:
Jds := JOIN(somedata,otherdata,LEFT.sysid=RIGHT.sysid);
Jds_dist1 := DISTRIBUTE(Jds,SKEW(0.1));
 //ensures skew is less than 10%
Jds_dist2 := DISTRIBUTE(Jds,SKEW(0.1,0.5));
 //ensures skew is less than 10%
 //and fails if skew exceeds 50% on any node
Ver também: HASH32, DISTRIBUTED, INDEX
© 2020 HPCC Systems. All rights reserved
24
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
HASH32
HASH32(expressionlist)
expressionlist Uma lista de valores delimitada por vírgula.
Return: HASH32 retorna um único valor.
A função HASH32 retorna um valor hash de 32 bits derivado de todos os valores da expressionlist. Ela usa um
algoritmo hashing que é mais rápido e menos provável do que o HASH para retornar os mesmos valores a partir de
dados diferentes. Espaços no final da string são removidos (ou UNICODE) antes de o valor ser calculado (a conversão
para DATA impede isso).
Exemplo:
MySet := DISTRIBUTE(Person,HASH32(Person.per_ssn));
 //people with the same SSN go to same Data Refinery node
Ver também: DISTRIBUTE, HASH, HASH64, HASHCRC, HASHMD5
© 2020 HPCC Systems. All rights reserved
25
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Exercício 3a
Especificação do exercício:
Criar um código Builder Window Runnable (BWR) que determina a cardinalidade do campo Bureau Code do arquivo
Persons.
A cardinalidade do campo é definida como o número de valores únicos contidos no campo.
O código BWR é definido como código ECL projetado para ser executado em uma janela do Builder, mas é armazenado
no Repositório da mesma maneira que qualquer definição ECL. Isso implica várias coisas:
* Deve conter pelo menos uma ação (explícita ou implícita).
* Todos os atributos referenciados do Repositório devem ser totalmente qualificados (ou referenciados pelo IMPORT).
* Não contém atributos EXPORT ou SHARED (significa que só pode ser aberta em uma janela do Builder e executado).
Requisitos:
O arquivo de definição a ser criado para este exercício é: BWR_Persons_BureauCode_Cardinality
OBSERVAÇÃO: NÃO use um relatório CrossTab para concluir este exercício! Consulte a seção Melhores
Práticas abaixo para obter mais detalhes.
Melhores práticas
1. Use o formulário "vertical slice" de TABLE para limitar os dados.
2. Use a funçãoDISTRIBUTE para permitir o uso da opção LOCAL em operações subsequentes.
Comparação do resultado
Abra o código em uma janela do Builder e execute-o. Verifique se o resultado é 303.
© 2020 HPCC Systems. All rights reserved
26
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Exercício 3b
Especificação do exercício:
Criar código Builder Window Runnable (BWR) que determina a população no campo Dependent Count do arquivo
Persons.
A população é definida como a porcentagem de registros que contêm valores diferentes de valores "nulos" (geralmente
espaços em branco ou zeros).
Requisitos:
O arquivo de definição a ser criado para este exercício é: BWR_Persons_DependentCount_Population
Melhores práticas
1. Use uma definição DATASET em linha para produzir a saída.
Comparação do resultado
Abra o código em uma janela do Builder e execute-o. Verifique se o resultado é:
 Total Records 841400
 Recs=0 841400
 Population Pct 0
© 2020 HPCC Systems. All rights reserved
27
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Padrões dos Dados
A funcionalidade Padrão dos Dados (definido como DataPatterns) é um pacote ECL que fornece algumas ferramen-
tas básicas de perfil e pesquisa de dados para um programador de ECL. Agora, esse pacote está integrado a todos os
relatórios de informações de arquivos lógicos no ECL Watch. Clique na aba Data Patterns do arquivo e, em seguida,
Analyze para iniciar a geração do relatório. Nota: seu arquivo lógico deve ter informações de ECL RECORD para
iniciar o relatório. No entanto, com a instalação do pacote configurável, você pode executar sua própria análise a
qualquer momento a partir de qualquer workunit ECL. OBSERVAÇÃO: A partir do HPCC Versão 7.6, as FUNC-
TIONMACROs usadas no pacote DataPatterns agora estão integradas à Referência da Biblioteca Padrão (consulte
STD.DataPatterns). Esta seção se concentrará apenas na instalação do pacote.
Instalação
DataPatterns é instalado como um pacote ECL. Instruções completas para gerenciar pacotes ECL podem ser encon-
tradas na documentação em PDF ECL IDE e no HPCC ClientTools. Use a ferramenta de linha de comando ECL para
instalar este pacote configurável:
ecl bundle install https://github.com/hpcc-systems/DataPatterns.git
Pode ser necessário navegar para o diretório bin das ferramentas do cliente antes de executar o comando ou usar o
caminho completo para o executável ecl. Após a instalação, todo o código fica disponível aqui após a importação:
IMPORT DataPatterns;
Observe que é possível usar esse código sem instalá-lo como um pacote. Para fazer isso, basta disponibilizá-lo no seu
IDE e ignorar o arquivo Bundle.ecl. Com o IDE do Windows, o diretório DataPatterns não deve ser um item de nível
superior na sua lista de repositórios; ele precisa ser instalado um nível abaixo do nível superior, como, por exemplo,
abaixo da pasta "Meus arquivos".
A FunctionMacro Profile
Profile() é um FUNCTIONMACRO para criar um perfil de todo ou parte de um dataset. A saída é um dataset que
contém as seguintes informações para cada atributo com perfil:
attribute O nome do atributo.
given_attribute_type O tipo de ECL do atributo conforme definido no dataset de entrada
best_attribute_type Um tipo de dados ECL que permite todos os valores no dataset de entrada e consome
a menor quantidade de memória
rec_count O número de registros analisados no dataset; isso pode ser menor que o número total
de registros, se o argumento sampleSize opcional tiver sido fornecido com um valor
menor que 10
fill_count O número de registros rec_count contendo valores diferentes de zero; um 'valor nulo'
é uma string vazia, um zero numérico ou um SET vazio; observe que os atributos
BOOLEAN são sempre contados como preenchidos, independentemente de seu val-
or; Além disso, os atributos DATA de comprimento fixo (por exemplo, DATA10)
também são contados como preenchidos, dada sua função típica de reter blobs de
dados.
fill_rate A porcentagem de registros rec_count contendo valores diferentes de zero; isso é
basicamente fill_count / rec_count * 100 cardinality
cardinality O número de valores únicos e diferentes de zero do atributo
© 2020 HPCC Systems. All rights reserved
28
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
cardinality_breakdown Para os atributos com um número baixo de valores únicos e não-nulos, mostre cada
valor e o número de registros que contêm esse valor; o parâmetro lcbLimit controla
o valor do "número baixo".
modes Os valores mais comuns no atributo, depois de converter todos os valores para
STRING, juntamente com o número de registros nos quais os valores foram encon-
trados; se nenhum valor for repetido mais de uma vez, nenhum modo será mostrado;
até cinco (5) modos serão mostrados; observe que valores de STRING maiores que
o argumento maxPatternLen serão truncados
min_length Para tipos de dados SET, o menor número de elementos encontrado no conjunto;
para outros tipos de dados, o menor comprimento de um valor quando expresso como
uma STRING; valores nulos são ignorados
max_length Para tipos de dados SET, o maior número de elementos encontrados no conjunto;
para outros tipos de dados, o maior comprimento de um valor quando expresso como
uma STRING; valores nulos são ignorados
ave_length Para tipos de dados SET, o número médio de elementos encontrados no conjunto;
para outros tipos de dados, o comprimento médio de um valor quando expresso
popular_patterns Os padrões mais comuns de valores (veja abaixo)
rare_patterns Os padrões menos comuns de valores (veja abaixo).
is_numeric. Booleano indicando se o atributo original era um número escalar ou se o valor
best_attribute_type era um número escalar; se TRUE, os campos de saída numer-
ic_xxxx serão preenchidos com valores reais; se esse valor for FALSE , todos os
valores de saída numeric_xxxx devem ser ignorados
numeric_min O menor valor não nulo encontrado no atributo como DECIMAL; esse valor é válido
apenas se is_numeric for TRUE; se is_numeric for FALSE, zero será mostrado aqui
numeric_max O maior valor não-nulo encontrado no atributo como DECIMAL; esse valor é válido
apenas se is_numeric for TRUE; se is_numeric for FALSE, zero será mostrado aqui
numeric_mean O menor valor não nulo encontrado no atributo como DECIMAL; esse valor é válido
apenas se is_numeric for TRUE; se is_numeric for FALSE, zero será mostrado aqui
numeric_std_dev O desvio padrão dos valores não nulos no atributo como DECIMAL; esse valor é
válido apenas se is_numeric for TRUE; se is_numeric for FALSE, zero será mostra-
do aqui
numeric_lower_quartile O valor que separa o primeiro (inferior) e o segundo quartil de valores diferentes
de zero no atributo como DECIMAL; esse valor é válido apenas se is_numeric for
TRUE; se is_numeric for FALSE, zero será mostrado aqui
numeric_median O valor mediano não nulo no atributo como DECIMAL; esse valor é válido apenas
se is_numeric for TRUE; se is_numeric for FALSE, zero será mostrado aqui
numeric_upper_quartile O valor que separa o terceiro e quarto (superior) quartil de valores não nulos dentro
do atributo como DECIMAL; esse valor é válido apenas se is_numeric for TRUE;
se is_numeric for FALSE, zero será mostrado aqui
correlations Um dataset filho contendo valores de correlação comparando o atributo numérico
atual com todos os outros atributos numéricos, listados em ordem decrescente do
valor de correlação; o atributo deve ser um tipo de dado numérico da ECL; atributos
não numéricos retornarão um conjunto de dados filho vazio; observe que essa pode
ser uma operação demorada, dependendo do número de atributos numéricos no seu
conjunto de dados e do número de linhas (se você tiver N atributos numéricos, serão
executados N * (N - 1) / 2 cálculos, cada um verificando todas as linhas de dados)
A maioria das saídas do profile() pode ser desativada (consulte as informações sobre os recursosabaixo).
© 2020 HPCC Systems. All rights reserved
29
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Os padrões de dados podem fornecer uma ideia da aparência de seus dados quando expressos como uma string (legível
por humanos). A função converte cada caractere da cadeia de caracteres em uma paleta de caracteres fixa para produzir
um "data pattern" e, em seguida, conta o número de padrões exclusivos para esse atributo. Os padrões mais e menos
populares dos dados serão mostrados na saída, juntamente com o número de vezes que o padrão aparece e de um
exemplo (escolhido aleatoriamente a partir dos dados reais). A paleta de caracteres usada é:
A - Qualquer letra maiúscula
a - Qualquer letra maiúscula
9 - Qualquer dígito numérico
B - Um valor booleano (verdadeiro ou falso)
Todos os outros caracteres são deixados como estão no padrão.
PROFILE(inFile, fieldListStr, maxPatterns, maxPatternLen, features, sampleSize, lcbLimit)
Parâmetros da função:
infile O conjunto de dados a ser processado; pode ser um dataset filho (por exemplo, inFile.childDS);
REQUERIDO
fieldListStr Uma string contendo uma lista delimitada por vírgula de nomes de atributos a serem processa-
dos; observe que os atributos listados aqui devem ser tipos de dados escalares (não registros
filhos ou dataset filhos); use uma string vazia para processar todos os atributos no inFile;
OPCIONAL, o padrão é uma string vazia
maxPatterns O número máximo de padrões (populares e raros) a serem retornados para cada atributo;
OPCIONAL, o padrão é 100
maxPatternLen O comprimento máximo de um padrão; padrões mais longos são truncados na saída; esse valor
também é usado para definir o comprimento máximo dos dados a serem considerados ao en-
contrar os valores de cardinalidade e modo; deve ser 33 ou maior; OPCIONAL, o padrão é 100
features Uma cadeia de caracteres delimitada por vírgula, listando os elementos de criação de perfil a
serem incluídos na saída; OPCIONAL, o padrão é uma sequência delimitada por vírgula que
contém todas as palavras-chave disponíveis:
KEYWORD -----------------AFFECTED KEYWORD
fill_rate -----------------------fill_rate,fill_count
cardinality -------------------cardinality
cardinality_beakdown ----cardinality_breakdown
best_ecl_types -------------best_attribute_type
modes ------------------------modes
lengths -----------------------min_length,max_length,ave_length
patterns ----------------------popular_patterns,rare_patterns
min_max ---------------------numeric_min,numeric_max
mean -------------------------numeric_mean
std_dev ----------------------numeric_std_dev
quartiles ---------------------numeric_lower_quartile, numeric_median, numeric_upper_quartile
correlations -----------------correlations
Para omitir a saída associada a uma única palavra-chave, defina esse argumento como uma
string delimitada por vírgula contendo todas as outras palavras-chave; observe que a saída
© 2020 HPCC Systems. All rights reserved
30
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
is_numeric aparecerá apenas se os recursos min_max, mean, std_dev, quartis ou correlations
estiverem ativos; Observe também que a ativação do recurso cardinality_breakdown também
ativará o recurso cardinalidade, mesmo se não estiver explicitamente ativado
sampleSize Um número inteiro positivo representando uma porcentagem do inFile a ser examinado, que
é útil ao analisar um dataset muito grande e apenas um perfil de dados estimado é suficiente;
o intervalo válido para esse argumento é 1-100; valores fora desse intervalo serão fixados;
OPCIONAL, o padrão é 100 (o que indica que todo o conjunto de dados será analisado)
lcbLimit Um número inteiro positivo (menor ou igual a 500) indicando a cardinalidade máxima permiti-
da para um atributo para emitir uma discriminação dos valores do atributo; este parâmetro será
ignorado se cardinality_breakdown não estiver incluído no argumento de recursos; OPCION-
AL, o padrão é 64
Aqui está um exemplo muito simples de executar o código completo de criação de perfil de dados:
IMPORT DataPatterns;
filePath := '~thor::my_sample_data';
ds := DATASET(filePath, RECORDOF(filePath, LOOKUP), FLAT);
profileResults := DataPatterns.Profile(ds);
OUTPUT(profileResults, ALL, NAMED('profileResults'));
© 2020 HPCC Systems. All rights reserved
31
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Visualização
O HPCC Systems fornece visualização integrada dos dados de saída em uma variedade de tabelas e gráficos. Você
pode visualizar seus dados de três maneiras:
• Usando a ferramenta Chart no ECL Playground
• Acessando a aba Visualize em todas as ECL workunits
• Usando a aba Resources em conjunto com o pacote ECL Visualizer
O pacote de visualização é um complemento de código aberto para a plataforma HPCC para permitir que você crie
visualizações a partir de consultas gravadas em ECL.
As visualizações são um meio importante de transmitir informações de dados maciços (ou "grandes"). Uma boa rep-
resentação visual pode ajudar a gerar uma análise acionável. Uma representação visualmente abrangente das infor-
mações pode ajudar a tornar o obscuro em algo mais óbvio.
Gráficos de pizza, linha, mapas, e outros gráficos nos ajudam a entender as respostas encontradas nas consultas de
dados. O processamento de big data é apenas uma parte da solução; também é preciso compreender a complexidade
dos dados. Os métodos de visualização dos dados simplificam aquilo que é complexo.
O pacote Visualizer amplia a funcionalidade da plataforma HPCC, permitindo plotar seus dados em tabelas, gráficos
e mapas para adicionar uma representação visual que pode ser facilmente entendida.
Além disso, a estrutura de visualização subjacente suporta recursos avançados para permitir a combinação de gráficos
para criar dashboards.
Instalação
Para instalar, use a interface da linha de comandos da ECL.
1. Faça o download: https://github.com/hpcc-systems/Visualizer/archive/master.zip
2. Descompacte na pasta “Visualizer”: …\Downloads\Visualizer-master.zip -> …\Downloads\Visualizer
3. Instale usando a interface da linha de comandos: ecl bundle install %USERPROFILE%\Downloads\Visualizer
Como alternativa, você pode instalar diretamente do GitHub:
ecl bundle install https://github.com/hpcc-systems/Visualizer.git
Na instalação bem-sucedida, você verá a seguinte mensagem:
Instalando o Pacote Visualizer versão 2.0.0
Visualizer 2.0.0 ECL Visualization
Bundle Installation complete
Observação: Você pode achar mais fácil definir o PATH manualmente para incluir as ferramentas do cliente ECL:
set PATH=%PATH%;"c:\Program Files (x86)\HPCCSystems\7.4.0\clienttools\bin"
Observação: Para usar o comando "ecl bundle install <git url>", o git deve estar instalado na sua máquina e acessível
ao usuário (na variável PATH).
© 2020 HPCC Systems. All rights reserved
32
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Categorias de visualização
O pacote de visualização separa elementos visuais em 6 categorias. Cada função em sua categoria compartilha parâmet-
ros comuns , na maioria dos casos, renderização visual semelhante. Cada categoria também possui uma função de Test
integrada para ajudá-lo a obter uma visualização rápida dos elementos visuais visados.
Funções de visualização global (helper)
Cada um dos tipos de gráficos de visualização individuais conta com as duas (2) funções principais a seguir para
auxiliar na execução:
• Meta
Cria um conjunto de registros de saída especial que contém as meta informações para uso na visualização de destino.
Visualização dos resultados da meta-informação.
• Grid
Usado com a função Meta para renderizar dados na grade ou tabela de dados apropriada. Os mapeamentos podem ser
usados para limitar e/ou renomear as colunas.
Ambas as funções podem ser usadas fora da visualização para simplesmentemapear seus dados, conforme necessário.
Uma função de teste localizada no Visualizer Any também é fornecida para visualizar seus resultados:
IMPORT Visualizer;
Visualizer.Any.__test;
//View the results in the Workunit Resource Tab.
Visualizações "ordinais" bidimensionais
As visualizações nesta categoria são ideais para dados expressos com dois campos, um Label (string) e um Value
(número). Todos os outros campos no dataset são ignorados.
Existem cinco funções principais nessa categoria, localizadas na estrutura TwoD MODULE:
• Bubble - uma série de círculos cujo tamanho é proporcional ao valor do campo
• Pie - um único círculo dividido em fatias proporcionais
• Summary - valores são exibidos em intervalos designados
• RadialBar - basicamente um gráfico de barras plotado em coordenadas polares, em vez de um plano cartesiano.
• WordCloud - uma representação visual de dados de texto, cujo tamanho é proporcional ao seu valor.
Teste e visualize todas essas funções com a seguinte função de teste:
IMPORT Visualizer;
Visualizer.TwoD.__test;
Visualizações "lineares" bidimensionais
As visualizações nesta categoria usam os gráficos de valores X/Y padrão, também conhecidos como coordenadas
cartesianas, e usam um ValueX (número) e um ValueY (número). Todos os outros campos no dataset são ignorados.
© 2020 HPCC Systems. All rights reserved
33
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Existem três (3) funções principais nessa categoria, localizadas no TwoDLinear Estrutura MODULE:
• Scatter - usa coordenadas cartesianas (X/Y) para exibir valores de ponto para dois campos numéricos em um dataset
• HexBin - útil para representar 2 campos numéricos quando você possui muitos pontos de dados. Em vez de se
sobrepor, a janela de plotagem é dividida em vários hexbins e o número de pontos por hexbin é contado. A cor indica
esse número de pontos.
• Contour - uma técnica gráfica que usa linhas de contorno. Uma linha de contorno de uma função de duas variáveis
é uma curva ao longo da qual a função tem um valor constante, de modo que a curva une pontos de igual valor.
Teste e visualize todas essas funções com a seguinte função de teste:
IMPORT Visualizer;
Visualizer.TwoDLinear.__test;
Visualizações multidimensionais
As visualizações nesta categoria são ideais para qualquer matriz numérica de valores, expressa com um Label (string),
e umValue1 a ValueN (todos os números). Os dados são renderizados em um gráfico de eixo XY. Todos os outros
campos no dataset são ignorados.
Existem sete (7) funções principais nessa categoria, localizadas na estrutura MultiD MODULE :
• Area - a legenda é plotada no eixo X, e os valores de cada etiqueta são plotados no eixo Y. Os campos comuns são
unidos por linha e a área abaixo é sombreada.
• Bar - a legenda é plotada no eixo Y e os valores para cada gráfico da barra no eixo X.
• Column - semelhante ao Bar, mas o rótulo é plotado no eixo X e os valores associados são representados por barra
no eixo Y.
• Line - semelhante ao Area, mas nenhuma área sombreada é colorida (somente linhas)
• Radar - semelhante ao Area , mas usa um ponto central em um círculo para as coordenadas zero dos eixos X e Y.
Pense em um escopo de radar para esse tipo de gráfico.
• Scatter - os pontos são marcados apenas neste tipo de gráfico
• Step - usa linhas verticais e horizontais para conectar pontos de dados, semelhante a um tipo de exibição em degraus.
Teste e visualize todas essas funções com a seguinte função de teste:
IMPORT Visualizer;
Visualizer.MultiD.__test;
Método de Visualização Geoespacial
Há um único tipo de gráfico nessa categoria que renderiza dados em um gráfico de relação de entidades. Os dados são
mapeados a partir de duas tabelas. A primeira tabela controla os vértices (nós) e cada nó contém três campos; uma
coluna de ID usando qualquer tipo de dados, uma string Label e uma string Icon. Esses vértices são conectados por
arestas (ou links) e cada aresta contém no mínimo 2 campos que unem ou conectam os vértices. O primeiro campo
é um Source ID e o segundo campo é um Target ID. Por exemplo, se eu tiver 3 vértices definidos; Casa - 1, Mulher
- 2 e Homem -3, um registro de limite {1,2} vinculará Casa(1) a Mulher(2) e um registro de limite {1,3} vinculará
Casa(1) a Homem (3). Um registro de limite {3,2} vincularia Homem(3) a Mulher(2) (consulte a função Test para
obter uma ilustração disso).
© 2020 HPCC Systems. All rights reserved
34
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Existe uma única função nesta categoria localizada na estrutura Relational MODULE:
• Network - monta os vértices e arestas definidos em um gráfico de relação de entidades
Teste e visualize este gráfico com a seguinte função de teste:
IMPORT Visualizer;
Visualizer.Relational.__test;
Método de Visualização Geoespacial
As visualizações geoespaciais são essencialmente gráficos de mapas, visualizando um valor com uma localização
específica. Os dados geoespaciais são expressos com dois campos, o Field 1 é uma STRING que contém um Location
Id (dependendo do tipo de gráfico) e um Value (número) que identifica ou colore um local. Todos os outros campos
no dataset são ignorados. Os mapeamentos em cada função podem ser usados para associar os campos no dataset de
destino aos campos do gráfico.
Existem cinco funções principais nessa categoria, localizadas na estrutura MODULE Choropleth :
• USStates - Um mapa de estados do EUA que mapeia um código de estado de duas letras com seu valor associado.
• USCounties - Um mapa do estado do EUA que mapeia um código numérico do condado FIPS (Federal Information
Processing Standard) com seu valor associado.
• Euro - um gráfico de mapa base que permite selecionar qualquer país do continente europeu. Um código internacional
de duas letras é necessário para a região.
• EuroIE - Exemplo de função no pacote que usa a função Euro para mostrar o mapa da Irlanda.
• EuroGB - Exemplo de função no pacote que usa a função Euro para mostrar o mapa da Grã-Bretanha.
Teste e visualize todas essas funções com a seguinte função de teste:
IMPORT Visualizer;
Visualizer.Choropleth.__test;
Início Rápido
O uso do pacote de visualização é essencialmente um processo de três etapas.
1. Prepare seus dados. Muitos pontos podem tornar um gráfico ilegível, poucos pontos diminuem o benefício da análise.
2. Importe a pasta Visualizer. Se você usar o método "git", sua pasta será facilmente localizada.
3. OUTPUT do seus dados usando o atributo NAMED.
4. Chame seu Visualizador gráfico usando o atributo NAMED como sua fonte de gráfico
Exemplo:
IMPORT $, Visualizer;
GenderDS := DATASET([{'Female', 404988}, 
 {'Male', 384182}, 
 {'Neutral', 20508}, 
 {'Unknown', 70722}],
 {STRING Label,UNSIGNED4 Value});
© 2020 HPCC Systems. All rights reserved
35
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
OUTPUT(GenderDS,NAMED('VizPie'));
Visualizer.TwoD.Pie('Pie',,'VizPie');
© 2020 HPCC Systems. All rights reserved
36
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Exercício 3c
Especificação do exercício:
Execute uma análise detalhada do perfil do campo do dataset de treinamento Persons usando a função built-in Profile
encontrada na Biblioteca Padrão.
Requisitos:
1. O arquivo de definição a ser criado para este exercício é: BWR_Persons_DP
2. Chame a função STD.DataPatterns.Profile que passa o dataset Person EXPORTado como parâmetro. DICA:
Você precisará IMPORTar uma referência da Biblioteca Padrão.
3. Gere a saída dos resultados e verifique se os resultados parecem razoáveis.
4. Extra: O que o BestRecordStructure diz sobre a estrutura RECORD que você está usando?
Melhores práticas
As funções Data Patterns Profile e BestRecordStructure são ferramentas valiosas que fornecemuma análise detal-
hada de qualquer conjunto de dados. É possível analisar Data Patterns nas informações de arquivos lógicos no ECL
Watch ou executar sua própria criação de perfil usando o pacote configurável ou a Biblioteca PadrãoDataPatterns .
Comparação do resultado
Envie os resultados do perfil no ECL IDE, no ECL Watch e analise com sua turma e instrutor.
© 2020 HPCC Systems. All rights reserved
37
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Mais relatórios de avaliação de dados
Exercício 3d
Especificação do exercício:
Gere e exiba um Gráfico de Mapa de Coropletos do USStates que reflete a população por estado do dataset Persons.
Use um arquivo BWR (Builder Window Runnable) para exibir o resultado.
Requisitos:
1. O arquivo de definição a ser criado para este exercício é: BWR_StatePopulation
2. Crie um relatório de tabulação cruzada que produz COUNTs por estado.
3. Faça OUTPUT do seu relatório cross-tab e atribua ao resultado um atributo NAMED.
4. Consulte o Manual de Treinamento e instale o pacote do Visualizer usando a técnica git especificada (NOTA: Você
também precisará do Git for Windows instalado em sua máquina).
5. Depois que o pacote Visualizer estiver instalado, chame o mapa cloroplético USStates da seguinte maneira:
Visualizer.Choropleth.USStates('usStates',,'yourNAMEDattributeHere');
Melhores práticas
A chave para uma ótima visualização é entender os dados com os quais você está trabalhando. Muitos pontos de dados
podem distorcer e dificultar a leitura do gráfico, e poucos pontos podem diluir a análise. Use a opção Visualize na
workunit do ECL Watch e experimente os diferentes estilos de gráfico disponíveis. Depois de encontrar o gráfico que
você está procurando, chame a função Visualizer apropriada para renderizar o resultado na aba Resources. A URL na
aba Resources pode ser distribuída ao seu usuário final.
Comparação do resultado
Veja seu resultado na aba ECL Watch Resources da sua workunit. Você deve ver um mapa dos Estados Unidos e a
população por estado claramente marcada.
© 2020 HPCC Systems. All rights reserved
38
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Transformações simples
Estrutura TRANSFORM
resulttype funcname ( parameterlist ) := TRANSFORM [, SKIP( condition )]
[ locals ]
SELF.outfield := transformation;
END;
TRANSFORM( resulttype, assignments )
TRANSFORM( datarow )
resulttype O nome de um Atributo da estrutura RECORD que especifica o formato dos resulta-
dos da função. Você pode usar TYPEOF aqui para especificar um dataset. Nenhuma
relação implícita do dataset de entrada é herdada.
funcname O nome da função definida pela estrutura TRANSFORM.
parameterlist Uma lista separada por vírgulas dos tipos de valores e rótulos dos parâmetros a serem
passados para a função TRANSFORM. Normalmente, são registros de dataset ou
parâmetros de COUNTER, mas não estão limitados a isso.
SKIP Opcional. Especifica a condition na qual a operação da função TRANSFORM é igno-
rada.
condition Uma expressão lógica que define em que circunstâncias a operação de TRANSFORM
não ocorre. Pode usar dados de parameterlist da mesma forma que a expressão trans-
formation .
locals Opcional. Definições de Atributos locais, úteis dentro da função TRANSFORM. Po-
dem ser definidos para receber parâmetros e podem usar qualquer parâmetro passado
para TRANSFORM.
SELF Especifica o conjunto de registros dos resultados gerados por TRANSFORM.
outfield O nome de um campo na estrutura resulttype .
transformation Uma expressão que especifica como produzir o valor de outfield. Isso pode incluir
outras operações da função TRANSFORM (transformações aninhadas).
assignments Uma lista delimitada por ponto e vírgula de definições SELF.outfield:= transformation
.
datarow Um único registro a transformar. Normalmente, a palavra-chave LEFT.
A estrutura TRANSFORM possibilita operações que devem ser executadas em datasets inteiros (como um JOIN)
e qualquer tipo iterativo de processamento de registros (PROJECT, ITERATE, etc.). Uma estrutura TRANSFORM
define as operações específicas que devem ocorrer registro a registro. Ela define a função chamada a cada vez que
a operação que usa TRANSFORM precisa processar registro(s). Uma função TRANSFORM pode ser definida em
termos de outra, e elas podem ser aninhadas.
A estrutura TRANSFORM especifica exatamente como cada campo do conjunto de resultados deve receber seu valor.
O valor do resultado pode ser simplesmente o valor de um campo em um conjunto de registros de entrada ou pode ser
o resultado de algum cálculo complexo ou avaliação de expressão condicional.
© 2020 HPCC Systems. All rights reserved
39
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
A estrutura TRANSFORM em si é uma ferramenta genérica. Cada operação que usa uma função TRANSFORM define
o que TRANSFORM precisa receber e qual funcionalidade básica deve fornecer. Portanto, o caminho correto para
compreender estruturas TRANSFORM é entender como são usadas pela função que chama a estrutura. Cada função
que usa um TRANSFORM documenta o tipo necessário para alcançar o objetivo, embora a própria TRANSFORM
também possa fornecer funcionalidades adicionais e receber outros parâmetros além dos necessários para a operação.
A opção SKIP especifica a condition que não gera resultados dessa iteração de TRANSFORM. No entanto, os valores
COUNTER são incrementados mesmo quando SKIP elimina a criação do registro atual.
Definições dos Atributos de Transformação
As definições de atributos dentro da estrutura TRANSFORM são usadas para converter os dados passados como
parâmetros para o formato resulttype nos resultados. Cada campo no layout do registro resulttype deve ser completa-
mente definido no TRANSFORM. Você pode definir explicitamente cada campo usando a expressão SELF.outfield
:= transformation; , ou pode usar um destes atalhos:
SELF := [ ];
limpa campos nos resultados de resulttype que não foram definidos previamente na função de transformação, ao passo
que este formato:
SELF.outfield := []; //the outfield names a child DATASET in
 // the resulttype RECORD Structure
limpa apenas os campos secundários em outfield, e este formato:
SELF := label; //the label names a RECORD structure parameter
// in the parameterlist
define os resultados de cada campo no formato de resultados de resulttype que não foi definido como oriundo do
campo nomeado correspondente do parâmetro label.
Você também pode definir atributos local dentro da estrutura TRANSFORM para organizar melhor o código. Esses
atributos local podem receber parâmetros.
Funções TRANSFORM
Esse formato de TRANSFORM deve ser encerrado pela palavra-chave END. O resulttype deve ser especificado, e
a própria função recebe parâmetros em parameterlist. Normalmente, esses parâmetros são estruturas RECORD, mas
podem ser qualquer tipo de parâmetro, dependendo do tipo de função TRANSFORM esperado pela função que faz
a chamada. O formato exato de uma função TRANSFORM está sempre associado diretamente à operação que usa
essa função.
Exemplo:
Ages := RECORD
 AgedRecs.id;
 AgedRecs.id1;
 AgedRecs.id2;
END;
SequencedAges := RECORD
 Ages;
 INTEGER4 Sequence := 0;
END;
SequencedAges AddSequence(AgedRecs L, INTEGER C) :=
 TRANSFORM, SKIP(C % 2 = 0) //skip even recs
 INTEGER1 rangex(UNSIGNED4 divisor) := (l.id DIV divisor) % 100;
 SELF.id1 := rangex(10000);
© 2020 HPCC Systems. All rights reserved
40
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
 SELF.id2 := rangex(100);
 SELF.Sequence := C;
 SELF := L;
END;
SequencedAgedRecs := PROJECT(AgedRecs, AddSequence(LEFT,COUNTER));
//Example of defining a TRANSFORM function in terms of another
namesIdRecord assignId(namesRecord l, UNSIGNED value) := TRANSFORM
 SELF.id := value;
 SELF := l;
END;
assignId1(namesRecord l) := assignId(l, 1);
 //creates an assignId1 TRANSFORM that uses assignId
assignId2(namesRecord