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(namesRecordl) := assignId(l, 2);
 //creates an assignId2 TRANSFORM that uses assignId
TRANSFORMs em linha
Este formato de TRANSFORM é usado em linha dentro da operação que usa a função. O resulttype deve ser especi-
ficado juntamente com todos os assignments. Esse formato é usado principalmente quando os assignments de trans-
formação são triviais (como SELF := LEFT;).
Exemplo:
namesIdRecord assignId(namesRecord L) := TRANSFORM
 SELF := L; //more like-named fields across
 SELF := []; //clear all other fields
END;
projected1 := PROJECT(namesTable, assignId(LEFT));
projected2 := PROJECT(namesTable, TRANSFORM(namesIdRecord,
 SELF := LEFT;
 SELF := []));
//projected1 and projected2 do the same thing
TRANSFORMs abreviado em linha
Este formato de TRANSFORM é uma versão abreviada de TRANSFORMs em linha. Neste formato,
TRANSFORM(LEFT)
é diretamente equivalente a
TRANSFORM(RECORDOF(LEFT), SELF := LEFT)
Exemplo:
namesIdRecord assignId(namesRecord L) := TRANSFORM
 SELF := L; //move like-named fields across
END;
projected1 := PROJECT(namesTable, assignId(LEFT));
projected2 := PROJECT(namesTable, TRANSFORM(namesIdRecord,
 SELF := LEFT));
projected3 := PROJECT(namesTable, TRANSFORM(LEFT));
//projected1, projected2, and projected3 all do the same thing
Ver também: RECORD Structure, RECORDOF, TYPEOF, JOIN, PROJECT, ITERATE, ROLLUP, NORMALIZE,
DENORMALIZE, FETCH, PARSE, ROW
© 2020 HPCC Systems. All rights reserved
41
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
PROJECT
PROJECT( recordset, transform [, PREFETCH [ (lookahead [, PARALLEL]) ] ] [, KEYED ] [, LOCAL ] [,
UNORDERED | ORDERED( bool ) ] [, STABLE | UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGO-
RITHM( name ) ] )
PROJECT( recordset, record [, PREFETCH [ (lookahead [, PARALLEL]) ] ] [, KEYED ] [, LOCAL ] [, UN-
ORDERED | ORDERED( bool ) ] [, STABLE | UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM(
name ) ] )
recordset O conjunto de registros para processamento. Esse pode ser um DATASET em linha de registro
único.
transform A função TRANSFORM a ser acionada para cada registro no recordset.
PREFETCH Opcional. Permite que leituras de índice dentro do transfom sejam tão eficientes quanto JOINs
com chave. Válido apenas para consultas ECL no Roxie.
lookahead Opcional. Especifica o número de leituras antecipadas. Se omitido, o padrão é o valor da tag
_PrefetchProjectPreload na consulta enviada. Se for omitido, o valor de defaultPrefetchProject-
Preload especificado no arquivo RoxieTopology será usado quando o Roxie foi implantado. Se
for omitido, 10 será usado por padrão.
PARALLEL Opcional. Especifica que a consulta avançada é feita em um thread separado, em paralelo com
a execução da consulta.
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.
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.
record A estrutura RECORD do resultado estrutura para uso em cada registro no recordset.
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 com-
patíveis com as opções STABLE e UNSTABLE da função SORT.
Return: PROJECT retorna um conjunto de registros.
A função PROJECT processa todos os registros no recordset , realizam a função transform em cada registro por vez.
A forma 1 PROJECT(recordset,record) é basicamente um sinônimo abreviado para:
PROJECT(recordset,TRANSFORM(record,SELF := LEFT)).
simplificando a transferência de dados de uma estrutura para outra sem um TRANSFORM, contanto que todos os
campos na estrutura de registro de resultado estejam presentes no recordset de entrada.
© 2020 HPCC Systems. All rights reserved
42
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Requisitos da Função TRANSFORM - PROJECT
A função transform precisa usar no mínimo um parâmetro: um registro LEFT de mesmo formato que o recordset.
Opcionalmente, ele pode usar um segundo parâmetro: um COUNTER inteiro que especifique o número de vezes que
a função transform foi acionada para o recordset , ou outro grupo atual no recordset (consulte a função GROUP). O
segundo form de parâmetro é útil para adicionar números de sequência. O formato do conjunto de registro resultante
não precisa ser o mesmo do da entrada.
Exemplo:
//form one example **********************************
Ages := RECORD
 STRING15 per_first_name;
 STRING25 per_last_name;
 INTEGER8 Age;
END;
TodaysYear := 2001;
Ages CalcAges(person l) := TRANSFORM
 SELF.Age := TodaysYear - l.birthdate[1..4];
 SELF := l;
END;
AgedRecs := PROJECT(person, CalcAges(LEFT));
//COUNTER example **********************************
SequencedAges := RECORD
 Ages;
 INTEGER8 Sequence := 0;
END;
SequencedAges AddSequence(Ages l, INTEGER c) :=
 TRANSFORM
 SELF.Sequence := c;
 SELF := l;
END;
SequencedAgedRecs := PROJECT(AgedRecs,
 AddSequence(LEFT,COUNTER));
//form two example **********************************
NewRec := RECORD
 STRING15 firstname;
 STRING25 lastname;
 STRING15 middlename;
END;
NewRecs := PROJECT(People,NewRec);
//equivalent to:
//NewRecs := PROJECT(People,TRANSFORM(NewRec,SELF :=
 LEFT));
//LOCAL example **********************************
MyRec := RECORD
 STRING1 Value1;
 STRING1 Value2;
END;
SomeFile := DATASET([{'C','G'},{'C','C'},{'A','X'},
 {'B','G'},{'A','B'}],MyRec);
MyOutRec := RECORD
 SomeFile.Value1;
 SomeFile.Value2;
© 2020 HPCC Systems. All rights reserved
43
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
 STRING6 CatValues;
END;
DistFile := DISTRIBUTE(SomeFile,HASH32(Value1,Value2));
MyOutRec CatThem(SomeFile L, INTEGER C) := TRANSFORM
 SELF.CatValues := L.Value1 + L.Value2 + '-' +
 (Std.System.Thorlib.Node()+1) + '-' + (STRING)C;
 SELF := L;
END;
CatRecs := PROJECT(DistFile,CatThem(LEFT,COUNTER),LOCAL);
OUTPUT(CatRecs);
/* CatRecs result set is:
Rec# Value1 Value2 CatValues
1 C C CC-1-1
2 B G BG-2-1
3 A X AX-2-2
4 A B AB-3-1
5 C G CG-3-2
*/
Ver também: Estrutura TRANSFORM, Estrutura RECORD, ROW, DATASET
PROJECT - Módulo
PROJECT( module, interface [, OPT | attributelist ] )
module A estrutura MODULE que contém definições de atributo cujos valores passam como a interface.
interface A estrutura INTERFACE para passar.
OPT Opcional. Suprime a mensagem de erro que é gerada quando um atributo definido na interface
não é definido também no módulo.
attributelist Opcional. Uma lista de atributos específicos delimitada por vírgula no módulo para fornecer à
interface. Isso permite a implementação de uma lista especificada de atributos, algo que é útil se
você quiser um controle mais rígido ou se os tipos de parâmetros não corresponderem.
Return: PROJECT retorna um MODULE compatível com a interface.
A função PROJECT passa os atributos de um módulo na forma de interface para uma função definida para aceitar
parâmetrosestruturados como a interface especificada. Isso permite que você crie um módulo para uma interface
com os valores fornecidos por outra interface. Os atributos no módulo precisam ser compatíveis com os atributos na
interface (do mesmo tipo e mesmos parâmetros, se usar algum parâmetro).
Exemplo:
PROJECT(x,y)
/*is broadly equivalent to
MODULE(y)
 SomeAttributeInY := x.someAttributeInY
 //... repeated for all attributes in Y ...
END;
*/
myService(myInterface myArgs) := FUNCTION
 childArgs := MODULE(PROJECT(myArgs,Iface,isDead,did,ssn,address))
 BOOLEAN isFCRA := myArgs.isFCRA OR myArgs.fakeFCRA
 END;
 RETURN childService(childArgs);
© 2020 HPCC Systems. All rights reserved
44
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
 END;
// you could directly pass PROJECT as a module parameter
// to an attribute:
myService(myInterface myArgs) := childService(PROJECT(myArgs, childInterface));
Ver também: Estrutura MODULE, Estrutura INTERFACE, Estrutura FUNCTION, STORED
© 2020 HPCC Systems. All rights reserved
45
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Exemplo funcional de PROJECT
PROJECT
Abra BWR_Training_Examples.DEDUP_ALL_Example em uma janela ECL e envie esta consulta:
MyRec := RECORD
 STRING1 Value1;
 STRING1 Value2;
END;
SomeFile := DATASET([{'C','G'},
 {'C','C'},
 {'A','X'},
 {'B','G'},
 {'A','B'}],MyRec);
MyOutRec := RECORD
 SomeFile.Value1;
 SomeFile.Value2;
 STRING4 CatValues;
END;
MyOutRec CatThem(SomeFile L, INTEGER C) := TRANSFORM
 SELF.CatValues := L.Value1 + L.Value2 + '-' + (STRING)C;
 SELF := L;
END;
CatRecs := PROJECT(SomeFile,CatThem(LEFT,COUNTER));
OUTPUT(CatRecs);
/* CatRecs result set is:
 Rec# Value1 Value2 CatValues
 1 C G CG-1
 2 C C CC-2
 3 A X AX-3
 4 B G BG-4
 5 A B AB-5
*/
© 2020 HPCC Systems. All rights reserved
46
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Diagrama de exemplo funcional do PROJECT
© 2020 HPCC Systems. All rights reserved
47
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
ITERATE
ITERATE(recordset, transform [, LOCAL ] [, UNORDERED | ORDERED( bool ) ] [, STABLE | UNSTABLE ]
[, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
recordset O conjunto de registros para processamento.
transform A função TRANSFORM a ser acionada para cada registro no recordset.
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 com-
patíveis com as opções STABLE e UNSTABLE da função SORT.
LOCAL Opcional. Especifica que a operação é realizada em cada nó de supercomputador de forma independente,
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.
Return: ITERATE retorna um conjunto de registros.
A função ITERATE processa através de todos os registros no recordset um par de registros por vez, executando a
função transform em cada par sucessivamente. O primeiro registro no recordset é especificado para transform como o
primeiro registro RIGHT, emparelhado com um registro LEFT cujos campos estão todos em branco ou definidos para
zero. Cada registro resultante de transform se torna o registro LEFT do próximo par.
Requerimentos da Função TRANSFORM - ITERATE
A função transform deve adotar pelo menos dois parâmetros: Registros LEFT e RIGHT que precisam estar no mesmo
formato que o recordset resultante. Pode ser especificado um terceiro parâmetro opcional: um COUNTER de número
inteiro para especificar o número de vezes que transform foi acionado para o recordset ou para o grupo atual no
recordset (consulte a função GROUP ).
Exemplo:
ResType := RECORD
 INTEGER1 Val;
 INTEGER1 Rtot;
END;
Records := DATASET([{1,0},{2,0},{3,0},{4,0}],ResType);
/* these are the recs going in: 
Val Rtot 
 1 0
 2 0
 3 0
 4 0 */
© 2020 HPCC Systems. All rights reserved
48
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
ResType T(ResType L, ResType R) := TRANSFORM
 SELF.Rtot := L.Rtot + R.Val;
 SELF := R;
END;
MySet1 := ITERATE(Records,T(LEFT,RIGHT));
/* these are the recs coming out: 
Val Rtot
 1 1
 2 3
 3 6
 4 10 */
//The following code outputs a running balance:
Run_bal := RECORD
 Trades.trd_bal;
 INTEGER8 Balance := 0;
END;
TradesBal := TABLE(Trades,Run_Bal);
Run_Bal DoRoll(Run_bal L, Run_bal R) := TRANSFORM
 SELF.Balance := L.Balance + IF(validmoney(R.trd_bal),R.trd_bal,0);
 SELF := R;
END;
MySet2 := ITERATE(TradesBal,DoRoll(LEFT,RIGHT));
See Also: Estrutura TRANSFORM, Estrutura RECORD, ROLLUP
© 2020 HPCC Systems. All rights reserved
49
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Exemplo funcional ITERATE
ITERATE
Abra BWR_Training_Examples.ITERATE_Example em uma janela ECL e envie esta consulta:
MyRec := RECORD
 INTEGER2 Value1;
 INTEGER2 Value2;
END;
SomeFile := DATASET([{10,0},
 {20,0},
 {30,0},
 {40,0},
 {50,0}],MyRec);
MyRec AddThem(MyRec L, MyRec R) := TRANSFORM
 SELF.Value2 := L.Value2 + R.Value1;
 SELF := R;
END;
AddedRecs := ITERATE(SomeFile,AddThem(LEFT,RIGHT));
output(AddedRecs);
/* Processes as:
 LEFT.Value2 RIGHT.Value1
 0 (0) 1 (10) - 0 + 10 = 10
 1 (10) 2 (20) - 10 + 20 = 30
 2 (30) 3 (30) - 30 + 30 = 60
 3 (60) 4 (40) - 60 + 40 = 100
 4 (100) 5 (50) - 100 + 50 = 150
AddedRecs result set is:
 Rec# Value1 Value2
 1 10 10
 2 20 30
 3 30 60
 4 40 100
 5 50 150
*/
© 2020 HPCC Systems. All rights reserved
50
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Diagrama de Exemplo Funcional ITERATE
© 2020 HPCC Systems. All rights reserved
51
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
PERSIST
attribute := expression : PERSIST( filename [, cluster ] [, CLUSTER(target)] [, EXPIRE(days )] [, REFRESH(flag
)] [, SINGLE | MULTIPLE[(count)]] ) ;
attribute O nome do atributo.
expression A definição do atributo. Isso normalmente define um recordset (mas pode ser qualquer ex-
pressão).
filename Uma constante de string que especifica o nome de armazenamento do resultado de expressão.
Consulte Escopo e nomes de arquivo lógicos..
cluster Opcional. Uma constante de string que especifica o nome do cluster Thor no qual o atributo é re-
compilado se/quando necessário. Isso possibilita usar atributos persistentes em clusters menores,
mas compilá-los em maiores, tornando a utilização de recursos mais eficiente. Se omitido, o
atributo é recompilado no cluster em execução atualmente.
CLUSTER Opcional. Especifica a gravação do nome de arquivo para a lista especificada de clusters de des-
tino . Se omitido, o nome de arquivo é gravado no cluster no qual a função PERSIST é executada
(como especificadopelo parâmetro cluster ). O número de partes de arquivos físicos gravadas
em disco é sempre determinado pelo número de nós no cluster no qual a função PERSIST é
executada, independentemente do número de nós no(s) destino(s).
target Uma lista de constantes de string delimitada por vírgulas que contém os nomes dos clusters
no qual o arquivo será gravado. Os nomes devem estar listados como aparecem na página de
Atividade do ECL Watch, ou como são retornados pela função Std.System.Thorlib.Group(); op-
cionalmente, podem apresentar colchetes contendo uma lista delimitada por vírgula dos números
dos nós (baseado em 1) e/ou dos intervalos (especificados com um traço, como p.ex., n-m) para
indicar o conjunto específico de nós para gravar.
EXPIRE Opcional. Especifica que o nome de arquivo é um arquivo temporário que pode ser removido
automaticamente após um número especificado de dias.
days Opcional. O número de dias em que o arquivo será automaticamente removido. Se omitido, por
padrão, a configuração PersistExpiryDefault será usada no Sasha.
REFRESH Opcional. Opção de controle quando o PERSIST é recompilado. Se omitido, o PERSIST recom-
pila caso 1) o arquivo subjacente não exista, ou 2) os dados tenham sido alterados ou 3) o código
tenha sido alterado.
flag Um valor booleano indicando se PERSIST deve ser recompilado ou não. Quando definido para
FALSE, o PERSIST recompila ONLY (APENAS) se o arquivo subjacente não existir. Se seu
layout PERSIST tiver sido alterado e você especificar REFRESH(FALSE), a incompatibilidade
ocasionaria a falha do job.
SINGLE Opcional. Especifica para manter um único PERSIST. O nome do arquivo de persistência é o
mesmo do nome da persistência.
MULTIPLE Opcional. Especifica para manter diferentes versões do PERSIST. O nome do arquivo de per-
sistência gerado é uma combinação do nome fornecido com sufixo de valor de 32 bits derivado
do ECL.
count Opcional. O número de versões de um PERSIST deve ser mantido. Se omitido, o padrão do
sistema será usado.
O serviço PERSIST armazena o resultado da expressão globalmente de forma a continuar permanentemente disponív-
el para uso (incluindo o resultado de qualquer operação DISTRIBUTE ou GROUP na expressão). Isso é especialmente
útil para atributos baseados em sequências de manipulação de dados dispendiosas e grandes. O atributo é recalculado
apenas quando o código ECL ou os dados subjacentes que foram usados para criá-lo sofrem alterações; caso contrário,
© 2020 HPCC Systems. All rights reserved
52
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
os dados de atributo são simplesmente retornados do arquivo nome armazenado em disco quando referido. Implicita-
mente, esse serviço faz com que o atributo seja avaliado em um escopo global em vez de escopo de função.
PERSIST pode ser combinado com a cláusula WHEN para que, embora o atributo possa ser usado mais de uma vez,
sua execução seja baseada na cláusula WHEN (ou o primeiro uso do atributo) e não baseada no número de vezes que
o atributo é usado na computação. Isso oferece um tipo recurso denominado "computação antecipada".
Exemplo:
 CountPeople := COUNT(Person) : PERSIST('PeopleCount');
 //Makes CountPeople available for use in all subsequent work units
 
 sPeople := SORT(Person,Person.per_first_name) :
 PERSIST('SortPerson'),WHEN(Daily);
 //Makes sPeople available for use in all subsequent work units
 
 s1 := SORT(Person,Person.per_first_name) :
 PERSIST('SortPerson1','OtherThor');
 //run the code on the OtherThor cluster
 s2 := SORT(Person,Person.per_first_name) :
 PERSIST('SortPerson2',
 'OtherThor',
 CLUSTER('AnotherThor'));
 //run the code on the OtherThor cluster
 // and write the file to the AnotherThor cluster
Ver também: STORED, WHEN, GLOBAL, CHECKPOINT
Estrutura SERVICE
servicename := SERVICE [ : defaultkeywords ]
prototype : keywordlist;
END;
servicename O nome do serviço fornecido pela estrutura SERVICE.
defaultkeywords Opcional. Uma lista delimitada por vírgula das palavras-chave padrão e seus valores compar-
tilhados por todos os protótipos no serviço externo.
prototype O nome ECL e o protótipo de uma função específica.
keywordlist Uma lista delimitada por vírgula das palavras-chave e seus valores que instruem o compilador
ECL como acessar o serviço externo.
A estrutura SERVICE possibilita a criação de serviços externos para ampliar os recursos do ECL no desempenho
de qualquer funcionalidade desejada. Estes serviços externos do sistema são implementados como funções exportadas
em .SO(Shared Object). Um serviço de sistema da ECL .SO pode conter um ou mais serviços e (possivelmente) uma
única rotina de inicialização de .SO.
Exemplo:
 email := SERVICE
 simpleSend( STRING address,
 STRING template,
 STRING subject) : LIBRARY='ecl2cw',
© 2020 HPCC Systems. All rights reserved
53
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
 INITFUNCTION='initEcl2Cw';
 END;
 MyAttr := COUNT(Trades): FAILURE(email.simpleSend('help@ln_risk.com',
 'FailTemplate',
 'COUNT failure'));
 //An example of a SERVICE function returning a structured record
 NameRecord := RECORD
 STRING5 title;
 STRING20 fname;
 STRING20 mname;
 STRING20 lname;
 STRING5 name_suffix;
 STRING3 name_score;
 END;
 
 LocalAddrCleanLib := SERVICE
 NameRecord dt(CONST STRING name, CONST STRING server = 'x')
 : c,entrypoint='aclCleanPerson73',pure;
 END;
 
 MyRecord := RECORD
 UNSIGNED id;
 STRING uncleanedName;
 NameRecord Name;
 END;
 x := DATASET('x', MyRecord, THOR);
 
 myRecord t(myRecord L) := TRANSFORM
 SELF.Name := LocalAddrCleanLib.dt(L.uncleanedName);
 SELF := L;
 END;
 y := PROJECT(x, t(LEFT));
 OUTPUT(y);
 //The following two examples define the same functions:
 TestServices1 := SERVICE
 member(CONST STRING src)
 : holertl,library='test',entrypoint='member',ctxmethod;
 takesContext1(CONST STRING src)
 : holertl,library='test',entrypoint='takesContext1',context;
 takesContext2()
 : holertl,library='test',entrypoint='takesContext2',context;
 STRING takesContext3()
 : holertl,library='test',entrypoint='takesContext3',context;
 END;
 
 //this form demonstrates the use of default keywords
 TestServices2 := SERVICE : holert,library='test'
 member(CONST STRING src) : entrypoint='member',ctxmethod;
 takesContext1(CONST STRING src) : entrypoint='takesContext1',context;
 takesContext2() : entrypoint='takesContext2',context;
 STRING takesContext3() : entrypoint='takesContext3',context;
 END;
Ver também: Implementação de Serviços Externos, CONST
© 2020 HPCC Systems. All rights reserved
54
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Node
STD.System.Thorlib.Node( )
Return: Node retorna um valor UNSIGNED INTEGER4.
A função Node retorna o número (baseado em zero) do nó da Refinaria de dados (Thor) ou do Motor de entrega
rápida de dados (Roxie).
Example:
A := STD.System.Thorlib.Node();
© 2020 HPCC Systems. All rights reserved
55
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Nodes
STD.System.Thorlib.Nodes( )
Return: Node retorna um valor UNSIGNED INTEGER4.
A função Nodes retorna o número de nós no cluster Thor (para hThor e Roxie, retorna sempre 1). Esse número é
o mesmo que a constante de tempo de compilação CLUSTERSIZE. A função Nodes é avaliada a cada vez que é
chamada. Portanto, a opção entre usar a função e a constante depende das circunstâncias.
Exemplo:
A := STD.System.Thorlib.Nodes();
© 2020 HPCC Systems. All rights reserved
56
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Exercício 4a
Especificação do exercício:
Crie uma definição de conjunto de registros que adicionenúmeros de identificação de registro exclusivos ao arquivo
Persons usando PROJECT. Use o serviço de workflow PERSIST para que os resultados não precisem ser recalculados
no uso subsequente.
Requisitos:
1. O arquivo de definição a ser criado para este exercício é: UID_Persons.
2. O nome PERSIST deve começar com ~CLASS, seguido pelas suas iniciais, seguidas por PERSIST::UID_Persons,
como neste exemplo:
~CLASS::XX::PERSIST::UID_Persons
Comparação do resultado
Abra uma janela do ECL Builder e execute uma SAÍDA simples da definição. Verifique se o campo de identificação
do registro é numerado sequencialmente.
© 2020 HPCC Systems. All rights reserved
57
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Transformações simples
Exercício 4b
Especificação do exercício:
Crie uma definição de conjunto de registros que adicione números de Record ID exclusivos ao arquivo Accounts
usando ITERATE. Use as funções ThorLib.Node e ThorLib.Nodes (consulte a Referência da Biblioteca de Serviços)
para criar os identificadores de registro exclusivos para que o ITERATE possa usar a opção LOCAL.
Use o serviço de workflow PERSIST para que os resultados não precisem ser recalculados no uso subsequente.
Requisitos:
O arquivo de definição a ser criado para este exercício é: UID_Accounts
O nome PERSIST deve começar com ~CLASS, seguido pelas suas iniciais, seguidas por PERSIST::UID_Accounts,
como neste exemplo:
~CLASS::XX::PERSIST::UID_Accounts
Comparação do resultado
Abra uma janela do ECL Builder e execute uma SAÍDA simples da definição. Como você está obtendo apenas 100
registros, todos serão do primeiro nó a responder à consulta. Verifique se o campo ID do registro está numerado
exclusivamente em incrementos que correspondem ao número de nós no ambiente (3).
© 2020 HPCC Systems. All rights reserved
58
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Padronização de dados
Padronização de dados
Neste capítulo, examinaremos o processo de limpeza e compressão de dados. Antes de prosseguir, vamos apresentar
uma função adicional de ECL que usaremos no próximo conjunto de exercícios:
© 2020 HPCC Systems. All rights reserved
59
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Padronização de dados
SIZEOF
SIZEOF(data [, MAX ] )
data O nome de um dataset, uma estrutura RECORD, o nome de um campo totalmente qualificado,
ou uma expressão de string constante.
MAX Especifica que os dados são de comprimento variável (que contêm datasets secundários) e que o
valor a ser retornado possui tamanho máximo.
Return: ROUNDUP retorna um único valor inteiro.
A função SIZEOF retorna o número total de bytes definido para armazenar a estrutura de dados ou campo especifi-
cados. data Estrutura ou Campo.
Exemplo:
MyRec := RECORD
INTEGER1 F1;
INTEGER5 F2;
STRING1 F3;
STRING10 F4;
QSTRING12 F5;
VARSTRING12 F6;
END;
MyData :=
 DATASET([{1,33333333333,'A','A','A',V'A'}],MyRec);
SIZEOF(MyRec); //result is 39
SIZEOF(MyData.F1); //result is 1
SIZEOF(MyData.F2); //result is 5
SIZEOF(MyData.F3); //result is 1
SIZEOF(MyData.F4); //result is 10
SIZEOF(MyData.F5); //result is 9 -12 chars stored in 9
 bytes
SIZEOF(MyData.F6); //result is 13 -12 chars plus null
 terminator
Layout_People := RECORD
STRING15 first_name;
STRING15 middle_name;
STRING25 last_name;
STRING2 suffix;
STRING42 street;
STRING20 city;
STRING2 st;
STRING5 zip;
STRING1 sex;
STRING3 age;
STRING8 dob;
BOOLEAN age_flag;
UNSIGNED8 __filepos { virtual(fileposition)};
END;
File_People := DATASET('ecl_training::People', Layout_People,
 FLAT);
SIZEOF(File_People); //result is 147
SIZEOF(File_People.street); //result is 42
SIZEOF('abc' + '123'); //result is 6
SIZEOF(person.per_cid); //result is 9 - Person.per_cid is
 DATA9
Ver também: LENGTH
© 2020 HPCC Systems. All rights reserved
60
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Padronização de dados
© 2020 HPCC Systems. All rights reserved
61
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Padronização de dados
Exercício 5a
Especificação do exercício:
Primeiro, determine o intervalo de valores de dados no arquivo de definição UID_Persons que você criou anterior-
mente e use a função TABLE para criar um Recordset com os campos de dados em UID_Persons o mais compactados
possível. Use bibliotecas de strings built-in para converter todos os campos de nome pertinentes em maiúsculos.
Use o serviço de workflow PERSIST na definição TABLE para que os resultados não precisem ser recalculados no
uso subsequente.
Requisitos:
1. O arquivo de definição a ser criado para o dataset Persons padronizado é: STD_Persons.
2. O nome do arquivo PERSIST usado com a definição TABLE deve começar com ~CLASS, seguido pelas suas
iniciais, seguidas por PERSIST::STD_Persons, como neste exemplo:
 ~CLASS::XX::PERSIST::STD_Persons
Melhores práticas
1. Crie uma estrutura modular em STD_Persons e duas definições de exportação dentro do módulo que exportam os
novos RECORD (Layout) e TABLE (File) compactados.
2. Veja as possibilidades de armazenamento dos campos de data e zip.
3. Examine as bibliotecas de strings built-in e encontrará uma função de string apropriada usada para converter qualquer
string em maiúsculas. Use esta função no layout RECORD e verifique se todos os campos de nome apropriados no
dataset Persons são processados.
Comparação do resultado
Use uma janela do Builder para executar uma consulta SIZEOF simples e verifique se o resultado é 133 e, em segui-
da, execute uma consulta simples e verifique se o resultado parece razoável (todos os nomes convertidos em dados
numéricos compactados em maiúsculas parecem bons).
Exemplo:
IMPORT TrainingYourName;
SIZEOF(TrainingYourName.STD_Persons.Layout);
TrainingYourName.STD_Persons.File;
© 2020 HPCC Systems. All rights reserved
62
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Padronização de dados
Exercício 5b
Especificação do exercício:
Primeiro, determine o intervalo de valores de dados na definição UID_Account que você criou anteriormente e use
a função TABLE para criar um atributo Recordset com os campos de dados em UID_Account o mais compactado
possível. Use o serviço de workflow PERSIST na definição TABLE para que os resultados não precisem ser recalcu-
lados no uso subsequente.
Requisitos:
1. O arquivo de definição a ser criado para este exercício é: STD_Accounts
2. O nome do arquivo PERSIST usado com a definição TABLE deve começar com ~CLASS, seguido pelas suas
iniciais, seguidas por PERSIST::STD_Accounts, como neste exemplo:
 ~CLASS::XX::PERSIST::STD_Accounts
Melhores práticas
1. Crie uma estrutura MODULE e duas definições EXPORT dentro do módulo que exportam o novo RECORD (Lay-
out) e TABLE(File).
2. Veja as possibilidades de armazenamento de datas.
Comparação do resultado
Use uma janela do Builder para executar uma consulta SIZEOF simples e verifique se o resultado é 69, depois execute
uma consulta OUTPUT simples e verifique se o resultado parece razoável.
Exemplo:
IMPORT TrainingYourName;
SIZEOF(TrainingYourName.STD_Accounts.Layout);
TrainingYourName.STD_Accounts.File;
© 2020 HPCC Systems. All rights reserved
63
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
Criando tabelas lookup
© 2020 HPCC Systems. All rights reserved
64
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
ROLLUP
ROLLUP(recordset, condition, transform [, LOCAL] [, UNORDERED | ORDERED( bool ) ] [, STABLE |
UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
ROLLUP(recordset, transform, fieldlist [, LOCAL] [, UNORDERED | ORDERED( bool ) ] [, STABLE |
UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
ROLLUP(recordset, GROUP, transform [, UNORDERED | ORDERED( bool ) ] [, STABLE | UNSTABLE ] [,
PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
recordset O recordset a serprocessado, normalmente classificado na mesma ordem em que a condição ou
fieldlist será testada.
condition Uma expressão que define registros “duplicados”. As palavras-chave LEFT e RIGHT podem ser
usadas como qualificadores de dataset nos campos do recordset.
transform A função TRANSFORM é usada para acionar cada par de registros duplicados encontrado.
LOCAL Opcional. Especifica que a operação é realizada em cada nó de supercomputador de forma inde-
pendente, 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.
fieldlist Uma lista delimitada por vírgula de expressões ou campos no conjunto de registros que define
os registros “duplicados”. As palavras-chave WHOLE RECORD (ou apenas RECORD) devem
ser usadas para indicar todos os campos nessa estrutura, e/ou você pode usar a palavra-chave
EXCEPT para listar os campos a serem excluídos.
GROUP Especifica que o recordset é GROUPed e a operação ROLLUP irá gerar um único registro de
resultado para cada grupo. Se não for este o caso, ocorrerá um erro.
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: ROLLUP retorna um conjunto de registros.
A função ROLLUP é semelhante à função DEDUP , porém possui o acionamento da função transform para processar
cada par de registro duplicado. Isso permite recuperar informações valiosas do registro “duplicado” antes que ele seja
descartado. Dependendo de como você codifica o transform , ROLLUP pode manter o registro LEFT ou RIGHT , ou
qualquer mistura de dados de ambos.
A primeira forma de ROLLUP testa uma condição usando valores dos registros que seriam especificados como LEFT e
RIGHT para transform. Os registros são combinados se a condição for true (verdadeira). A segunda forma de ROLLUP
compara valores de registros adjacentes no recordset de entrada, combinando-os caso sejam iguais. Estas duas for-
mas adotarão um comportamento diferente se transform modificar alguns dos campos usados na condição de corre-
spondência (veja os exemplos abaixo).
© 2020 HPCC Systems. All rights reserved
65
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
Para o primeiro par de registros candidatos, o registro LEFT especificado para “transform” corresponde ao primeiro
registro do par, e o registro RIGHT o segundo. Para as correspondências subsequentes de mesmo valor, o registro
LEFT especificado corresponde ao registro de resultado do acionamento anterior do transform , e o registro RIGHT
o próximo registro no recordset, como descrito neste exemplo:
ds := DATASET([{1,10},{1,20},{1,30},{3,40},{4,50}], 
 {UNSIGNED r, UNSIGNED n});
d t(ds L, ds R) := TRANSFORM
 SELF.r := L.r + R.r;
 SELF.n := L.n + R.n;
END;
ROLLUP(ds, t(LEFT, RIGHT), r);
/* results in:
 3 60
 3 40
 4 50
*/
ROLLUP(ds, LEFT.r = RIGHT.r,t(LEFT, RIGHT));
/* results in:
 2 30
 1 30
 3 40
 4 50
 the third record is not combined because the transform modified the value.
*/
Requerimentos da Função TRANSFORM - ROLLUP
Para as formas 1 e 2 de ROLLUP, a função transform deve adotar pelo menos dois parâmetros: um registro LEFT e
um registro RIGHT , onde ambos devem estar no mesmo formato que o recordset. O formato do conjunto de registros
resultante também deve ser o mesmo que as entradas.
Para a forms 3 de ROLLUP, a função transform deve adotar pelo menos dois parâmetros: um registro LEFT
que deve estar no mesmo formato que o recordset, e um ROWS(LEFT) cujo formato deve ser um parâmetro
DATASET(RECORDOF(recordset)) . O formato do conjunto de registros resultante deve ser diferente das entradas.
Forma 1 do ROLLUP
A forma 1 é processada através de todos os registros no recordset , desempenhando a função transform apenas nos pares
de registros adjacentes onde a condition de correspondência é atingida (indicando registros duplicados) e passando
direto por todos os outros registros até o resultado.
Exemplo:
//a crosstab table of last names and the number of times they occur
MyRec := RECORD
 Person.per_last_name;
 INTEGER4 PersonCount := 1;
END;
LnameTable := TABLE(Person,MyRec); //create dataset to work with
SortedTable := SORT(LnameTable,per_las_name); //sort it first
MyRec Xform(MyRec L,MyRec R) := TRANSFORM
 SELF.PersonCount := L.PersonCount + 1;
 SELF := L; //keeping the L rec makes it KEEP(1),LEFT
// SELF := R; //keeping the R rec would make it KEEP(1),RIGHT
END;
XtabOut := ROLLUP(SortedTable,
 LEFT.per_last_name=RIGHT.per_last_name,
 Xform(LEFT,RIGHT));
© 2020 HPCC Systems. All rights reserved
66
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
Forma 2 do ROLLUP
A forma 2 é processada através de todos os registros no recordset , desempenhando a função transform apenas nos
pares de registros adjacentes onde todas as expressões na fieldlist são correspondidas (indicando registros duplicados)
e passando por todos os outros registros até o resultado. Esta forma permite usar o mesmo tipo de lógica de exclusão
de campo EXCEPT disponível para DEDUP.
Exemplo:
rec := {STRING1 str1,STRING1 str2,STRING1 str3};
ds := DATASET([{'a', 'b', 'c'},{'a', 'b', 'c'},
 {'a', 'c', 'c'},{'a', 'c', 'd'}], rec);
rec tr(rec L, rec R) := TRANSFORM
 SELF := L;
END;
Cat(STRING1 L, STRING1 R) := L + R;
r1 := ROLLUP(ds, tr(LEFT, RIGHT), str1, str2);
 //equivalent to LEFT.str1 = RIGHT.str1 AND
 // LEFT.str2 = RIGHT.str2
r2 := ROLLUP(ds, tr(LEFT, RIGHT), WHOLE RECORD, EXCEPT str3);
 //equivalent to LEFT.str1 = RIGHT.str1 AND
 // LEFT.str2 = RIGHT.str2
r3 := ROLLUP(ds, tr(LEFT, RIGHT), RECORD, EXCEPT str3); 
 //equivalent to LEFT.str1 = RIGHT.str1 AND
 // LEFT.str2 = RIGHT.str2
r4 := ROLLUP(ds, tr(LEFT, RIGHT), RECORD, EXCEPT str2,str3);
 //equivalent to LEFT.str1 = RIGHT.str1
r5 := ROLLUP(ds, tr(LEFT, RIGHT), RECORD);
 //equivalent to LEFT.str1 = RIGHT.str1 AND
 // LEFT.str2 = RIGHT.str2 AND
 // LEFT.str3 = RIGHT.str3
r6 := ROLLUP(ds, tr(LEFT, RIGHT), str1 + str2);
 //equivalent to LEFT.str1+LEFT.str2 = RIGHT.str1+RIGHT.str2
r7 := ROLLUP(ds, tr(LEFT, RIGHT), Cat(str1,str2));
 //equivalent to Cat(LEFT.str1,LEFT.str2) =
 // Cat(RIGHT.str1,RIGHT.str2 )
Forma 3 do ROLLUP
A forma 3 é uma forma especial de ROLLUP onde o segundo parâmetro especificado para transform é um GROUP e
o primeiro parâmetro é o primeiro registro nesse GROUP. Ela é processada através de todos os grupos no recordset,
gerando um registro de resultado para cada grupo. Funções agregadas podem ser usadas dentro de transform (tais
como TOPN ou CHOOSEN) no segundo parâmetro. O conjunto de registro de resultado não é agrupado. Esta forma
é implicitamente LOCAL devido ao agrupamento.
Exemplo:
inrec := RECORD
 UNSIGNED6 did;
END;
outrec := RECORD(inrec)
 STRING20 name;
 UNSIGNED score;
END;
nameRec := RECORD
 STRING20 name;
END;
finalRec := RECORD(inrec)
© 2020 HPCC Systems. All rights reserved
67
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
 DATASET(nameRec) names;
 STRING20 secondName;
END;
ds := DATASET([1,2,3,4,5,6], inrec);
dsg := GROUP(ds, ROW);
i1 := DATASET([ {1, 'Kevin', 10},{2, 'Richard', 5},
 {5,'Nigel', 2},
 {0, '', 0}], outrec);
i2 := DATASET([ {1, 'Kevin Halligan', 12},
 {2, 'Richard Charles', 15},
 {3, 'Blake Smith', 20},
 {5,'Nigel Hicks', 100},
 {0, '', 0}], outrec);
i3 := DATASET([ {1, 'Halligan', 8},
 {2, 'Richard', 8},
 {6, 'Pete', 4},
 {6, 'Peter', 8},
 {6, 'Petie', 1},
 {0, '', 0}], outrec);
j1 := JOIN( dsg,
 i1,
 LEFT.did = RIGHT.did,
 TRANSFORM(outrec, SELF := LEFT; SELF := RIGHT),
 LEFT OUTER, MANY LOOKUP);
j2 := JOIN( dsg,
 i2,
 LEFT.did = RIGHT.did,
 TRANSFORM(outrec, SELF := LEFT; SELF := RIGHT),
 LEFT OUTER,
 MANY LOOKUP);
j3 := JOIN( dsg,
 i3,
 LEFT.did = RIGHT.did,
 TRANSFORM(outrec, SELF := LEFT; SELF := RIGHT),
 LEFT OUTER,
 MANY LOOKUP);
combined := REGROUP(j1, j2, j3);
finalRec doRollup(outRec l, DATASET(outRec) allRows) :=
 TRANSFORM
 SELF.did := l.did;
 SELF.names := PROJECT(allRows(score != 0),
 TRANSFORM(nameRec, SELF := LEFT));
 SELF.secondName := allRows(score != 0)[2].name;
END;
results := ROLLUP(combined, GROUP, doRollup(LEFT,ROWS(LEFT)));
Ver também: Estrutura TRANSFORM, Estrutura RECORD, DEDUP, EXCEPT, GROUP
© 2020 HPCC Systems. All rights reserved
68
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
Exemplo de ROLLUP funcional
ROLLUP
Abra BWR_Training_Examples.ROLLUP_Example em uma janela ECL e envie esta consulta:
MyRec := RECORD
 STRING1 Value1;
 STRING1 Value2;
 UNSIGNED1 Value3;
END;
SomeFile := DATASET([{'C','G',1},
 {'C','C',2},
 {'A','X',3},
 {'B','G',4},
 {'A','B',5}],MyRec);
SortedTable := SORT(SomeFile,Value1);
OUTPUT(SortedTable);
RECORDOF(SomeFile) RollThem(SomeFile L, SomeFile R) := TRANSFORM
 SELF.Value3 := IF(L.Value3 < R.Value3,L.Value3,R.Value3);
 SELF.Value2 := IF(L.Value2 < R.Value2,L.Value2,R.Value2);
 SELF := L;
END;
RolledUpRecs := ROLLUP(SortedTable,
 LEFT.Value1 = RIGHT.Value1,
 RollThem(LEFT,RIGHT));
OUTPUT(RolledUpRecs );
 
/*
Processes as:
 LEFT vs. RIGHT
 1 (AX3) 2 (AB5) - match, run transform, output AB3
 1 (AB3) 3 (BG4) - no match, output BG4
 3 (BG4) 4 (CX1) - no match 
 4 (CX1) 5 (CC2) - match, run transform, output CC1
Result set is:
 Rec# Value1 Value2 Value3
 1 A B 3
 2 B G 4
 2 C C 1
*/
© 2020 HPCC Systems. All rights reserved
69
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
Diagrama de Exemplo Funcional ROLLUP
© 2020 HPCC Systems. All rights reserved
70
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Criando tabelas lookup
Exercício 6a
Especificação do exercício:
Crie uma BWR que usa ROLLUP para criar um novo arquivo de todos os valores exclusivos de City, State e ZIP do
recordset STD_Persons. Verifique se cada registro no arquivo OUTPUT final possui um identificador exclusivo.
Use os identificadores exclusivos existentes em STD_Persons para a nova tabela, garantindo que o identificador uti-
lizado seja o de menor valor para esse conjunto exclusivo de valores.
Requisitos:
1. O nome do arquivo de definição a ser criado para este exercício é: BWR_Rollup_CSZ.
2. O nome do arquivo OUTPUT deve começar com ~CLASS, , seguido pelas suas iniciais, seguidas por
OUT::LookupCSZ, como neste exemplo:
 ~CLASS::XX::OUT::LookupCSZ
Comparação do resultado
Use uma janela do Builder para executar a consulta e procure na lista de arquivos lógicos do ECL Watch o arquivo
recém-gerado. Verifique se o tamanho do arquivo é de cerca de 600.387 e se há 20.703 registros.
Exercício 6b
Especificação do exercício:
Defina a estrutura RECORD e a definição de DATASET para a tabela LookupCSZ que você acabou de criar no Exer-
cício 6a. Coloque a definição RECORD em uma estrutura MODULE, nomeando o Layout de definição na estrutura
MODULE. Coloque a definição DATASET na mesma estrutura MODULE, nomeando o arquivo de definição dentro
da estrutura.
Requisitos:
1. O nome da definição do arquivo EXPORT a ser criado para este exercício é: File_LookupCSZ
Comparação do resultado
Use uma janela do Builder para executar uma saída simples e verifique se o resultado parece razoável.
© 2020 HPCC Systems. All rights reserved
71
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Juntando arquivos
© 2020 HPCC Systems. All rights reserved
72
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
JOIN
JOIN(leftrecset, rightrecset, joincondition [, transform] [, jointype] [, joinflags] )
JOIN(setofdatasets, joincondition, transform, SORTED( fields) [, jointype] )
leftrecset O conjunto esquerdo dos registros para processamento.
rightrecset O conjunto direito dos registros para processamento. Esse pode ser um INDEX.
joincondition Uma expressão que especifica como combinar registros em leftrecset e rightrecset ou setof-
datasets (consulte as discussões de Lógica de combinação abaixo). Na expressão, a palavra-
chave LEFT é o qualificador de dataset para os campos no leftrecset e a palavra-chave RIGHT
é o qualificador do dataset para os campos no rightrecset.
transform Opcional. A função TRANSFORM para acionar cada par de registros para processamento. Se
omitida, JOIN retorna todos os campos de ambos leftrecset e rightrecset com o segundo de
qualquer campo de nome em duplicidade removido.
jointype Opcional. Se omitida, uma operação de junção interna; caso contrário, um dos tipos listados na
seção Tipos de JOIN abaixo.
joinflags Opcional. Qualquer opção (consulte a seção JOIN Options [OPÇÕES DE JOIN] abaixo) para
especificar exatamente como a operação JOIN é executada.
setofdatasets O SET de conjuntos de registro para processamento ([idx1,idx2,idx3]), normalmente INDEXes
(ÍNDiCES), em que todos precisam ter o mesmo formato.
SORTED Especifica a ordem de classificação de registros no setofdatasets de entrada, além da ordem de
classificação de resultado no conjunto de resultados.
fields Uma lista delimitada por vírgulas dos campos no setofdatasets, que precisa ser um subconjunto
da ordem de classificação de entrada. Todos esses campos precisam ser usados na joincondition
, uma vez que definem a ordem na qual os campos passam pela operação STEPPED.
Return: JOIN retorna um conjunto de registros.
A função JOIN produz um conjunto de resultados baseado na interseção de dois ou mais datasets ou indíces (conforme
determinado por joincondition).
JOIN em Dois Datasets
JOIN(leftrecset, rightrecset, joincondition [, transform] [, jointype] [, joinflags] )
A primeira forma de JOIN processa todos os pares de registros em leftrecset e rightrecset e avalia a condition
para localizar registros correspondentes. Se a condition e jointype especificarem que o par de registros se qualifica
para processamento, a função transform é executada, gerando o resultado.
JOIN classifica/distribui dinamicamente o leftrecset e rightrecset conforme necessário para realizar sua operação com
base na condition especificada; assim sendo , orecordset resultante não tem garantia de estar na mesma ordem que
os recordsets de entrada. Se JOIN realizar uma classificação dinâmica de seus recordsets de entrada, essa nova ordem
de classificação não pode ser usada para além da execução de JOIN. Esse princípio também se aplica a qualquer função
GROUPing – os registros são desagrupados automaticamente conforme necessário, exceto nas circunstâncias a seguir:
* Para junções LOOKUP e ALL, o GROUPing e a ordem de classificaçãode leftrecset são preservados
* Para junções KEYED, o GROUPing (mas não a ordem de classificação) do leftrecset é preservado.
© 2020 HPCC Systems. All rights reserved
73
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Lógica de Correspondência - JOIN
O registro que corresponde a joincondition é processado internamente em duas partes:
"equality" (hard
match)
Toda a lógica "LEFT.field = RIGHT.field" simples que define os registros correspondentes. Para
JOINs que usam chaves, todos esses precisam ser campos na chave para se qualificarem para
inclusão nessa parte. Se não houver uma parte de "igualdade" na lógica joincondition , um erro
"JOIN too complex" (operação JOIN muito complexa) será exibido.
"non-
equality" (soft
match)
Todos os outros critérios de correspondência na lógica joincondition , como expressões
"LEFT.field > RIGHT.field" ou qualquer lógica OR, que possam estar envolvidos na determi-
nação final de que qualquer registro leftrecset e rightrecset realmente coincidem.
Essa divisão de lógica interna permite que o código JOIN seja otimizado para máxima eficiência – primeiro a lógica
de "igualdade" é avaliada para proporcionar um resultado temporário que é então avaliado em relação a qualquer
"desigualdade" na joincondition correspondente.
Opções
As opções de joinflags a seguir podem ser especificadas para determinar exatamente como JOIN é executado.
[, PARTITION LEFT | PARTITION RIGHT | [MANY] LOOKUP [ FEW] ] | GROUPED | ALL | NOSORT
[ ( which ) ] | KEYED [ (index) [, UNORDERED ] ] | LOCAL | HASH ]][, KEEP(n) ] [, ATMOST( [ condition,
] n ) ] [, LIMIT( value [, SKIP | transform | FAIL ]) ] [, SKEW(limit [, target] ) [, THRESHOLD( size ) ] ] [,
SMART ] [, UNORDERED | ORDERED( bool ) ] [, STABLE | UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ]
[, ALGORITHM( name ) ]
PARTITION LEFT
| RIGHT
Especifica qual recordset proporciona os pontos de partição que determinam como os reg-
istros são classificados e distribuídos entre os nós do supercomputador. PARTITION RIGHT
especifica o rightrecset , enquanto PARTITION LEFT especifica o leftrecset. Se omitido,
PARTITION LEFT é o padrão.
[MANY] LOOKUP Especifica o rightrecset , sendo um arquivo relativamente pequeno de registros de consulta que
podem ser copiados completamente para cada nó. MANY não estiver presente, os registros
rightrecset têm uma relação de muitos para 0/1 com os registros em leftrecset (para cada
registro em leftrecset há no máximo 1 registro em rightrecset. Se MANY estiver presente, os
registros rightrecset têm uma relação de muitos para 0/muitos com os registros em leftrecset.
Essa opção permite que o otimizador evite a classificação desnecessária do leftrecset. Válido
apenas para os jointypes internos, LEFT OUTER ou LEFT ONLY. As opções ATMOST,
LIMIT e KEEP são suportadas em conjunto com MANYLOOKUP.
SMART Especifica para usar uma consulta na memória quando possível, mas usa uma operação de
junção distribuída se o dataset direito for muito grande.
FEW Especifica que o LOOKUP rightrecset possui poucos registros, de forma que pouca memória
é utilizada, permitindo que várias junções de consultas sejam incluídas no mesmo subgráfico
Thor.
GROUPED Especifica a mesma ação de MANY LOOKUP, mas preserva o agrupamento Usado princi-
palmente no motor de entrega rápida de dados. Válido apenas para os jointypes internos, LEFT
OUTER ou LEFT ONLY. As opções ATMOST, LIMIT e KEEP são suportadas em conjunto
com GROUPED.
ALL Especifica que o rightrecset é um arquivo pequeno que pode ser copiado completamente para
cada nó, o que permite que o compilador ignore a falta de qualquer parte de "igualdade" em re-
lação à condição; isso elimina o erro "JOIN too complex" (“operação JOIN muito complexa”)
que a condição normalmente produziria. Se uma parte de "igualdade" estiver presente, o JOIN
© 2020 HPCC Systems. All rights reserved
74
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
é executado internamente como MANY LOOKUP. A opção KEEP é suportada juntamente
com essa opção.
NOSORT Realiza o JOIN sem classificar dinamicamente as tabelas. Isso implica que leftrecset e/ou
rightrecset precisam ter sido previamente classificados e particionados com base nos campos
especificados em joincondition para que os registros possam ser facilmente combinados.
which Opcional. As palavras-chave LEFT ou RIGHT para indicar que leftrecset ou rightrecset foram
previamente classificados. Se omitidas, NOSORT assume que ambos leftrecset e rightrecset
foram classificados previamente.
KEYED Especifica o uso de acesso indexado em rightrecset (consulte INDEX).
index Opcional. O nome de um INDEX no rightrecset para um JOIN full-keyed (consulte abaixo).
Se omitido, indica que o rightrecset sempre será um INDEX (útil quando rightrecset é especi-
ficado como um parâmetro para uma função).
UNORDERED Opcional. Especifica que a operação KEYED JOIN não preserva a ordem de classificação do
leftrecset.
LOCAL Especifica que a operação é realizada em cada nó de supercomputador de forma independente,
sem exigir interação com todos os outros nós para obter dados; a operação mantém a dis-
tribuição de qualquer operação DISTRIBUTE anterior.
HASH Especifica um DISTRIBUTE implícito do leftrecset e rightrecset entre os nós de supercom-
putador com base na joincondition para que cada nó possa realizar seu trabalho com os dados
locais.
KEEP(n) Especifica o número máximo de registros correspondentes (n) a ser gerado no conjunto de
resultados. Se omitido, todas as correspondências são mantidas. Isso é útil nos casos em que
possa haver muitos pares correspondentes e caso você precise limitar o número no conjunto
de resultados. KEEP não é suportado para RIGHT EXTER, RIGHT ONLY, LEFT ONLY ou
FULL ONLY jointypes.
ATMOST Especifica o número máximo de registros correspondentes que, se excedido, elimina to-
das essas correspondências do conjunto de resultados. Isso é útil para situações nas quais
você elimina pares de registros com "excesso de correspondências" do conjunto de re-
sultados. ATMOST não é suportado para RIGHT EXTER ONLY ou FULL ONLY join-
types. Há duas formas: ATMOST(condição, n) – o máximo é computado apenas para a
condição. ATMOST(n) – o máximo é computado para toda a joincondition, exceto caso
KEYED seja usado na joincondition (caso no qual aspenas as expressões KEYED são us-
adas).Quando ATMOST é especificado (e o JOIN não é full-keyed ou half-keyed), a join-
condition e a condition podem incluir comparações de campo da string que usam indexação
de strings com um asterisco como o limite máximo, como neste exemplo: J1 := JOIN(dsL,d-
sR, LEFT.name[1..*]=RIGHT.name[3..*] AND LEFT.val < RIGHT.val, T(LEFT,RIGHT),
ATMOST(LEFT.name[1..*]=RIGHT.name[3..*],3)); TO asterisco indica correspondência do
máximo de caracteres necessários para reduzir o número de possíveis correspondências para
abaixo do número ATMOST (n).
condition Uma parte da expressão joincondition .
n Especifica o número máximo de correspondências permitidas.
LIMIT Especifica o número máximo de registros correspondentes que, se excedido, ocasiona a falha
da workunit ou elimina todas essas correspondências do conjunto de resultados. Isso é útil
para situações nas quais você elimina pares de registros com "excesso de correspondências"
do conjunto de resultados. Normalmente usado para JOINS KEYED e “Half-Keyed” (con-
sulte abaixo), LIMIT se difere de ATMOST principalmente por seu efeito em uma junção
LEFT OUTER, na qual um registro leftrecset com um número excessivo de registros corre-
spondentes seria tratado como não correspondente pelo ATMOST (o registro leftrecset estaria
no resultado sem registros rightrecset correspondentes), enquanto LIMIT faria com que toda
© 2020 HPCC Systems. All rights reserved
75
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
a workunit falhasse ou executaria o SKIP no registro (eliminando o registro leftrecset total-
mente do resultado). Se omitido, o padrãoé LIMIT(10000). O LIMIT é aplicado ao record set
que atende à parte de correspondência rígida ("equality") da joincondition , porém antes de a
correspondência suave ("desigualdade") da joincondition ser avaliada.
value O número máximo de correspondências permitido; LIMIT(0) é ilimitado.
SKIP Opcional. Especifica a eliminação de registros correspondentes que ultrapassam o valor máx-
imo do resultado LIMIT, em vez da falha da workunit.
transform Opcional. Especifica a emissão de um registro único produzido por transform em vez da falha
da workunit (similar à opção ONFAIL da função LIMIT).
FAIL Opcional. Especifica o uso do FAIL ação para configurar a mensagem de erro quando a worku-
nit falha.
SKEW Indica que você sabe que os dados para essa junção não serão espalhados uniformemente entre
os nós (serão distorcidos após ambos os arquivos terem sido distribuídos baseados na condition
da junção), e que você opta por substituir o padrão especificando seu próprio valor limite para
permitir que a workunit continue apesar da distorção. Só é válido em junções sem chave (a
opção KEYED não está presente e o rightrecset não é um INDEX).
limit Um valor entre zero (0) e um (1,0 = 100%) indicando a porcentagem máxima da distorção a
ser permitida antes que a workunit falhe (o padrão é 0,1 = 10%).
target Opcional. Um valor entre zero (0) e um (1,0 = 100%) indicando a porcentagem máxima de-
sejada da distorção a ser permitida (o padrão é 0,1 = 10%).
THRESHOLD Indica o tamanho mínimo de uma parte única do leftrecset ou rightrecset antes que o limite
de SKEW seja determinado. Só é válido em junções sem chave (a opção KEYED não está
presente e o rightrecset não é um INDEX).
size Um valor inteiro indicando o número mínimo de bytes para uma parte única.
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, especifica que a ordem do registro de resultado não é importante. Quando
for True, 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 threads numthreads .
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.
As opções a seguir são mutualmente exclusivas e só podem ser usadas para a exclusão das outras nessa lista.
PARTITION LEFT | PARTITION RIGHT | [MANY] LOOKUP | GROUPED | ALL | NOSORT | HASH
Além dessa lista, as opções KEYED e LOCAL também são mutualmente exclusivas com as opções acima listadas,
mas não umas com as outras. Quando ambas as opções KEYED e LOCAL são especificadas, apenas as partes INDEX
em cada nó são acessadas por esse nó.
Normalmente, o leftrecset deve ser maior que o rightrecset para evitar problemas de distorção (porque PARTITION
LEFT é o comportamento padrão). Se as opções LOOKUP ou ALL forem especificadas, o rightrecset precisa ser
pequeno o bastante para ser carregado na memória em cada nó e a operação é então implicitamente LOCAL. A opção
ALL não é prática se o rightrecset for maior que alguns poucos milhares de registros (devido ao número de compara-
© 2020 HPCC Systems. All rights reserved
76
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
ções necessário). O tamanho do rightrecset é irrelevante no caso de JOINs "half-keyed" e “full-keyed" (consulte a
discussão sobre Join Chaveado).
Use o SMART quando o dataset do lado direito provavelmente for pequeno o bastante para caber na memória, mas
sem garantias de tal.
Se aparecer um erro similar a esse:
“error: 1301: Pool memory exhausted:..."
significa que o rightrecset é muito grande e uma operação LOOKUP JOIN não deve ser usada. Uma operação SMART
JOIN pode ser uma boa opção neste caso.
JOINS KEYEDs
Uma JOIN full-keyed usa a opção KEYED, e a joincondition precisa ser baseada nos campos index. Na verdade, a
junção é feita entre o leftrecset e o index no rightrecset – o index precisa do campo de ponteiro de registro do dataset
(virtual(fileposition)) para buscar corretamente os registros do rightrecset. A operação join KEYED típica especifica
apenas o rightrecset para o TRANSFORM.
Se a rightrecset for um INDEX, a operação é uma JOIN “half-keyed”. Normalmente, o INDEX em uma JOIN de
“half-keyed” contém campos de “payload", que frequentemente eliminam a necessidade de leitura do dataset de base.
Se esse for o caso, o INDEX de “payload" não precisa do campo de ponteiro de registro (virtual(fileposition)) do
dataset declarado. Para uma JOIN de half-keyed, a joincondition pode usar apenas as palavras-chave KEYED e WILD
que estão disponíveis para uso apenas nos filtros INDEX.
Para ambos os tipos de junção KEYED (com chave), qualquer GROUPing dos conjuntos de registro de base permanece
inalterado. Consulte KEYED e WILD para ler uma discussão sobre a filtragem de INDEX.
Lógica do Join
A operação JOIN segue a seguinte lógica:
1. Classificação/distribuição de registro para obter possíveis correspondências nos mesmos nós.
As opções PARTITION LEFT, PARTITION RIGHT, LOOKUP, ALL, NOSORT, KEYED, HASH e LOCAL indicam
como isso acontece. Essas opções são mutualmente exclusivas; apenas uma pode ser especificada, sendo PARTITION
LEFT o padrão. SKEW e THRESHOLD podem modificar o comportamento solicitado. LOOKUP também possui o
efeito de deduplicação de rightrecset pela joincondition.
2. Correspondência de registros.
A joincondition, LIMIT e ATMOST determinam como isso é feito.
Um limite implícito de 10000 é adicionado quando não há LIMIT especificado E o seguinte é verdadeiro:
Não há limite especificado para ATMOST E e não é um LEFT ONLY JOIN E (ou nenhum limite KEEP especificado
OU o JOIN que tem um postfilter).
3. Determina quais correspondências devem ser especificadas para transform.
O jointype determina isso.
4. Gera registros de resultados através da função TRANSFORM.
O parâmetro transform implícito ou explícito determina isso.
© 2020 HPCC Systems. All rights reserved
77
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
5. Filtrar registros de resultados com SKIP.
Se transform para um par de registros resultar em SKIP, então o registro de resultado não é contado em nenhum total
da opção KEEP.
6. Limitar registros de resultados com KEEP.
Quaisquer registros de resultados para um determinado registro leftrecset acima e além do valor KEEP permitido
são descartados. Em uma junção FULLOUTER , registros rightrecset que não correspondem a nenhum registro são
tratados como se todos fossem correspondências de diferentes registros leftrecset padrão (isto é, o contador KEEP é
reiniciado para cada um).
Requerimentos da Função TRANSFORM - JOIN
A função transform : um registro LEFT formatado como leftrecset e/ou um registro RIGHT formatado como o
rightrecset (que pode estar em diferentes formatos). O formato do conjunto de registros resultante não precisa ser o
mesmo que nenhum conjunto de registros de entrada.
Tipos de Join: Dois DATASETS
Os jointypes a seguir produzem os seguintes tipos de resultados com base na correspondência de registros produzida
por joincondition:
inner (default) Apenas os registros existentes em ambos leftrecset e rightrecset.
LEFT OUTER No mínimo um registro para cada um no leftrecset.
RIGHT OUTER No mínimo um registro para cada um no rightrecset.
FULL OUTER No mínimo um registro para cada um no leftrecset e rightrecset.
LEFT ONLY Um registro para cada registro leftrecset sem correspondência no rightrecset.
RIGHT ONLY Um registro para cada registro rightrecset sem correspondência no leftrecset.
FULL ONLY Um registro para cada registro leftrecsete rightrecset sem correspondência no conjunto de reg-
istro oposto.
Exemplo:
outrec := RECORD
 people.id;
 people.firstname;
 people.lastname;
END;
RT_folk := JOIN(people(firstname[1] = 'R'),
 people(lastname[1] = 'T'),
 LEFT.id=RIGHT.id,
 TRANSFORM(outrec,SELF := LEFT));
OUTPUT(RT_folk);
//*********************** Half KEYED JOIN example:
peopleRecord := RECORD
 INTEGER8 id;
 STRING20 addr;
END;
peopleDataset := DATASET([{3000,'LONDON'},{3500,'SMITH'},
 {30,'TAYLOR'}], peopleRecord);
PtblRec doHalfJoin(peopleRecord l) := TRANSFORM
© 2020 HPCC Systems. All rights reserved
78
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
 SELF := l;
END;
FilledRecs3 := JOIN(peopleDataset, SequenceKey,
 LEFT.id=RIGHT.sequence,doHalfJoin(LEFT));
FilledRecs4 := JOIN(peopleDataset, AlphaKey,
 LEFT.addr=RIGHT.Lname,doHalfJoin(LEFT));
//******************* Full KEYED JOIN example:
PtblRec := RECORD
 INTEGER8 seq;
 STRING2 State;
 STRING20 City;
 STRING25 Lname;
 STRING15 Fname;
END;
PtblRec Xform(person L, INTEGER C) := TRANSFORM
 SELF.seq := C;
 SELF.State := L.per_st;
 SELF.City := L.per_full_city;
 SELF.Lname := L.per_last_name;
 SELF.Fname := L.per_first_name;
END;
Proj := PROJECT(Person(per_last_name[1]=per_first_name[1]),
 Xform(LEFT,COUNTER));
PtblOut := OUTPUT(Proj,,'~RTTEMP::TestKeyedJoin',OVERWRITE);
Ptbl := DATASET('RTTEMP::TestKeyedJoin',
 {PtblRec,UNSIGNED8 __fpos {virtual(fileposition)}},
 FLAT);
AlphaKey := INDEX(Ptbl,{lname,fname,__fpos},
 '~RTTEMPkey::lname.fname');
SeqKey := INDEX(Ptbl,{seq,__fpos},'~RTTEMPkey::sequence');
Bld1 := BUILD(AlphaKey ,OVERWRITE);
Bld2 := BUILD(SeqKey,OVERWRITE);
peopleRecord := RECORD
 INTEGER8 id;
 STRING20 addr;
END;
peopleDataset := DATASET([{3000,'LONDON'},{3500,'SMITH'},
 {30,'TAYLOR'}], peopleRecord);
joinedRecord := RECORD
 PtblRec;
 peopleRecord;
END;
joinedRecord doJoin(peopleRecord l, Ptbl r) := TRANSFORM
 SELF := l;
 SELF := r;
END;
FilledRecs1 := JOIN(peopleDataset, Ptbl,LEFT.id=RIGHT.seq,
 doJoin(LEFT,RIGHT), KEYED(SeqKey));
FilledRecs2 := JOIN(peopleDataset, Ptbl,LEFT.addr=RIGHT.Lname,
 doJoin(LEFT,RIGHT), KEYED(AlphaKey));
SEQUENTIAL(PtblOut,Bld1,Bld2,OUTPUT(FilledRecs1),OUTPUT(FilledRecs2))
JOIN com Set of Datasets
JOIN(setofdatasets, joincondition, transform, SORTED( fields) [, jointype] [, UNORDERED | ORDERED( bool ) ]
[, STABLE | UNSTABLE ] [, PARALLEL [ ( numthreads ) ] ] [, ALGORITHM( name ) ] )
A segunda forma de JOIN é similar à função MERGEJOIN no sentido de que usa um SET OF DATASETs como
o seu primeiro parâmetro. Isso oferece a possibilidade de unir mais de dois datasets em uma única operação.
© 2020 HPCC Systems. All rights reserved
79
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Lógica de Correspondência de Registros
O registro correspondente a joincondition pode conter duas partes: uma condição STEPPED que pode opcionalmente
ser ANDed com condições sem STEPPED. A expressão STEPPED contém as principais expressões de igualdade dos
campos da opção SORTED (componentes à direita podem ser comparações de intervalo se os valores de intervalo
não dependem das linhas LEFT e RIGHT), juntamente com ANDed, usando LEFT e RIGHT como qualificadores de
dataset. Caso não esteja presente, a condição STEPPED é deduzida dos campos especificados pela opção SORTED.
A ordem dos datasets em setofdatasets pode ser importante para a maneira pela qual joincondition é avaliado. A
joincondition é duplicada entre pares adjacentes de datasets, o que significa que essa joincondition:
 LEFT.field = RIGHT.field
quando aplicada em um setofdatasets de três datasets, é logicamente equivalente a:
 ds1.field = ds2.field AND ds2.field = ds3.field
Requisitos de função do TRANSFORM - JOIN setof-
datasets
A função transform precisa usar no mínimo um parâmetro que precisa ter uma das duas formas:
LEFT Formatado como qualquer um dos setofdatasets. Isso indica o primeiro dataset no setofdatasets.
ROWS(LEFT) Formatado como qualquer um dos setofdatasets. Isso indica um conjunto de registro composto
de todos os registros de qualquer dataset no setofdatasets que corresponde ao joincondition
– isso não pode incluir todos os datasets no setofdatasets, dependendo de qual jointype for
especificado.
O formato do conjunto final de registros de resultado precisa ser o mesmo que os datasets de entrada.
Tipos de Join: setofdatasets
Os jointypes a seguir produzem os seguintes tipos de resultados com base na correspondência de registros produzida
por joincondition:
INNER Esse é o padrão se nenhum jointype for especificado. Apenas os registros presentes em todos
os datasets no setofdatasets.
LEFT OUTER No mínimo um registro para cada registro no primeiro dataset no setofdatasets.
LEFT ONLY Um registro para cada um no primeiro dataset no setofdatasets para o qual não há corre-
spondência em nenhum dos datasets subsequentes.
MOFN(min [,max]) Um registro para cada registro com registros correspondentes no número mínimo de datasets
adjacentes no setofdatasets. Se o número máximo for especificado, o registro não será incluí-
do se o número máximo de correspondências de datasets for excedido.
Exemplo:
Rec := RECORD,MAXLENGTH(4096)
 STRING1 Letter;
 UNSIGNED1 DS;
 UNSIGNED1 Matches := 0;
 UNSIGNED1 LastMatch := 0;
 SET OF UNSIGNED1 MatchDSs := [];
END;
© 2020 HPCC Systems. All rights reserved
80
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
ds1 := DATASET([{'A',1},{'B',1},{'C',1},{'D',1},{'E',1}],Rec);
ds2 := DATASET([{'A',2},{'B',2},{'H',2},{'I',2},{'J',2}],Rec);
ds3 := DATASET([{'B',3},{'C',3},{'M',3},{'N',3},{'O',3}],Rec);
ds4 := DATASET([{'A',4},{'B',4},{'R',4},{'S',4},{'T',4}],Rec);
ds5 := DATASET([{'B',5},{'V',5},{'W',5},{'X',5},{'Y',5}],Rec);
SetDS := [ds1,ds2,ds3,ds4,ds5];
Rec XF(Rec L,DATASET(Rec) Matches) := TRANSFORM
 SELF.Matches := COUNT(Matches);
 SELF.LastMatch := MAX(Matches,DS);
 SELF.MatchDSs := SET(Matches,DS);
 SELF := L;
END;
j1 := JOIN(SetDS,
 STEPPED(LEFT.Letter=RIGHT.Letter),
 XF(LEFT,ROWS(LEFT)),SORTED(Letter));
j2 := JOIN(SetDS,
 STEPPED(LEFT.Letter=RIGHT.Letter),
 XF(LEFT,ROWS(LEFT)),SORTED(Letter),LEFT OUTER);
j3 := JOIN(SetDS,
 STEPPED(LEFT.Letter=RIGHT.Letter), 
 XF(LEFT,ROWS(LEFT)),SORTED(Letter),LEFT ONLY);
j4 := JOIN(SetDS,
 STEPPED(LEFT.Letter=RIGHT.Letter),
 XF(LEFT,ROWS(LEFT)),SORTED(Letter),MOFN(3));
j5 := JOIN(SetDS,
 STEPPED(LEFT.Letter=RIGHT.Letter),
 XF(LEFT,ROWS(LEFT)),SORTED(Letter),MOFN(3,4));
OUTPUT(j1);
OUTPUT(j2);
OUTPUT(j3);
OUTPUT(j4);
OUTPUT(j5);
Ver também: Estrutura TRANSFORM,Estrutura RECORD,SKIP ,STEPPED, KEYED/WILD, MERGEJOIN
© 2020 HPCC Systems. All rights reserved
81
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Exemplo de JOIN funcional
JOIN
Abra BWR_Training_Examples.JOIN_Example em uma janela ECL e envie esta consulta:
MyRec := RECORD
 STRING1 Value1;
 STRING1 Value2;
END;
LeftFile := DATASET([{'C','A'},
 {'X','B'},
 {'A','C'}],MyRec);
RightFile := DATASET([{'C','X'},
 {'B','Y'},
 {'A','Z'}],MyRec);
MyOutRec := RECORD
 STRING1 Value1;
 STRING1 LeftValue2;
 STRING1 RightValue2;
END;
MyOutRec JoinThem(MyRec L, MyRec R) := TRANSFORM
 SELF.Value1 := IF(L.Value1<>'', L.Value1, R.Value1);
 SELF.LeftValue2 := L.Value2;
 SELF.RightValue2 := R.Value2;
END;
InnerJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT));
LOutJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT),LEFTOUTER);
ROutJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT),RIGHT OUTER);
FOutJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT),FULL OUTER);
LOnlyJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT),LEFT ONLY);
ROnlyJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT),RIGHT ONLY);
FOnlyJoinedRecs := JOIN(LeftFile,RightFile,LEFT.Value1 = RIGHT.Value1,
 JoinThem(LEFT,RIGHT),FULL ONLY);
OUTPUT(InnerJoinedRecs,,NAMED('Inner'));
OUTPUT(LOutJoinedRecs,,NAMED('LeftOuter'));
OUTPUT(ROutJoinedRecs,,NAMED('RightOuter'));
OUTPUT(FOutJoinedRecs,,NAMED('FullOuter'));
OUTPUT(LOnlyJoinedRecs,,NAMED('LeftOnly'));
OUTPUT(ROnlyJoinedRecs,,NAMED('RightOnly'));
OUTPUT(FOnlyJoinedRecs,,NAMED('FullOnly'));
/* InnerJoinedRecs result set is: 
 Rec# Value1 LeftValue2 RightValue2
 1 A C Z
 2 C A X
 
LOutJoinedRecs result set is:
 Rec# Value1 LeftValue2 RightValue2
 1 A C Z
© 2020 HPCC Systems. All rights reserved
82
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
 2 C A X
 3 X B
ROutJoinedRecs result set is:
 Rec# Value1 LeftValue2 RightValue2
 1 A C Z
 2 B Y
 3 C A X
FOutJoinedRecs result set is:
 Rec# Value1 LeftValue2 RightValue2
 1 A C Z
 2 B Y
 3 C A X
 4 X B
LOnlyJoinedRecs result set is:
 Rec# Value1 LeftValue2 RightValue2
 1 X B
ROnlyJoinedRecs result set is:
 Rec# Value1 LeftValue2 RightValue2
 1 B Y
FOnlyJoinedRecs result set is:
 Rec# Value1 LeftValue2 RightValue2
 1 B Y
 2 X B
*/
© 2020 HPCC Systems. All rights reserved
83
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Diagrama de exemplo funcional JOIN
© 2020 HPCC Systems. All rights reserved
84
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
INTFORMAT
INTFORMAT(expression, width, mode)
expression A expressão que especifica o valor inteiro a ser formatado.
width O tamanho da string na qual o valor será alinhado à direita.
mode O formato tipo: 0 = preenchimento em branco, 1 = preenchimento com zero.
Return: INTFORMAT retorna um único valor.
A função INTFORMAT retorna o valor da expressão formatada como string justificada à direita dos caracteres de
largura .
Exemplo:
val := 123456789;
OUTPUT(INTFORMAT(val,20,1));
 //formats as '00000000000123456789'
OUTPUT(INTFORMAT(val,20,0));
 //formats as ' 123456789'
Ver também: REALFORMAT
© 2020 HPCC Systems. All rights reserved
85
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Exercício 7a
Especificação do exercício:
Crie uma BWR que produza um arquivo de saída de STD_Persons com os valores City, State e Zip removidos e
substituídos por links para File_LookupCSZ.
Depois que o arquivo for produzido, defina sua estrutura RECORD e o DATASET para uso posterior. Coloque a
definição RECORD em uma estrutura MODULE, nomeando a definição de Layout na estrutura MODULE. Coloque
a definição DATASET na mesma estrutura MODULE, nomeando a definição de File dentro da estrutura.
Requisitos:
1. Os nomes dos arquivos de definição a serem criados para este exercício são:
BWR_File_Persons_Slim
File_Persons_Slim
2. O nome do arquivo OUTPUT deve começar com ~CLASS, seguido pelas suas iniciais, seguidas por OUT::Person-
s_Slim, como neste exemplo:
 ~CLASS::XX::OUT::Persons_Slim
Comparação do resultado
Use uma janela do Builder para executar a consulta e procure na lista de arquivos lógicos do ECL Watch Logical Files
o arquivo recém-gerado. Verifique se o tamanho é de cerca de 94.236.800 e se há 841.400 registros.
© 2020 HPCC Systems. All rights reserved
86
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Exercício 7b
Especificação do exercício:
Crie uma BWR que reproduza um arquivo de saída cujos dados e estrutura duplicam exatamente o arquivo File_Per-
sons original com o qual começamos. Use a opção LOOKUP no JOIN para unir as tabelas File_Persons_Slim e
File_LookupCSZ e criar o resultado.
Requisitos:
1. O nome do arquivo de definição a ser criado para este exercício é:
BWR_RejoinPersons
2. O nome do arquivo OUTPUT deve começar com ~CLASS, seguido pelas suas iniciais, seguidas por OUT::Person-
s_Rejoined , como neste exemplo:
 ~CLASS::XX::OUT::Persons_Rejoined
3. Você precisará restaurar os campos de data e compactá-los de volta aos seus tipos de dados originais.
4. Você precisará converter os nomes em maiúsculos de volta em capitalização apenas de título (Dica: use a função
da biblioteca String ToTitleCase no TRANSFORM).
5. Não se esqueça dos campos MaritalStatus e DependentCount.
6. Execute os requisitos de transformação de dados usando sua estrutura TRANSFORM.
Comparação do resultado
Escreveremos o código ECL no próximo exercício de laboratório para realizar uma comparação entre o arquivo "re-
joined" e o arquivo original Persons que passou pelo processo de spray.
© 2020 HPCC Systems. All rights reserved
87
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Juntando arquivos
Exercício 7c
Especificação do exercício:
Crie código BWR para combinar (append) o arquivo Person original que foi submetido ao spray com a tabela “rejoined"
que criamos no Exercício 7be, em seguida, faça a deduplicação dos registros combinados por todos os campos. Envie
os resultados de todos os registros de deduplicação, que devem ser zero para os 2 arquivos combinados.
Requisitos:
1. O nome do atributo a ser criado para este exercício é:
BWR_RejoinPersonsCompare
2. Crie um DATASET para a tabela que você criou no Exercício 7b.
3. ANEXAR a tabela Person original submetida ao spray com a tabela rejoined no Exercício 7b.
4. ORDENAR a tabela anexada usando a palavra-chave WHOLE RECORD (ou apenas RECORD) para indicar que
todos os campos nessa estrutura precisam ser classificados.
5. DEDUP as tabelas anexadas classificadas usando a palavra-chave WHOLE RECORD (ou apenas RECORD) para
indicar que todos os campos nessa estrutura serão comparados.
Comparação do resultado
Abra uma nova janela do Builder e produza a diferença das contagens do conjunto de registros deduplicados e a
contagem original da tabela rejoined. Os resultados para cada uma das contagens da tabela devem ser zero.
© 2020 HPCC Systems. All rights reserved
88
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Soluções para exercícios de
laboratório
Exercício 1
Solução - File_Persons.ECL:
EXPORT File_Persons := MODULE
 EXPORT Layout := RECORD
 UNSIGNED8 ID;
 STRING15 FirstName;
 STRING25 LastName;
 STRING15 MiddleName;
 STRING2 NameSuffix;
 STRING8 FileDate;
 UNSIGNED2 BureauCode;
 STRING1 MaritalStatus;
 STRING1 Gender;
 UNSIGNED1 DependentCount;
 STRING8 BirthDate;
 STRING42 StreetAddress;
 STRING20 City;
 STRING2 State;
 STRING5 ZipCode;
 END;
 EXPORT File := DATASET('~CLASS::BMF::Intro::Persons', Layout,FLAT);
END;
Isso ilustra o uso da forma mais simples da estrutura RECORD, onde tudo o que você define é o tipo e o nome do
valor de cada campo. Essa forma é mais comumente usada para definir o layout de campo dos DATASETs, embora
também possa ser usada para definir o formato de saída de uma função TRANSFORM. Existem duas outras formas
maiscomplexas usadas pela função TABLE e outra que define estruturas de conjuntos de dados filhos que serão
introduzidas em outra aula.
As opções FLAT e THOR no DATASET são sinônimos que indicam que não há delimitadores de campo no arquivo,
diferentemente dos arquivos CSV ou XML. Os registros podem ter comprimento-fixo, com ou sem delimitadores de
registro (carriage return and/or line feed), ou comprimento variável, com ou sem delimitadores de registro (dependendo
de como a variabilidade é definida). Os registros que contêm dados de comprimento-fixo seguidos por um número
variável de registros de conjuntos de dados filhos de comprimento fixo não precisam de delimitadores de registro,
enquanto os registros de comprimento variável geralmente exigem.
© 2020 HPCC Systems. All rights reserved
89
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 1 (continuação)
Solução - File_Accounts.ECL:
EXPORT File_Accounts := MODULE
 EXPORT Layout := RECORD
 UNSIGNED8 PersonID;
 STRING8 ReportDate;
 STRING2 IndustryCode;
 UNSIGNED4 Member;
 STRING8 OpenDate;
 STRING1 TradeType;
 STRING1 TradeRate;
 UNSIGNED1 Narr1;
 UNSIGNED1 Narr2;
 UNSIGNED4 HighCredit;
 UNSIGNED4 Balance;
 UNSIGNED2 Terms;
 UNSIGNED1 TermTypeR;
 STRING20 AccountNumber;
 STRING8 LastActivityDate;
 UNSIGNED1 Late30Day;
 UNSIGNED1 Late60Day;
 UNSIGNED1 Late90Day;
 STRING1 TermType;
 END;
 EXPORT File := DATASET('~CLASS::BMF::Intro::Accounts',Layout,CSV);
END;
Essa é novamente a forma mais simples da estrutura RECORD, mas ilustra o conceito de definir os campos de texto
de dados numéricos contidos no arquivo CSV como tipos inteiros. Isso tem a vantagem de não exigir a conversão
explícita de tipos com uma operação TABLE ou PROJECT para produzir seus tipos intrínsecos binários.
A opção CSV no DATASET indica que há algum tipo de campo e delimitadores de registro no arquivo. Esta declaração
de arquivo usa os valores padrão (vírgulas e CR/LF), mas qualquer delimitador pode ser especificado usando o conjunto
de csvoptions disponíveis (consulte o PDF de Referência a Linguagem).
© 2020 HPCC Systems. All rights reserved
90
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 2a
Solução - XTAB_Persons_Gender.ECL:
IMPORT $;
r := RECORD
 $.File_Persons.File.Gender;
 INTEGER cnt := COUNT(GROUP);
 END;
EXPORT XTAB_Persons_Gender := TABLE($.File_Persons.File,r,Gender);
Essa é a forma mais simples de relatório crosstab, com um único campo "group by" na função TABLE duplicado na
estrutura RECORD. A função COUNT usa a palavra-chave GROUP para agregar o número de registros File_Persons
que contêm cada valor único do campo Gender.
Observe também que apresentamos neste exercício de laboratório o uso da qualificação $ (cifrão), que permite que
você faça referência facilmente aos atributos contidos no mesmo módulo.
Exercício 2b
Solução - XTAB_Accounts_HighCredit_MaxMin.ECL:
IMPORT $;
layout_min_max := RECORD
 Min_Value := MIN(GROUP, $.File_Accounts.File.HighCredit);
 Max_Value := MAX(GROUP, $.File_Accounts.File.HighCredit);
END;
EXPORT XTAB_Accounts_HighCredit_MaxMin := TABLE($.File_Accounts.File, layout_min_max);
 
A chave deste relatório crosstab é a falta de campos "group by" na função TABLE ou na estrutura RECORD. Isso
garante que File_Accounts seja tratado como um grupo único, permitindo que as funções MAX e MIN determinem
os valores mais alto e mais baixo do campo HighCredit no arquivo.
© 2020 HPCC Systems. All rights reserved
91
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 3a
Solução - BWR_Persons_BureauCode_Cardinality:
IMPORT $;
t := TABLE($.File_Persons.File,
 {$.File_Persons.File.BureauCode});
dt := DISTRIBUTE(t,HASH32(BureauCode));
sdt := SORT(dt,BureauCode,LOCAL);
dsdt := DEDUP(sdt,BureauCode,LOCAL);
COUNT(dsdt);
Esse código usa o formato "vertical slice" de TABLE para limitar a operação apenas ao campo em que estamos in-
teressados em trabalhar. A função DISTRIBUTE usa a função HASH32 para distribuir uniformemente os registros
da TABELA, para que as operações SORT e DEDUP possam usar a opção LOCAL, o que garante o desempenho
ideal da contagem.
Exercício 3b
Solução - BWR_Persons_DependentCount_Population:
IMPORT $;
c1 := COUNT($.File_Persons.File(DependentCount=0));
c2 := COUNT($.File_Persons.File);
d := DATASET([{'Total Records',c2},
 {'Recs=0',c1},
 {'Population Pct',(INTEGER)(((c2-c1)/c2)*100.0)}],
 {STRING15 valuetype,INTEGER val});
OUTPUT(d);
Esse código simplesmente usa uma condição de filtro para determinar o número de registros com um valor “nu-
lo" (nesse caso, zero). A técnica interessante aqui é o uso de um DATASET inline para produzir o resultado da saída.
Exercício 3c
Solução - BWR_Persons_DP:
IMPORT $,STD;
Persons := $.File_Persons.File;
profileResults := STD.DataPatterns.Profile(Persons);
bestrecord := STD.DataPatterns.BestRecordStructure(Persons);
OUTPUT(profileResults, ALL, NAMED('profileResults'));
OUTPUT(bestrecord, ALL, NAMED('BestRecord'));
Esse código perfila o conjunto de dados de treinamento Persons usando as FUNCTIONMACROs built-in DataPat-
terns Profile e BestRecordStructure.
© 2020 HPCC Systems. All rights reserved
92
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 3d
Solução - BWR_StatePopulation:
IMPORT $,Visualizer;
Persons := $.File_Persons.File;
Rec := RECORD
 Persons.State;
 UNSIGNED4 StateCnt := COUNT(GROUP);
END;
OUTPUT(TABLE(Persons,Rec,State),NAMED('choro_usStates'));
Visualizer.Choropleth.USStates('usStates',,'choro_usStates');
© 2020 HPCC Systems. All rights reserved
93
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 4a
Solução - UID_Persons.ECL:
IMPORT $;
Layout_People_RecID := RECORD
 UNSIGNED4 RecID;
 $.File_Persons.Layout;
END;
Layout_People_RecID IDRecs($.File_Persons.Layout L,INTEGER C) := TRANSFORM
 SELF.RecID := C;
 SELF := L;
END;
EXPORT UID_Persons := PROJECT($.File_Persons.File,IDRecs(LEFT,COUNTER)) 
 : PERSIST('~CLASS::BMF::PERSIST::UID_Persons');
Usar PROJECT para atribuir IDs de registro exclusivos é simples de codificar, mas geralmente menos eficiente que a
técnica ITERATE usada no próximo exercício. A operação PROJECT inicia o COUNTER em cada nó apenas quando
o número de registros em cada nó anterior for conhecido. Isso pode ser feito rapidamente se os registros do número
estiverem sendo acessados do disco, mas a simples adição de um filtro de registro pode atrasar consideravelmente
o processo.
© 2020 HPCC Systems. All rights reserved
94
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 4b
Solução - UID_Accounts.ECL:
IMPORT $,Std;
Layout_Accts_RecID := RECORD
 UNSIGNED4 RecID := 0;
 $.File_Accounts.File;
END;
AcctsTbl := TABLE($.File_Accounts.File,Layout_Accts_RecID);
Layout_Accts_RecID IDRecs(Layout_Accts_RecID L, 
 Layout_Accts_RecID R) := TRANSFORM
 SELF.RecID := IF(L.RecID=0,std.system.thorlib.node()+1,L.RecID+CLUSTERSIZE);
 SELF := R;
END;
EXPORT UID_Accounts := ITERATE(AcctsTbl,IDRecs(LEFT,RIGHT),LOCAL)
 :PERSIST('~CLASS::BMF::PERSIST::UID_Accounts');
O uso da função node() e a constante CLUSTERSIZE ECL permitem ao ITERATE usar a opção LOCAL, que garante
a execução mais rápida possível. DISTRIBUTE não é necessário porque o único requisito é que cada registro receba
um número exclusivo e a ordem em si é irrelevante.
© 2020 HPCC Systems. All rights reserved
95
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 5a
Solução - STD_Persons.ECL:
IMPORT $,Std;
EXPORT STD_Persons := MODULE
EXPORT Layout :=RECORD
 $.UID_Persons.RecID;
 $.UID_Persons.ID;
 STRING15 FirstName := std.Str.ToUpperCase($.UID_Persons.FirstName);
 STRING25 LastName := std.Str.ToUpperCase($.UID_Persons.LastName);
 STRING1 MiddleName := std.Str.ToUpperCase($.UID_Persons.MiddleName);
 STRING2 NameSuffix := std.Str.ToUpperCase($.UID_Persons.NameSuffix);
 UNSIGNED4 FileDate := (UNSIGNED4)$.UID_Persons.FileDate;
 $.UID_Persons.BureauCode;
 $.UID_Persons.Gender;
 UNSIGNED4 BirthDate := (UNSIGNED4)$.UID_Persons.BirthDate;
 $.UID_Persons.StreetAddress;
 $.UID_Persons.City;
 $.UID_Persons.State;
 UNSIGNED3 ZipCode := (UNSIGNED3)$.UID_Persons.ZipCode;
 END;
EXPORT File := TABLE($.UID_Persons,Layout)
 : PERSIST('~CLASS::BMF::PERSIST::STD_Persons');
END;
O uso de UNSIGNED4 para conter datas economiza quatro bytes por campo de data, enquanto o UNSIGNED3 para
o ZipCode economiza mais dois. Após examinar os campos dos dados de Persons, descobrimos que MiddleName
sempre possui 1 caractere e a função built-in string ToUpperCase interna converte todos os campos relacionados a
nomes em maiúsculas.
© 2020 HPCC Systems. All rights reserved
96
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 5b
Solução - STD_Accounts.ECL:
IMPORT $;
EXPORT STD_Accounts := MODULE
EXPORT Layout := RECORD
 $.UID_Accounts.RecID;
 $.UID_Accounts.PersonID;
 UNSIGNED4 ReportDate := (UNSIGNED4)$.UID_Accounts.ReportDate;
 $.UID_Accounts.IndustryCode;
 $.UID_Accounts.Member;
 UNSIGNED4 OpenDate := (UNSIGNED4)$.UID_Accounts.OpenDate;
 $.UID_Accounts.TradeType;
 $.UID_Accounts.TradeRate;
 $.UID_Accounts.Narr1;
 $.UID_Accounts.Narr2;
 $.UID_Accounts.HighCredit;
 $.UID_Accounts.Balance;
 $.UID_Accounts.Terms;
 $.UID_Accounts.TermTypeR;
 $.UID_Accounts.AccountNumber;
 UNSIGNED4 LastActivityDate := (UNSIGNED4)$.UID_Accounts.LastActivityDate;
 $.UID_Accounts.Late30Day;
 $.UID_Accounts.Late60Day;
 $.UID_Accounts.Late90Day;
 $.UID_Accounts.TermType;
 END;
 EXPORT File := TABLE($.UID_Accounts,Layout)
 : PERSIST('~CLASS::BMF::PERSIST::STD_Accounts');
END;
A decisão de EXPORTAR uma estrutura RECORD depende se ela será usada em outras definições de arquivo ECL
posteriormente. Caso contrário, não há necessidade de EXPORTÁ-LO. No entanto, essa decisão não precisa ser tomada
no momento em que você a criou - você sempre pode promover sua visibilidade posteriormente. Nesse caso, essa
estrutura RECORD será referenciada posteriormente.
© 2020 HPCC Systems. All rights reserved
97
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 6a
Solução - BWR_Rollup_CSZ.ECL:
IMPORT $;
Layout_T_recs := RECORD
 UNSIGNED4 CSZ_ID := $.STD_Persons.File.RecID;
 $.STD_Persons.File.City;
 $.STD_Persons.File.State;
 $.STD_Persons.File.Zipcode;
 END;
T_recs := TABLE($.STD_Persons.File,Layout_T_recs);
S_recs := SORT(T_recs,ZipCode,State,City);
Layout_T_recs RollCSV(Layout_T_recs L, Layout_T_recs R) := TRANSFORM
 SELF.CSZ_ID := IF(L.CSZ_ID < R.CSZ_ID,L.CSZ_ID,R.CSZ_ID);
 SELF := L;
END;
Rollup_CSZ := ROLLUP(S_Recs,
 LEFT.Zipcode=RIGHT.Zipcode AND
 LEFT.State=RIGHT.State AND
 LEFT.City=RIGHT.City,
 RollCSV(LEFT,RIGHT));
OUTPUT(Rollup_CSZ,,'~CLASS::BMF::OUT::LookupCSZ',OVERWRITE)
O código BWR (Builder Window Runnable) sempre contém pelo menos uma ação (nesse caso, um OUTPUT). Tam-
bém requer que todas as definições ECL exportadas existentes usadas no repositório sejam totalmente qualificadas,
pois o objetivo do código BWR é executá-lo na Janela do Builder. IMPORT $ é um atalho para referenciar explicita-
mente o nome do módulo, e as definições devem ter nomes totalmente qualificados para desambiguá-los. Isso explica
por que os campos definidos na estrutura RECORD Layout_T_recs são todos totalmente qualificados.
A função Roll_CSZ TRANSFORM foi projetada para garantir que o campo CSZ_ID que é mantido seja o número
RecID mais baixo da tabela STD_Persons. Essa é uma técnica padrão a ser usada sempre que você precisar de números
de registro exclusivos e não se importa se eles são sequenciais ou não. Ao derivá-los de um conjunto de valores já
exclusivos, você pode eliminar uma etapa extra do PROJECT para gerar IDs de registro.
© 2020 HPCC Systems. All rights reserved
98
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 6b
Solução - File_LookupCSZ.ECL:
EXPORT File_LookupCSZ := MODULE
 EXPORT Layout := RECORD
 UNSIGNED4 CSZ_ID;
 STRING20 City;
 STRING2 State;
 UNSIGNED3 ZipCode;
 END;
 SHARED Filename := '~CLASS::BMF::OUT::LookupCSZ';
 EXPORT File := DATASET(Filename,Layout,FLAT);
END;
Essa estrutura RECORD simplesmente define o layout do campo do arquivo de pesquisa. A declaração do DATASET
disponibiliza o arquivo de pesquisa para uso em outras operações.
© 2020 HPCC Systems. All rights reserved
99
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 7a
Solução - File_Persons_Slim.ECL:
IMPORT $;
EXPORT File_Persons_Slim := MODULE
 EXPORT Layout := RECORD
 RECORDOF($.STD_Persons.File) AND NOT [City,State,ZipCode];
 // equivalent to:
 // $.STD_Persons.RecID;
 // $.STD_Persons.ID;
 // $.STD_Persons.FirstName;
 // $.STD_Persons.LastName;
 // $.STD_Persons.MiddleName;
 // $.STD_Persons.NameSuffix;
 // $.STD_Persons.FileDate;
 // $.STD_Persons.BureauCode;
 // $.STD_Persons.Gender;
 // $.STD_Persons.BirthDate;
 // $.STD_Persons.StreetAddress;
 UNSIGNED4 CSZ_ID;
 END;
 SHARED Filename := '~CLASS::BMF::OUT::Persons_Slim';
 EXPORT File := DATASET(Filename,Layout,FLAT);
END;
Esse layout herda a maioria das definições de campo de STD_Persons e adiciona o campo CSZ_ID que fornece o link
entre o registro File_Persons_Slim e o registro File_LookupCSZ relacionado. Este módulo também define o arquivo
resultante para uso nas definições subsequentes.
© 2020 HPCC Systems. All rights reserved
100
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 7a (continuação)
Solução - BWR_File_Persons_Slim.ECL:
IMPORT $;
$.File_Persons_Slim.Layout Slimdown($.STD_Persons.File L,
 $.File_LookupCSZ.File R) := TRANSFORM
 SELF.CSZ_ID := R.CSZ_ID;
 SELF := L;
END;
SlimRecs := JOIN($.STD_Persons.File,
 $.File_LookupCSZ.File,
 LEFT.zipcode=RIGHT.zipcode AND
 LEFT.city=RIGHT.city AND
 LEFT.state=RIGHT.state,
 Slimdown(LEFT,RIGHT),LEFT OUTER, LOOKUP);
 
OUTPUT(SlimRecs,,'~CLASS::BMF::OUT::Persons_Slim',overwrite);
A operação JOIN aqui é a chave, permitindo que STD_Persons e File_LookupCSZ se combinem para criar os registros
File_Persons_Slim. O uso da opção LEFT OUTER evita a perda de dados do arquivo Persons original definido no Ex-
ercício 2. A opção LOOKUP também é usada no JOIN, uma vez que existem apenas 20.703 registros File_LookupCSZ,
que ocupariam apenas 600.387 bytes de memória em cada nó quando totalmente carregados. Como cada nó possui
pelo menos dois gigabytes de RAM, é razoável usar LOOKUP para carregar completamente esse arquivo.
© 2020 HPCC Systems. All rights reserved
101
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 7b
Solução - BWR_RejoinPersons.ECL:
IMPORT $,Std;
$.File_Persons.Layout Bulkup($.File_Persons_Slim.Layout L,
 $.File_LookupCSZ.Layout R) := TRANSFORM
 SELF.zipcode := IF(R.zipcode=0,'',INTFORMAT(R.zipcode,5,1));
 SELF.FileDate := IF(L.FileDate=0,'',(STRING8)L.FileDate);
 SELF.BirthDate := IF(L.BirthDate=0,'',(STRING8)L.BirthDate);
 SELF.MaritalStatus := '';
 SELF.DependentCount := 0;
 SELF.FirstName := Std.Str.ToTitleCase(L.FirstName);
 SELF.LastName:= Std.Str.ToTitleCase(L.LastName);
 SELF.MiddleName := Std.Str.ToTitleCase(L.MiddleName);
 SELF.NameSuffix := Std.Str.ToTitleCase(L.NameSuffix);
 SELF := R;
 SELF := L;
END;
BulkRecs := JOIN($.File_Persons_Slim.File,
 $.File_LookupCSZ.File,
 LEFT.CSZ_ID=RIGHT.CSZ_ID,
 Bulkup(LEFT,RIGHT),LEFT OUTER,LOOKUP);
OUTPUT(BulkRecs,,'~CLASS::BMF::OUT::Persons_Rejoined',overwrite);
O objetivo deste exercício é recriar exatamente o arquivo Persons original que foi definido no Exercício 2, juntando
o File_Persons_Slim e o File_LookupCSZ. Além de formatar corretamente as datas e o zip code, a função TRANS-
FORM Bulkup também precisa manipular os dois campos "não preenchidos" que não foram executados. Além disso,
restauramos os campos de nome para capitalização apenas de título e usando a biblioteca de funções de string ToTi-
tleCase. Este é um ótimo uso de funções em um TRANSFORM para obter o resultado desejado.
© 2020 HPCC Systems. All rights reserved
102
Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
Soluções para exercícios de laboratório
Exercício 7c
Solução - BWR_RejoinPersonsCompare.ECL:
IMPORT $;
//DATASETS of renormed tables created in Exercise 7B
RJPersons := DATASET('~CLASS::BMF::OUT::Persons_Rejoined',$.File_Persons.Layout,THOR);
//SORT the APPENDed records, and then DEDUP.
AppendRecs := $.File_Persons.File + RJPersons;
SortRecs := SORT(AppendRecs,WHOLE RECORD);
DedupPersons := DEDUP(SortRecs,WHOLE RECORD);
//Count of rejoined records created in Exercise 7B
OUTPUT(COUNT(RJPersons),NAMED('Input_Recs_Persons'));
//This result should be zero
OUTPUT(COUNT(DedupPersons)-count(RJPersons),NAMED('Dup_Persons'));
O objetivo deste exercício é comparar a "rejoined table" no Exercício 7B com o arquivo Persons original que aplicamos
no início deste curso. Usando o operador de acréscimo (+), primeiro combinamos os dois arquivos. Em seguida,
classificamos a tabela anexada por todos os campos no layout Persons, usando a cláusula WHOLE RECORD para
simplificar nosso código. Finalmente, DEDUPlicamos a tabela anexada (novamente usando WHOLE RECORD para
comparar nossos pares) e a contagem de nosso resultado DEDUP deve ser igual à contagem de nosso registro reunido,
que resulta em zero duplicidades.
© 2020 HPCC Systems. All rights reserved
103
	Manual de Treinamento de Introdução ao ECL (Parte 2) - ETL com ECL
	Table of Contents
	Visão Geral
	Introdução
	O que é THOR?
	Visão Geral do Processo ETL
	ECL em ETL - 4 Objetivos Principais
	Convenções de Documentação
	Linguagem ECL
	Nomes
	Código de Exemplo
	Ações
	Trechos da Linguagem ECL
	Definir e organizar seus dados
	Exercício 1: Organize suas definições de dados
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Relatórios de tabulação
	TABLE
	Relatórios Cross-Tab
	Uma CrossTab Simples
	Um exemplo mais complexo
	Um Exemplo Estatístico
	Exemplo de tabulação funcional
	Relatórios de tabulação
	Exercício 2a
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Exercício 2b
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Mais relatórios de avaliação de dados
	DISTRIBUTE "Randômico"
	“Random” DISTRIBUTE
	Expressão DISTRIBUTE
	DISTRIBUTE baseado em Index
	DISTRIBUTE baseado em Skew
	HASH32
	Exercício 3a
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Exercício 3b
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Padrões dos Dados
	Instalação
	A FunctionMacro Profile
	Visualização
	Instalação
	Categorias de visualização
	Funções de visualização global (helper)
	Visualizações "ordinais" bidimensionais
	Visualizações "lineares" bidimensionais
	Visualizações multidimensionais
	Método de Visualização Geoespacial
	Método de Visualização Geoespacial
	Início Rápido
	Exercício 3c
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Exercício 3d
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Transformações simples
	Estrutura TRANSFORM
	Definições dos Atributos de Transformação
	Funções TRANSFORM
	TRANSFORMs em linha
	TRANSFORMs abreviado em linha
	PROJECT
	Requisitos da Função TRANSFORM - PROJECT
	PROJECT - Módulo
	Exemplo funcional de PROJECT
	PROJECT
	Diagrama de exemplo funcional do PROJECT
	ITERATE
	Requerimentos da Função TRANSFORM - ITERATE
	Exemplo funcional ITERATE
	ITERATE
	Diagrama de Exemplo Funcional ITERATE
	PERSIST
	Estrutura SERVICE
	Node
	Nodes
	Exercício 4a
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Exercício 4b
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Padronização de dados
	SIZEOF
	Exercício 5a
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Exercício 5b
	Especificação do exercício:
	Requisitos:
	Melhores práticas
	Comparação do resultado
	Criando tabelas lookup
	ROLLUP
	Requerimentos da Função TRANSFORM - ROLLUP
	Forma 1 do ROLLUP
	Forma 2 do ROLLUP
	Forma 3 do ROLLUP
	Exemplo de ROLLUP funcional
	ROLLUP
	Diagrama de Exemplo Funcional ROLLUP
	Exercício 6a
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Exercício 6b
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Juntando arquivos
	JOIN
	JOIN em Dois Datasets
	Lógica de Correspondência - JOIN
	Opções
	JOINS KEYEDs
	Lógica do Join
	Requerimentos da Função TRANSFORM - JOIN
	Tipos de Join: Dois DATASETS
	JOIN com Set of Datasets
	Lógica de Correspondência de Registros
	Requisitos de função do TRANSFORM - JOIN setofdatasets
	Tipos de Join: setofdatasets
	Exemplo de JOIN funcional
	JOIN
	Diagrama de exemplo funcional JOIN
	INTFORMAT
	Exercício 7a
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Exercício 7b
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Exercício 7c
	Especificação do exercício:
	Requisitos:
	Comparação do resultado
	Soluções para exercícios de laboratório
	Exercício 1
	Solução - File_Persons.ECL:
	Exercício 1 (continuação)
	Solução - File_Accounts.ECL:
	Exercício 2a
	Solução - XTAB_Persons_Gender.ECL:
	Exercício 2b
	Solução - XTAB_Accounts_HighCredit_MaxMin.ECL:
	Exercício 3a
	Solução - BWR_Persons_BureauCode_Cardinality:
	Exercício 3b
	Solução - BWR_Persons_DependentCount_Population:
	Exercício 3c
	Solução - BWR_Persons_DP:
	Exercício 3d
	Solução - BWR_StatePopulation:
	Exercício 4a
	Solução - UID_Persons.ECL:
	Exercício 4b
	Solução - UID_Accounts.ECL:
	Exercício 5a
	Solução - STD_Persons.ECL:
	Exercício 5b
	Solução - STD_Accounts.ECL:
	Exercício 6a
	Solução - BWR_Rollup_CSZ.ECL:
	Exercício 6b
	Solução - File_LookupCSZ.ECL:
	Exercício 7a
	Solução - File_Persons_Slim.ECL:
	Exercício 7a (continuação)
	Solução - BWR_File_Persons_Slim.ECL:
	Exercício 7b
	Solução - BWR_RejoinPersons.ECL:
	Exercício 7c
	Solução - BWR_RejoinPersonsCompare.ECL: